Updated to add resampler

Author: djthorpe

cmd/transcode/main.go

@@ -119,9 +119,6 @@ func main() {
 		os.Exit(-2)
 	}
 
-	// Print the map
-	media_map.PrintMap(os.Stdout)
-
 	// For the output, we can output to a device, a URL, or a file
 	var out Media
 	if reDeviceName.MatchString(flags.Out()) {
@@ -138,6 +135,25 @@ func main() {
 		os.Exit(-2)
 	}
 
+	// For each input stream, add an output
+	for _, stream := range media_map.Streams(flags.MediaFlags()) {
+		// TODO
+		// If audio, then resample data
+		switch {
+		case stream.Flags().Is(MEDIA_FLAG_AUDIO):
+			if err := media_map.Resample(AudioFormat{
+				Rate:   11025,
+				Format: SAMPLE_FORMAT_U8,
+			}, stream); err != nil {
+				fmt.Fprintln(os.Stderr, "Cannot resample audio stream:", err)
+				os.Exit(-2)
+			}
+		}
+	}
+
+	// Print the map
+	media_map.PrintMap(os.Stdout)
+
 	// Create a cancellable context
 	ctx := contextForSignal(os.Interrupt)
 

media.go

@@ -105,22 +105,24 @@ type Map interface {
 	// Return input media
 	Input() Media
 
-	// Return streams which are mapped for decoding
-	Streams() []Stream
+	// Return a single stream which is mapped for decoding, filtering by
+	// stream type. Returns nil if there is no selection of that type
+	Streams(MediaFlag) []Stream
 
 	// Print a summary of the mapping
 	PrintMap(w io.Writer)
+
+	// Resample an audio stream
+	Resample(AudioFormat, Stream) error
+
+	// Encode to output media using default codec from a specific stream
+	//Encode(Media, Stream) error
 }
 
 // Media is a source or destination of media
 type Media interface {
 	io.Closer
 
-	// Return best streams for specific types (video, audio, subtitle, data or attachment)
-	// or returns empty slice if no streams of that type are in the media file. Only returns
-	// one stream of each type.
-	//StreamsByType(MediaFlag) []Stream
-
 	// URL for the media
 	URL() string
 
@@ -130,6 +132,9 @@ type Media interface {
 	// Return media flags for the media
 	Flags() MediaFlag
 
+	// Return the format of the media
+	Format() MediaFormat
+
 	// Return metadata for the media
 	Metadata() Metadata
 

pkg/media/decoder.go

@@ -2,11 +2,14 @@ package media
 
 import (
 	// Packages
+	"fmt"
+
 	multierror "github.com/hashicorp/go-multierror"
 	ffmpeg "github.com/mutablelogic/go-media/sys/ffmpeg51"
+
 	// Namespace imports
+	. "github.com/mutablelogic/go-media"
 	//. "github.com/djthorpe/go-errors"
-	//. "github.com/mutablelogic/go-media"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -16,7 +19,6 @@ type decoder struct {
 	ctx    *ffmpeg.AVCodecContext
 	stream *stream
 	frame  *frame
-	codec  *ffmpeg.AVCodec
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -37,8 +39,6 @@ func NewDecoder(stream *stream) *decoder {
 	decoder := ffmpeg.AVCodec_find_decoder(stream.ctx.CodecPar().CodecID())
 	if decoder == nil {
 		return nil
-	} else {
-		this.codec = decoder
 	}
 
 	// Allocate a codec context for the decoder
@@ -92,8 +92,35 @@ func (decoder *decoder) Close() error {
 	decoder.ctx = nil
 	decoder.frame = nil
 	decoder.stream = nil
-	decoder.codec = nil
 
 	// Return any errors
 	return result
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (decoder *decoder) String() string {
+	str := "<media.decoder"
+	if decoder.ctx != nil {
+		str += fmt.Sprint(" context=", decoder.ctx)
+	}
+	if decoder.frame != nil {
+		str += fmt.Sprint(" frame=", decoder.frame)
+	}
+	return str + ">"
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (decoder *decoder) AudioFormat() AudioFormat {
+	if decoder.ctx == nil {
+		return AudioFormat{}
+	}
+	return AudioFormat{
+		Rate:   uint(decoder.ctx.BitRate()),
+		Format: fromSampleFormat(decoder.ctx.SampleFormat()),
+		Layout: fromChannelLayout(decoder.ctx.ChannelLayout()),
+	}
+}

pkg/media/encoder.go

@@ -1,6 +1,8 @@
 package media
 
 import (
+	"fmt"
+
 	ffmpeg "github.com/mutablelogic/go-media/sys/ffmpeg51"
 	// Namespace imports
 	//. "github.com/djthorpe/go-errors"
@@ -11,31 +13,16 @@ import (
 // TYPES
 
 type encoder struct {
-	codec *ffmpeg.AVCodec
-	ctx   *ffmpeg.AVCodecContext
+	ctx *ffmpeg.AVCodecContext
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
 // Create a encoder for a stream
-func NewEncoderByName(name string) *encoder {
+func NewEncoderWithCodec(codec *ffmpeg.AVCodec) *encoder {
 	this := new(encoder)
 
-	// Find encoder
-	if codec := ffmpeg.AVCodec_find_encoder_by_name(name); codec == nil {
-		return nil
-	} else {
-		this.codec = codec
-	}
-
-	// Allocate context
-	if ctx := ffmpeg.AVCodec_alloc_context3(this.codec); ctx == nil {
-		return nil
-	} else {
-		this.ctx = ctx
-	}
-
 	// Return success
 	return this
 }
@@ -50,7 +37,6 @@ func (encoder *encoder) Close() error {
 
 	// Blank out other fields
 	encoder.ctx = nil
-	encoder.codec = nil
 
 	// Return success
 	return result
@@ -61,8 +47,8 @@ func (encoder *encoder) Close() error {
 
 func (encoder *encoder) String() string {
 	str := "<media.encoder"
-	if encoder.codec != nil {
-		str += " name=" + encoder.codec.Name()
+	if encoder.ctx != nil {
+		str += fmt.Sprint(" context=", encoder.ctx)
 	}
 	return str + ">"
 }

pkg/media/manager.go

@@ -3,6 +3,7 @@ package media
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"log"
 	"strings"
@@ -236,6 +237,16 @@ func (manager *manager) Decode(ctx context.Context, media_map Map, p Packet, fn
 		// Receive frames from the packet
 		err := ffmpeg.AVCodec_receive_frame(decoder.ctx, decoder.frame.ctx)
 		if err == nil {
+			// Resample
+			if mapentry.Resampler != nil {
+				if err := mapentry.Resampler.Resample(decoder.frame); err == nil {
+					fmt.Println("Resample", mapentry.Resampler.Frame())
+				} else {
+					fmt.Println("Error", err)
+				}
+				// Release the frame
+				mapentry.Resampler.Release()
+			}
 			err = fn(ctx, decoder.frame)
 		}
 

pkg/media/manager_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 const (
-	SAMPLE_MP4 = "../../etc/sample.mp4"
+	SAMPLE_MP4 = "../../etc/test/sample.mp4"
 	SAMPLE_HLS = "http://a.files.bbci.co.uk/media/live/manifesto/audio/simulcast/hls/nonuk/sbr_vlow/ak/bbc_radio_fourfm.m3u8"
 )
 

pkg/media/map.go

@@ -26,7 +26,8 @@ type decodemap struct {
 type mapentry struct {
 	Decoder   *decoder   // Decoder context for the stream
 	Resampler *resampler // Resampler context for the audio frames
-	Scaler    *scaler    // Scaler context for the video frames
+	Rescaler  *rescaler  // Rescaler context for the video frames
+	Encoder   *encoder   // Encoder context for the stream
 }
 
 // Ensure decodemap complies with Map interface
@@ -115,16 +116,22 @@ func (mapentry *mapentry) Close() error {
 			result = multierror.Append(result, err)
 		}
 	}
-	if mapentry.Scaler != nil {
-		if err := mapentry.Scaler.Close(); err != nil {
+	if mapentry.Rescaler != nil {
+		if err := mapentry.Rescaler.Close(); err != nil {
+			result = multierror.Append(result, err)
+		}
+	}
+	if mapentry.Encoder != nil {
+		if err := mapentry.Encoder.Close(); err != nil {
 			result = multierror.Append(result, err)
 		}
 	}
 
 	// Release resources
 	mapentry.Decoder = nil
 	mapentry.Resampler = nil
-	mapentry.Scaler = nil
+	mapentry.Rescaler = nil
+	mapentry.Encoder = nil
 
 	// Return any errors
 	return result
@@ -147,16 +154,43 @@ func (m *decodemap) Input() Media {
 }
 
 // Return the input media streams which should be decoded
-func (m *decodemap) Streams() []Stream {
+func (m *decodemap) Streams(flag MediaFlag) []Stream {
 	var result []Stream
 	for _, mapentry := range m.context {
 		if mapentry.Decoder != nil {
-			result = append(result, mapentry.Decoder.stream)
+			if flag == MEDIA_FLAG_NONE || mapentry.Decoder.stream.Flags().Is(flag) {
+				result = append(result, mapentry.Decoder.stream)
+			}
 		}
 	}
 	return result
 }
 
+// Create a resampler for an audio stream
+func (m *decodemap) Resample(out AudioFormat, in Stream) error {
+	decoder := toDecoder(m.context, in)
+	if decoder == nil {
+		return ErrBadParameter.With("resample: no decoder: ", in)
+	}
+
+	// Check decoder is audio
+	if !in.Flags().Is(MEDIA_FLAG_AUDIO) {
+		return ErrBadParameter.With("not an audio stream: ", in)
+	}
+
+	// Create a resampler
+	resampler := NewResampler(out, decoder.AudioFormat())
+	if resampler == nil {
+		return ErrInternalAppError.With("resample: returned nil: ", decoder)
+	}
+
+	// Set resampler
+	m.context[in.Index()].Resampler = resampler
+
+	// Return success
+	return nil
+}
+
 // Decode a packet, by calling a decoding function with a packet.
 // If the stream associated with the packet is not in the map, then
 // ignore it
@@ -176,15 +210,35 @@ func (m *decodemap) Demux(ctx context.Context, p Packet, fn DemuxFn) error {
 
 // PrintMap will print out a summary of the mapping
 func (m *decodemap) PrintMap(w io.Writer) {
-	for id := range m.context {
+	for id, entry := range m.context {
 		stream := m.input.streams[id]
 		fmt.Fprintf(w, "Stream %2d (%s): %s\n", id, toMediaType(stream.Flags()), stream)
+		if entry.Rescaler != nil {
+			fmt.Fprintf(w, "  Rescale: %s\n", entry.Rescaler)
+		}
+		if entry.Resampler != nil {
+			fmt.Fprintf(w, "  Resample: %s\n", entry.Resampler)
+		}
+		if entry.Encoder != nil {
+			fmt.Fprintf(w, "  Encode: %s\n", entry.Encoder)
+		}
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
+// Return a decoder from the context
+func toDecoder(context map[int]*mapentry, stream Stream) *decoder {
+	if context == nil || stream == nil {
+		return nil
+	} else if entry, exists := context[stream.Index()]; !exists || entry == nil {
+		return nil
+	} else {
+		return entry.Decoder
+	}
+}
+
 // Return media type (audio, video, subtitle, etc)
 func toMediaType(flag MediaFlag) string {
 	switch {