A transcoder (h264 to mjpeg) example using FFmpeg via go-astiav

[Tryanks]

package main

import "github.com/asticode/go-astiav"

type Stream struct {
	decoder    *astiav.Codec
	decContext *astiav.CodecContext
	pkt        *astiav.Packet
	frame      *astiav.Frame

	encoder    *astiav.Codec
	encContext *astiav.CodecContext
	encPkt     *astiav.Packet
}

func NewStream(width, height int) (s *Stream, err error) {
	s = &Stream{}

	// Find Decoder
	s.decoder = astiav.FindDecoder(astiav.CodecIDH264)
	if s.decoder == nil {
		panic("Cannot find H264 decoder")
	}

	// Alloc Codec Context
	s.decContext = astiav.AllocCodecContext(s.decoder)
	if s.decContext == nil {
		panic("Cannot alloc codec context")
	}
	// Open Codec Context
	err = s.decContext.Open(s.decoder, nil)
	if err != nil {
		panic(err)
	}
	// Set Codec Context
	s.decContext.SetWidth(width)
	s.decContext.SetHeight(height)
	s.decContext.SetPixelFormat(astiav.PixelFormatYuv420P)

	// Alloc
	s.pkt = astiav.AllocPacket()
	s.frame = astiav.AllocFrame()

	// Find Encoder
	s.encoder = astiav.FindEncoder(astiav.CodecIDMjpeg)
	if s.encoder == nil {
		panic("Cannot find MJPEG encoder")
	}

	// Alloc Codec Context
	s.encContext = astiav.AllocCodecContext(s.encoder)
	if s.encContext == nil {
		panic("Cannot alloc codec context")
	}
	// Set Codec Context
	s.encContext.SetPixelFormat(astiav.PixelFormatYuvj420P)
	s.encContext.SetWidth(s.decContext.Width())
	s.encContext.SetHeight(s.decContext.Height())
	s.encContext.SetTimeBase(astiav.NewRational(1, 60))

	// Open Codec Context
	err = s.encContext.Open(s.encoder, nil)
	if err != nil {
		panic(err)
	}

	// Alloc
	s.encPkt = astiav.AllocPacket()

	return
}

func (s *Stream) Free() {
	s.decContext.Free()
	s.pkt.Free()
	s.frame.Free()
}

func (s *Stream) SendData(data []byte) (err error) {
	s.pkt.Unref()
	err = s.pkt.FromData(data)
	if err != nil {
		return
	}
	err = s.decContext.SendPacket(s.pkt)
	if err != nil {
		return
	}
	return
}

func (s *Stream) ReceiveJpeg() (jpeg []byte, err error) {
	s.frame.Unref()
	err = s.receiveFrame()
	if err != nil {
		return
	}
	jpeg, err = s.encodeFrame()
	if err != nil {
		return
	}
	return
}

func (s *Stream) receiveFrame() error {
	return s.decContext.ReceiveFrame(s.frame)
}

func (s *Stream) encodeFrame() (jpeg []byte, err error) {
	err = s.encContext.SendFrame(s.frame)
	if err != nil {
		panic(err)
	}
	s.encPkt.Unref()
	err = s.encContext.ReceivePacket(s.encPkt)
	if err != nil {
		panic(err)
	}
	jpeg = s.encPkt.Data()
	return
}

All exceptions have been ignored

How to use:

videoCodec, _ := NewStream(1920, 1080)
defer videoCodec.Free()
buffer := make([]byte, 65536 * 2)
for {
    // NALUSource is NALU data from iPhone h264 Stream
    n, _ := NALUSource.Read(buffer)
    _ = videoCodec.SendData(buffer[:n])
    jpgBuffer, _ := videoCodec.ReceiveJpeg()
    // It can be saved as an image or provided directly via websocket as a mjpeg stream making it playable with VLC.
    fmt.Println(len(jpgBuffer))
}

It helps to decouple h264 video streams from gst by converting them to any video encoding.
I'll implement a PoC for the project later if you think this will work.

I apologize for putting this on hold after offering to help a few months ago. (nnnpa31)