Updated encoder

Author: djthorpe

encoder.go

@@ -4,6 +4,7 @@ import (
 
 	// Packages
 	"fmt"
+	"io"
 
 	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
 
@@ -15,10 +16,11 @@ import (
 // TYPES
 
 type encoder struct {
-	t      MediaType
-	ctx    *ff.AVCodecContext
-	stream *ff.AVStream
-	packet *ff.AVPacket
+	t        MediaType
+	ctx      *ff.AVCodecContext
+	stream   *ff.AVStream
+	packet   *ff.AVPacket
+	next_pts int64
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -78,19 +80,22 @@ func newEncoder(ctx *ff.AVFormatContext, stream_id int, param Parameters) (*enco
 			codecctx.SetSampleFormat(sampleformat)
 		}
 
-		// Choose sample rate
-		if samplerate, err := ff.AVCodec_supported_samplerate(codec, par.audiopar.Samplerate); err != nil {
-			ff.AVCodec_free_context(codecctx)
-			return nil, err
-		} else {
-			codecctx.SetSampleRate(samplerate)
-		}
+		// TODO Choose sample rate
+		codecctx.SetSampleRate(par.audiopar.Samplerate)
 
-		// Choose channel layout
-		if channellayout, err := ff.AVCodec_supported_channellayout(codec, par.audiopar.Ch); err != nil {
-			ff.AVCodec_free_context(codecctx)
-			return nil, err
-		} else if err := codecctx.SetChannelLayout(channellayout); err != nil {
+		// TODO
+		//if samplerate, err := ff.AVCodec_supported_samplerate(codec, par.audiopar.Samplerate); err != nil {
+		//	ff.AVCodec_free_context(codecctx)
+		//	return nil, err
+		//}
+
+		// TODO Choose channel layout
+		//if channellayout, err := ff.AVCodec_supported_channellayout(codec, par.audiopar.Ch); err != nil {
+		//	ff.AVCodec_free_context(codecctx)
+		//	return nil, err
+		//}
+
+		if err := codecctx.SetChannelLayout(par.audiopar.Ch); err != nil {
 			ff.AVCodec_free_context(codecctx)
 			return nil, err
 		}
@@ -174,8 +179,7 @@ func (encoder *encoder) Close() error {
 // PRIVATE METHODS
 
 func (encoder *encoder) encode(fn MuxFunc) (*ff.AVPacket, error) {
-	packet, err := fn(encoder.stream.Id())
-	if packet != nil {
-	}
-
+	// TODO
+	fmt.Println("TODO: encode - get packet")
+	return nil, io.EOF
 }

packet.go

@@ -11,13 +11,13 @@ import (
 // TYPES
 
 type packetmeta struct {
-	StreamIndex int            `json:"stream_index" writer:",width:10,right"`
-	MediaType   ff.AVMediaType `json:"media_type" writer:",width:20"`
-	Size        int            `json:"size,omitempty"  writer:",width:7,right"`
-	Pts         ff.AVTimestamp `json:"pts,omitempty"  writer:",width:9,right"`
-	TimeBase    ff.AVRational  `json:"time_base,omitempty"  writer:",width:10,right"`
-	Duration    ff.AVTimestamp `json:"duration,omitempty"  writer:",width:10,right"`
-	Pos         *int64         `json:"pos,omitempty"  writer:",width:10,right"`
+	Stream    int            `json:"stream" writer:",width:10,right"`
+	MediaType ff.AVMediaType `json:"media_type" writer:",width:20"`
+	Size      int            `json:"size,omitempty"  writer:",width:7,right"`
+	Pts       int64          `json:"pts,omitempty"  writer:",width:9,right"`
+	TimeBase  ff.AVRational  `json:"time_base,omitempty"  writer:",width:10,right"`
+	Duration  int64          `json:"duration,omitempty"  writer:",width:10,right"`
+	Pos       *int64         `json:"pos,omitempty"  writer:",width:10,right"`
 }
 
 type packet struct {
@@ -34,15 +34,15 @@ func newPacket(ctx *ff.AVPacket, stream int, t ff.AVMediaType, timeBase ff.AVRat
 	pkt := &packet{
 		ctx: ctx,
 		packetmeta: packetmeta{
-			StreamIndex: stream,
-			MediaType:   t,
+			Stream:    stream,
+			MediaType: t,
 		},
 	}
 	if ctx != nil {
 		pkt.packetmeta.Size = ctx.Size()
-		pkt.packetmeta.Pts = ff.AVTimestamp(ctx.Pts())
+		pkt.packetmeta.Pts = ctx.Pts()
 		pkt.packetmeta.TimeBase = timeBase
-		pkt.packetmeta.Duration = ff.AVTimestamp(ctx.Duration())
+		pkt.packetmeta.Duration = ctx.Duration()
 		if ctx.Pos() != -1 {
 			pos := ctx.Pos()
 			pkt.packetmeta.Pos = &pos
@@ -62,3 +62,23 @@ func (packet *packet) String() string {
 	data, _ := json.MarshalIndent(packet, "", "  ")
 	return string(data)
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// PROPERTIES
+
+func (packet *packet) Id() int {
+	return packet.packetmeta.Stream
+}
+
+func (packet *packet) Type() MediaType {
+	switch packet.packetmeta.MediaType {
+	case ff.AVMEDIA_TYPE_AUDIO:
+		return AUDIO
+	case ff.AVMEDIA_TYPE_VIDEO:
+		return VIDEO
+	case ff.AVMEDIA_TYPE_SUBTITLE:
+		return SUBTITLE
+	default:
+		return DATA
+	}
+}

sys/ffmpeg61/avcodec_core.go

@@ -105,14 +105,35 @@ func AVCodec_is_decoder(codec *AVCodec) bool {
 
 // Return a supported sample format that is closest to the given sample format.
 func AVCodec_supported_sampleformat(codec *AVCodec, samplefmt AVSampleFormat) (AVSampleFormat, error) {
-	for _, fmt := range codec.SampleFormats() {
+	first := AV_SAMPLE_FMT_NONE
+	for i, fmt := range codec.SampleFormats() {
 		if fmt == samplefmt {
 			return samplefmt, nil
 		}
+		if i == 0 {
+			first = fmt
+		}
+	}
+	// Return an error and the first supported sample format
+	return first, fmt.Errorf("sample format %v is not supported by codec %q", samplefmt, codec.Name())
+}
+
+// Return a supported pixel format that is closest to the given pixel format.
+func AVCodec_supported_pixelformat(codec *AVCodec, pixelfmt AVPixelFormat) (AVPixelFormat, error) {
+	first := AV_PIX_FMT_NONE
+	for i, fmt := range codec.PixelFormats() {
+		if fmt == pixelfmt {
+			return pixelfmt, nil
+		}
+		if i == 0 {
+			first = fmt
+		}
 	}
-	return AVSampleFormat(AV_SAMPLE_FMT_NONE), fmt.Errorf("sample format %v is not supported by codec %q", samplefmt, codec.Name())
+	// Return an error and the first supported sample format
+	return first, fmt.Errorf("pixel format %v is not supported by codec %q", pixelfmt, codec.Name())
 }
 
+/*
 // Return a supported sample rate that is closest to the given sample rate.
 func AVCodec_supported_samplerate(codec *AVCodec, samplerate int) (int, error) {
 	max := 0
@@ -139,8 +160,4 @@ func AVCodec_supported_channellayout(codec *AVCodec, channellayout AVChannelLayo
 		}
 	}
 }
-
-// Return a supported pixel format that is closest to the given pixel format.
-func AVCodec_supported_pixelformat(AVCodec *codec, AVPixelFormat pixelformat) (AVPixelFormat, error) {
-
-}
+*/

sys/ffmpeg61/avcodec_encoding.go

@@ -9,8 +9,9 @@ import (
 // CGO
 
 /*
-#cgo pkg-config: libavcodec
+#cgo pkg-config: libavcodec libavformat
 #include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
 #include <stdlib.h>
 */
 import "C"

writer.go

@@ -217,17 +217,24 @@ FOR_LOOP:
 			}
 
 			// Find the first encoder which should return a packet
-			next_time := 0
-			next_stream := 0
-			for stream := range encoders {
-				if next_time == 0 || encoder.nextTime() < next_time {
-					next_time = encoder.nextTime()
+			var next_encoder *encoder
+			var next_stream int
+			for stream, encoder := range encoders {
+				// Initialise the next encoder
+				if next_encoder == nil {
+					next_encoder = encoder
+					next_stream = stream
+					continue
+				}
+				// Compare
+				if !compareNextPts(next_encoder, encoder) {
+					next_encoder = encoder
 					next_stream = stream
 				}
 			}
 
 			// Get a packet from the encoder
-			packet, err := encoders[next_stream].encode(fn)
+			packet, err := next_encoder.encode(fn)
 			if errors.Is(err, io.EOF) {
 				break FOR_LOOP
 			} else if err != nil {
@@ -261,6 +268,11 @@ FOR_LOOP:
 	return ctx.Err()
 }
 
+// Returns true if a.next_pts is greater than b.next_pts
+func compareNextPts(a, b *encoder) bool {
+	return ff.AVUtil_compare_ts(a.next_pts, a.stream.TimeBase(), b.next_pts, b.stream.TimeBase()) > 0
+}
+
 /*
 		while (1) {
 	        AVStream *in_stream, *out_stream;