Add resampler functionality (#89)

* Added resampler

* Updates after PR comments

* Updated

Author: djthorpe

sys/ffmpeg80/avutil_frame.go

@@ -162,6 +162,16 @@ func AVUtil_frame_get_num_planes(frame *AVFrame) int {
 	return 0
 }
 
+// Set up dst as a new reference to the same data described by src, sharing
+// its underlying buffer(s) (bumping their refcount) rather than copying -
+// dst must already be allocated but not yet hold any buffers of its own.
+func AVUtil_frame_ref(dst, src *AVFrame) error {
+	if ret := AVError(C.av_frame_ref((*C.struct_AVFrame)(dst), (*C.struct_AVFrame)(src))); ret != 0 {
+		return ret
+	}
+	return nil
+}
+
 // Copy frame data
 func AVUtil_frame_copy(dst, src *AVFrame) error {
 	if ret := AVError(C.av_frame_copy((*C.struct_AVFrame)(dst), (*C.struct_AVFrame)(src))); ret < 0 {

task/manager/manager.go

@@ -37,7 +37,7 @@ type Manager struct {
 ////////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// New creates a new media object
+// New creates a new task manager
 func New(ctx context.Context, opts ...Opt) (_ *Manager, err error) {
 	self := new(Manager)
 	if err := self.apply(opts); err != nil {
@@ -302,9 +302,10 @@ func (m *Manager) Remove(ctx context.Context, id uuid.UUID) (err error) {
 
 // Wait blocks until the task registered under id finishes, or until ctx is
 // done, whichever comes first, then returns its final status. It returns an
-// error if the task hasn't been started (there's nothing to wait for), or if
-// the task itself returned an error (joined into err, alongside a context
-// error if ctx is what ended the wait).
+// error if the task hasn't been started (there's nothing to wait for), if
+// ctx ends the wait first (no status is returned in that case, since the
+// task may still be running), or if the task itself returned an error (its
+// status is still returned alongside that error).
 func (m *Manager) Wait(ctx context.Context, id uuid.UUID) (_ *schema.Status, err error) {
 	ctx, endSpan := otel.StartSpan(m.tracer, ctx, "Wait",
 		attribute.String("uuid", id.String()),

task/manager/opt.go

@@ -8,7 +8,7 @@ import (
 ////////////////////////////////////////////////////////////////////////////////
 // TYPES
 
-// Opt is a functional option for filer manager configuration.
+// Opt is a functional option for task manager configuration.
 type Opt func(*opt) error
 
 type opt struct {

writer/encoder.go

@@ -178,8 +178,11 @@ func (e *Encoder) Encode(f frame.Frame) error {
 
 // Flush signals end-of-stream to the codec registered for streamID and
 // passes any remaining buffered packets to the Encoder's callback. This is
-// a no-op for a subtitle stream: subtitles use a legacy API with no
-// buffering, so there is nothing to flush.
+// a no-op for a subtitle stream (subtitles use a legacy API with no
+// buffering, so there is nothing to flush) and for a stream whose codec
+// isn't actually an encoder (e.g. a StreamProfile fed to Add purely to copy
+// a demuxed stream's parameters/extradata onto the muxed output for a
+// remux - avcodec_send_frame is only valid against a real encoder context).
 func (e *Encoder) Flush(streamID int) error {
 	ctx, err := e.contextFor(streamID)
 	if err != nil {
@@ -188,6 +191,9 @@ func (e *Encoder) Flush(streamID int) error {
 	if ctx.CodecType() == ff.AVMEDIA_TYPE_SUBTITLE {
 		return nil
 	}
+	if codec := ctx.Codec(); codec == nil || !codec.IsEncoder() {
+		return nil
+	}
 	return e.encode(ctx, streamID, nil)
 }
 

writer/encoder_test.go

@@ -51,6 +51,42 @@ func silentFrame(t *testing.T, streamID, numSamples int) *frame.AudioFrame {
 	return frame
 }
 
+// mismatchedFrame builds an audio frame in a deliberately different format
+// (s16 mono @ 8kHz) from silentFrame's (fltp stereo @ 44.1kHz) - the format
+// audioStream's aac profile expects. Used to force Writer.Encode's resampler
+// into a real conversion rather than the fast pass-through path.
+func mismatchedFrame(t *testing.T, streamID, numSamples int) *frame.AudioFrame {
+	t.Helper()
+
+	frame, err := frame.NewAudioFrame(streamID)
+	if err != nil {
+		t.Fatalf("NewFrame: %v", err)
+	}
+
+	frame.SetSampleFormat(ff.AVUtil_get_sample_fmt("s16"))
+	frame.SetSampleRate(8000)
+
+	var ch ff.AVChannelLayout
+	if err := ff.AVUtil_channel_layout_from_string(&ch, "mono"); err != nil {
+		t.Fatalf("AVUtil_channel_layout_from_string: %v", err)
+	}
+	if err := frame.SetChannelLayout(ch); err != nil {
+		t.Fatalf("SetChannelLayout: %v", err)
+	}
+	frame.SetNumSamples(numSamples)
+
+	if err := frame.AllocateBuffers(); err != nil {
+		t.Fatalf("AllocateBuffers: %v", err)
+	}
+
+	samples := frame.Int16(0)
+	for i := range samples {
+		samples[i] = 0
+	}
+
+	return frame
+}
+
 func newTestEncoder(t *testing.T, fn writer.PacketFn) *writer.Encoder {
 	t.Helper()
 	if fn == nil {