Updated code

Author: djthorpe

pkg/ffmpeg/decoder.go

@@ -17,6 +17,7 @@ type Decoder struct {
 	stream   int
 	codec    *ff.AVCodecContext
 	dest     *Par          // Destination parameters
+	re       *Re           // Resample/resize
 	timeBase ff.AVRational // Timebase for the stream
 	frame    *ff.AVFrame   // Destination frame
 }
@@ -25,21 +26,38 @@ type Decoder struct {
 // LIFECYCLE
 
 // Create a stream decoder which can decode packets from the input stream
-// TODO: resample and resize frames to the destination parameters
 func NewDecoder(stream *ff.AVStream, dest *Par, force bool) (*Decoder, error) {
 	decoder := new(Decoder)
 	decoder.stream = stream.Id()
 	decoder.dest = dest
 	decoder.timeBase = stream.TimeBase()
 
+	// Create a frame for decoder output - before resize/resample
+	frame := ff.AVUtil_frame_alloc()
+	if frame == nil {
+		return nil, errors.New("failed to allocate frame")
+	}
+
 	// Create a codec context for the decoder
 	codec := ff.AVCodec_find_decoder(stream.CodecPar().CodecID())
 	if codec == nil {
+		ff.AVUtil_frame_free(frame)
 		return nil, fmt.Errorf("failed to find decoder for codec %q", stream.CodecPar().CodecID())
 	} else if ctx := ff.AVCodec_alloc_context(codec); ctx == nil {
+		ff.AVUtil_frame_free(frame)
 		return nil, fmt.Errorf("failed to allocate codec context for codec %q", codec.Name())
 	} else {
 		decoder.codec = ctx
+		decoder.frame = frame
+	}
+
+	// If the destination codec parameters are not nil, then create a resample/resizer
+	if dest != nil {
+		if re, err := NewRe(dest, force); err != nil {
+			return nil, errors.Join(err, decoder.Close())
+		} else {
+			decoder.re = re
+		}
 	}
 
 	// Copy codec parameters from input stream to output codec context
@@ -52,13 +70,6 @@ func NewDecoder(stream *ff.AVStream, dest *Par, force bool) (*Decoder, error) {
 		return nil, errors.Join(decoder.Close(), err)
 	}
 
-	// Create a frame for decoder output - before resize/resample
-	if frame := ff.AVUtil_frame_alloc(); frame == nil {
-		return nil, errors.Join(decoder.Close(), errors.New("failed to allocate frame"))
-	} else {
-		decoder.frame = frame
-	}
-
 	// Return success
 	return decoder, nil
 }
@@ -67,6 +78,11 @@ func NewDecoder(stream *ff.AVStream, dest *Par, force bool) (*Decoder, error) {
 func (d *Decoder) Close() error {
 	var result error
 
+	// Free resampler/resizer
+	if d.re != nil {
+		result = errors.Join(result, d.re.Close())
+	}
+
 	// Free the codec context
 	if d.codec != nil {
 		ff.AVCodec_free_context(d.codec)
@@ -77,30 +93,38 @@ func (d *Decoder) Close() error {
 		ff.AVUtil_frame_free(d.frame)
 	}
 
+	// Reset fields
+	d.re = nil
+	d.codec = nil
+	d.frame = nil
+
 	// Return any errors
 	return result
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
+// Decode a packet into a set of frames to pass back to the
+// DecoderFrameFn. If the packet is nil, then the decoder will
+// flush any remaining frames.
+// TODO: Optionally use the user defined packet function
+// if they want to use AVParser
+// TODO: The frame sent to DecoderFrameFn needs to have the
+// correct timebase, etc set
 func (d *Decoder) decode(packet *ff.AVPacket, fn DecoderFrameFn) error {
 	if fn == nil {
 		return errors.New("DecoderFrameFn is nil")
 	}
 
-	//if demuxfn != nil {
-	// Send the packet (or a nil to flush) to the user defined packet function
-	//	return demuxfn(newPacket(packet, d.stream, d.codec.Codec().Type(), d.timeBase))
-	//}
-
 	// Submit the packet to the decoder (nil packet will flush the decoder)
 	if err := ff.AVCodec_send_packet(d.codec, packet); err != nil {
 		return err
 	}
 
 	// get all the available frames from the decoder
 	var result error
+	var dest *Frame
 	for {
 		// End early if we've received an EOF
 		if result != nil {
@@ -115,25 +139,38 @@ func (d *Decoder) decode(packet *ff.AVPacket, fn DecoderFrameFn) error {
 			return err
 		}
 
+		// Obtain the output frame. If a new frame is returned, it is
+		// managed by the rescaler/resizer and no need to unreference it
+		// later.
+		if d.re != nil {
+			if frame, err := d.re.Frame((*Frame)(d.frame)); err != nil {
+				result = errors.Join(result, err)
+			} else {
+				dest = frame
+			}
+		} else {
+			dest = (*Frame)(d.frame)
+		}
+
 		// TODO: Modify Pts?
+		// What else do we need to copy across?
+		fmt.Println("TODO", d.timeBase, dest.TimeBase(), ff.AVTimestamp(dest.Pts()))
+		if dest.Pts() == PTS_UNDEFINED {
+			(*ff.AVFrame)(dest).SetPts(d.frame.Pts())
+		}
 
 		// Pass back to the caller
-		if err := fn(d.stream, (*Frame)(d.frame)); errors.Is(err, io.EOF) {
+		if err := fn(d.stream, dest); errors.Is(err, io.EOF) {
 			// End early, return EOF
 			result = io.EOF
 		} else if err != nil {
 			return err
 		}
 
-		// Re-allocate frames for next iteration
+		// Re-allocate frame for next iteration
 		ff.AVUtil_frame_unref(d.frame)
 	}
 
-	// Flush
-	if err := fn(d.stream, nil); err != nil && !errors.Is(err, io.EOF) {
-		result = errors.Join(result, err)
-	}
-
 	// Return success or EOF
 	return result
 }

pkg/ffmpeg/reader_test.go

@@ -63,7 +63,10 @@ func Test_reader_003(t *testing.T) {
 	defer media.Close()
 
 	framefn := func(stream int, frame *ffmpeg.Frame) error {
-		t.Logf("Frame %v[%d] => %v", frame.Type(), stream, time.Duration(frame.Ts()*float64(time.Second)).Truncate(time.Millisecond))
+		// Receive a nil frame at the end of each packet
+		if frame != nil {
+			t.Logf("Frame %v[%d] => %v", frame.Type(), stream, time.Duration(frame.Ts()*float64(time.Second)).Truncate(time.Millisecond))
+		}
 		return nil
 	}