Beispiel #1
1
func (m *Muxer) writeAudioFrame(frame *C.AVFrame) bool {
	for C.av_audio_fifo_size(m.fifo) < 1024 { // generate & store in fifo
		C.fill_audio_frame(frame, m.audioStream.stream.codec)
		frame_size := frame.nb_samples
		if C.av_audio_fifo_realloc(m.fifo, C.av_audio_fifo_size(m.fifo)+frame_size) < 0 {
			return false
		}
		if C.av_audio_fifo_write(m.fifo, (*unsafe.Pointer)(unsafe.Pointer(&frame.data[0])), frame_size) < frame_size {
			return false
		}
	}
	got_packet := C.int(0)
	for C.av_audio_fifo_size(m.fifo) >= 1024 { // read & encode & write
		frame_size := C.min(C.av_audio_fifo_size(m.fifo), m.audioStream.stream.codec.frame_size)
		output_frame := C.alloc_audio_frame(m.audioStream.stream.codec)
		if C.av_audio_fifo_read(m.fifo, (*unsafe.Pointer)(unsafe.Pointer(&output_frame.data[0])), frame_size) < frame_size {
			C.av_frame_free(&output_frame)
			return false
		}
		pkt := C.AVPacket{}
		C.av_init_packet(&pkt)
		output_frame.pts = C.int64_t(m.audioStream.ts)
		m.audioStream.ts += int(m.audioStream.stream.codec.frame_size)
		if C.avcodec_encode_audio2(m.audioStream.stream.codec, &pkt, frame, &got_packet) < 0 {
			C.av_free_packet(&pkt)
			return false
		}
		if got_packet == 0 {
			continue
		}
		C.av_packet_rescale_ts(&pkt, m.audioStream.stream.codec.time_base, m.audioStream.stream.time_base)
		pkt.stream_index = m.audioStream.stream.index
		if C.av_interleaved_write_frame(m.context, &pkt) < 0 {
			return false
		}
	}
	return true
}
Beispiel #2
0
func (id *Capture) Read(frame *C.AVFrame) error {
	if frame == (*C.AVFrame)(null) {
		return fmt.Errorf("buffer error")
	}
	pkt := C.AVPacket{}
	C.av_init_packet(&pkt)
	defer C.av_free_packet(&pkt)
	if C.av_read_frame(id.context, &pkt) < 0 {
		return fmt.Errorf("read frame error")
	}
	if int(pkt.stream_index) != id.index {
		return fmt.Errorf("not video frame")
	}
	got_frame := C.int(0)
	if C.avcodec_decode_video2(id.codec, id.frame, &got_frame, &pkt) < 0 {
		return fmt.Errorf("decode frame error")
	}
	if got_frame != 0 {
		if C.sws_scale(id.sws, (**C.uint8_t)(&(id.frame.data[0])), &id.frame.linesize[0], 0, id.codec.height, &frame.data[0], &frame.linesize[0]) >= 0 {
			return nil
		}
		return fmt.Errorf("scale error")
	}
	return fmt.Errorf("no frame out")
}
func (dpx *Demultiplexer) Start() {
	for true {
		dpx.Packet = new(C.AVPacket)
		C.av_init_packet(dpx.Packet)

		if C.av_read_frame(dpx.Ds.Ctx, dpx.Packet) >= 0 {
			C.av_dup_packet(dpx.Packet)
		} else {
			println("end of file reached, closing channels")
			for i := 0; i < len(*dpx.tracks); i++ {
				print("closing channel ")
				println(i)
				close((*dpx.tracks)[i].stream)
			}
			break
		}
		var re Packet

		re.Pts = int64(dpx.Packet.pts)
		re.Dts = int64(dpx.Packet.dts)
		re.Size = int(dpx.Packet.size)
		re.Data = make([]byte, re.Size)
		data := (*(*[1 << 30]byte)(unsafe.Pointer(dpx.Packet.data)))[0:dpx.Packet.size]
		for i := 0; i < re.Size; i++ {
			re.Data[i] = data[i]
		}
		re.Stream = int(dpx.Packet.stream_index)
		re.Flags = int(dpx.Packet.flags)
		re.Duration = int(dpx.Packet.duration)
		re.Pos = int64(dpx.Packet.pos)
		C.av_free_packet(dpx.Packet)
		(*dpx.tracks)[re.Stream].stream <- re
	}
	//re * Packet
}
Beispiel #4
0
func NewPacket() *Packet {
	p := &Packet{}

	C.av_init_packet(&p.avPacket)

	p.avPacket.data = nil
	p.avPacket.size = 0

	return p
}
Beispiel #5
0
func (m *H264Encoder) Encode(img *image.YCbCr) (out h264Out, err error) {
	var f *C.AVFrame
	if img == nil {
		f = nil
	} else {
		if img.SubsampleRatio != m.Pixfmt {
			err = errors.New("image pixfmt not match")
			return
		}
		if img.Rect.Dx() != m.W || img.Rect.Dy() != m.H {
			err = errors.New("image size not match")
			return
		}
		f = m.m.f
		f.data[0] = (*C.uint8_t)(unsafe.Pointer(&img.Y[0]))
		f.data[1] = (*C.uint8_t)(unsafe.Pointer(&img.Cb[0]))
		f.data[2] = (*C.uint8_t)(unsafe.Pointer(&img.Cr[0]))
		f.linesize[0] = (C.int)(img.YStride)
		f.linesize[1] = (C.int)(img.CStride)
		f.linesize[2] = (C.int)(img.CStride)
	}

	C.av_init_packet(&m.m.pkt)
	r := C.avcodec_encode_video2(m.m.ctx, &m.m.pkt, f, &m.m.got)
	defer C.av_free_packet(&m.m.pkt)
	if int(r) < 0 {
		err = errors.New("encode failed")
		return
	}
	if m.m.got == 0 {
		err = errors.New("no picture")
		return
	}
	if m.m.pkt.size == 0 {
		err = errors.New("packet size == 0")
		return
	}

	out.Data = make([]byte, m.m.pkt.size)
	C.memcpy(
		unsafe.Pointer(&out.Data[0]),
		unsafe.Pointer(m.m.pkt.data),
		(C.size_t)(m.m.pkt.size),
	)
	out.Key = (m.m.pkt.flags & C.AV_PKT_FLAG_KEY) != 0

	return
}
Beispiel #6
0
func (m *Muxer) writeVideoFrame(frame *C.AVFrame) bool {
	if m.capture.Read(frame) != nil {
		return false
	}
	if m.display != nil {
		m.display.Render(frame)
	}
	pkt := C.AVPacket{}
	C.av_init_packet(&pkt)
	frame.pts = C.int64_t(m.videoStream.ts)
	m.videoStream.ts++
	got_packet := C.int(0)
	if C.avcodec_encode_video2(m.videoStream.stream.codec, &pkt, frame, &got_packet) < 0 {
		C.av_free_packet(&pkt)
		return false
	}
	if got_packet == 0 {
		return false
	}
	C.av_packet_rescale_ts(&pkt, m.videoStream.stream.codec.time_base, m.videoStream.stream.time_base)
	pkt.stream_index = m.videoStream.stream.index
	return C.av_interleaved_write_frame(m.context, &pkt) == 0
}
func (c *Decoder) decodeAudio(p Packet) *Frame {
	packet := new(C.AVPacket)
	C.av_init_packet(packet)
	defer C.av_free_packet(packet)

	packet.pts = C.int64_t(p.Pts)
	packet.dts = C.int64_t(p.Dts)
	packet.size = C.int(p.Size)
	packet.data = (*C.uint8_t)(unsafe.Pointer(&p.Data[0]))
	packet.stream_index = C.int(p.Stream)
	packet.flags = C.int(p.Flags)
	packet.duration = C.int(p.Duration)
	packet.pos = C.int64_t(p.Pos)
	//size:=packet.size;
	samples_size := C.int(C.AVCODEC_MAX_AUDIO_FRAME_SIZE)
	//bps := C.av_get_bits_per_sample_fmt(c.Ctx.sample_fmt) >> 3;

	outbuf := (*C.uint8_t)(C.av_malloc(C.uint(samples_size)))
	defer C.av_free(unsafe.Pointer(outbuf))
	C.avcodec_decode_audio3(c.Ctx, (*C.int16_t)(unsafe.Pointer(outbuf)), &samples_size, packet)
	//println(data_len)
	return nil
}
Beispiel #8
0
func (file *MediaFile) StartDecoding() {
	for _, i := range file.DecodedStreams {
		go file.Streams[i].decode()
	}

	go func() {
	get_packets:
		for packet := range file.packets {
			if packet == nil {
				break get_packets
			}
			for _, i := range file.DecodedStreams {
				if packet.stream_index == C.int(i) {
					file.Streams[i].packets <- packet
					continue get_packets
				}
			}
			C.av_free_packet(packet)
		}
		for _, i := range file.DecodedStreams {
			file.Streams[i].packets <- nil
		}
	}()

	go func() {
		for {
			packet := new(C.AVPacket)
			C.av_init_packet(packet)
			if C.av_read_frame(file.fmtctx, packet) < 0 {
				// assume EOF
				file.packets <- nil
				return
			}
			file.packets <- packet
		}
	}()
}
func (dpx *Demultiplexer) ReadPacket(re *Packet) bool {
	dpx.Packet = new(C.AVPacket)

	C.av_init_packet(dpx.Packet)
	defer C.av_free_packet(dpx.Packet)
	if C.av_read_frame(dpx.Ds.Ctx, dpx.Packet) >= 0 {
		C.av_dup_packet(dpx.Packet)
	} else {
		return false
	}
	re.Pts = int64(dpx.Packet.pts)
	re.Dts = int64(dpx.Packet.dts)
	re.Size = int(dpx.Packet.size)
	re.Data = make([]byte, re.Size)
	data := (*(*[1 << 30]byte)(unsafe.Pointer(dpx.Packet.data)))[0:dpx.Packet.size]
	for i := 0; i < re.Size; i++ {
		re.Data[i] = data[i]
	}
	re.Stream = int(dpx.Packet.stream_index)
	re.Flags = int(dpx.Packet.flags)
	re.Duration = int(dpx.Packet.duration)
	re.Pos = int64(dpx.Packet.pos)
	return true
}
Beispiel #10
0
func av_init_packet2(packet *avPacket) {
	//if(packet==nil){
	//packet=new(AVPacket)
	//}
	C.av_init_packet((*C.AVPacket)(unsafe.Pointer(packet)))
}
Beispiel #11
0
func av_init_packet(packet *Packet) {
	if packet.avpacket == nil {
		packet.avpacket = new(C.AVPacket)
	}
	C.av_init_packet(packet.avpacket)
}
Beispiel #12
0
//Initialize optional fields of a packet with default values.
func (p *Packet) AvInitPacket() {
	C.av_init_packet((*C.struct_AVPacket)(p))
}
Beispiel #13
0
func main() {

	var (
		fmt_ctx          *C.AVFormatContext
		video_stream_idx C.int
		pkt              C.AVPacket
		fn               string
	)
	flag.StringVar(&fn, "i", fn, "Input filename")
	flag.Parse()
	if fn == "" {
		flag.PrintDefaults()
		os.Exit(1)
	}
	cfn := C.CString(fn)
	defer C.free(unsafe.Pointer(cfn))
	C.av_register_all()
	if err := C.avformat_open_input(&fmt_ctx, cfn, nil, nil); err < 0 {
		log.Fatalf("Could not open source file %s, %d\n", fn, err)
	}
	// The smd codecs aren't too happy with missing PTS
	fmt_ctx.flags |= C.AVFMT_FLAG_GENPTS
	defer C.avformat_close_input(&fmt_ctx)
	if err := C.avformat_find_stream_info(fmt_ctx, nil); err < 0 {
		log.Fatalf("Could not find stream information: %d", err)
	}
	if err := open_codec_context(&video_stream_idx, fmt_ctx, C.AVMEDIA_TYPE_VIDEO); err < 0 {
		log.Fatalf("Could not open codec context: %d", err)
	}
	log.Printf("fmt_ctx: %+v", fmt_ctx)
	streams := (*[32]*C.AVStream)(unsafe.Pointer(fmt_ctx.streams))
	log.Printf("video stream codec: %+v", streams[video_stream_idx].codec.codec_id)

	log.Printf("time_base: %+v", streams[video_stream_idx].time_base)
	num := 1000000 * float64(streams[video_stream_idx].time_base.num)
	den := float64(streams[video_stream_idx].time_base.den)

	var codec C.ismd_codec_type_t
	switch vc := streams[video_stream_idx].codec.codec_id; vc {
	case C.AV_CODEC_ID_H264:
		codec = C.ISMD_CODEC_TYPE_H264
	case C.AV_CODEC_ID_MPEG1VIDEO:
		fallthrough
	case C.AV_CODEC_ID_MPEG2VIDEO:
		codec = C.ISMD_CODEC_TYPE_MPEG2
	case C.AV_CODEC_ID_MPEG4:
		codec = C.ISMD_CODEC_TYPE_MPEG4
	default:
		log.Fatalf("Unhandled video codec: %d", vc)
	}

	Init(codec, C.GDL_PLANE_ID_UPP_C)
	defer Destroy()

	C.av_init_packet(&pkt)
	pkt.data = nil
	pkt.size = 0

	running := true
	go func() {
		os.Stdin.Read(make([]byte, 1))
		running = false
	}()
	frame := 0
	for running && C.av_read_frame(fmt_ctx, &pkt) >= 0 {
		orig_pkt := pkt
		wrote := false
		for pkt.stream_index == video_stream_idx && (pkt.size > 0) {
			pts := num * float64(pkt.pts) / den
			WriteToInputPort(uintptr(unsafe.Pointer(pkt.data)), C.size_t(pkt.size), pts, 32*1024)
			wrote = true
			break
		}
		if wrote {
			frame++
			if frame%100 == 0 {
				var stat C.ismd_vidrend_stats_t
				C.ismd_vidrend_get_stats(m_video_render, &stat)
				log.Printf("%+v", stat)
			}
		}

		C.av_free_packet(&orig_pkt)
	}
}
Beispiel #14
0
//Initialize optional fields of a packet with default values.
//void 	av_init_packet (AVPacket *pkt)
func Av_init_packet(p *AVPacket) {
	C.av_init_packet((*C.struct_AVPacket)(p))
}
func (c *Decoder) decodeVideo(p Packet) *Frame {
	if !c.Valid {
		//println("try to decode with an invalid Decoder")
		return nil
	}
	//println("try to decode with a valid Decoder")

	packet := new(C.AVPacket)
	C.av_init_packet(packet)
	defer C.av_free_packet(packet)

	packet.pts = C.int64_t(p.Pts)
	packet.dts = C.int64_t(p.Dts)
	packet.size = C.int(p.Size)
	//packet.data=&C.uint8_t(make([]byte, p.Size)[0])
	//myBytes:=make([]byte,p.Size);
	/*
	   var pb *byte
	   if(len(p.Data)>0){
	   //println("Data > 0")
	   pb=&p.Data[0]
	   }*/
	packet.data = (*C.uint8_t)(unsafe.Pointer(&p.Data[0]))
	//    println(p.Data)
	//    println(pb)
	//    println(packet.data)
	//    packet.data=unsafe.Pointer(p.Data)
	//    for i:= 0; i < re.Size; i++ {
	//      re.Data[i] = data[i];
	//    }
	packet.stream_index = C.int(p.Stream)
	packet.flags = C.int(p.Flags)
	packet.duration = C.int(p.Duration)
	packet.pos = C.int64_t(p.Pos)

	height := c.Ctx.height
	width := c.Ctx.width
	var frame *Frame = new(Frame)

	numBytes := C.avpicture_get_size(0, width, height)
	//_size = numBytes;
	//_buffer := (*C.uint8_t) (C.av_malloc(C.uint(numBytes)));
	if numBytes > 0 {
		var buffer []byte = make([]byte, numBytes)
		var pbuffer *byte = &buffer[0]
		// C.memset((*C.uint8_t)(_buffer), 0, C.size_t(numBytes));
		// Assign appropriate parts of buffer to image planes
		//var picture * C.AVPicture=(*C.AVPicture)(unsafe.Pointer(frame))
		//println(frame)
		//println(picture)
		//:=&frame
		//854x480
		C.avpicture_fill((*C.AVPicture)(unsafe.Pointer(frame)), (*C.uint8_t)(unsafe.Pointer(pbuffer)), 0, width, height)
	}

	//frameFinished:=C.int(0)
	var frameFinished *C.int = new(C.int)
	//bytes_decoded:=

	C.avcodec_decode_video2(c.Ctx, (*C.AVFrame)(unsafe.Pointer(frame)), frameFinished, packet)
	frame.pts = packet.pts
	//frame.dts=packet.dts

	/*
	   //C.avcodec_decode_video2(nil,nil,nil,nil)

	   header:=fmt.Sprintf("P5\n%d %d\n255\n",width,height)

	   file, err := os.Open("test.ppm", os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666)

	   if(err!=nil){
	   println("error while openning file")
	   }
	   file.WriteString(header)
	   linesize:=int(frame.linesize[0])
	   //println(linesize)
	   data:=make([]byte, width)
	   tmpdata:=(*(*[1<<30]byte)(unsafe.Pointer(frame.data[0])))[0:numBytes]
	   //    for i:= 0; i < 1; i++ {
	   //      data[i] = tmpdata[i];
	   //    }

	   for i := 0; i < int(height); i++{
	   for a:= 0; a < int(width); a++ {
	   data[a] = tmpdata[(i*linesize)+a];
	   }
	   file.Write(data);
	   }

	   file.Close()*/
	//ioutil.WriteFile("test.data", header,0755)
	//println("bla fasel")
	//println(bytes_decoded)
	//println(*frameFinished)
	return frame
}