Added enumeration of channel layouts, sample formats and pixel formats

Author: djthorpe

cmd/cli/formats.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"os"
+
+	// Packages
+	"github.com/djthorpe/go-tablewriter"
+	"github.com/mutablelogic/go-media"
+)
+
+type SampleFormatsCmd struct{}
+
+type ChannelLayoutsCmd struct{}
+
+type PixelFormatsCmd struct{}
+
+func (cmd *SampleFormatsCmd) Run(globals *Globals) error {
+	manager := media.NewManager()
+	writer := tablewriter.New(os.Stdout, tablewriter.OptHeader(), tablewriter.OptOutputText())
+	return writer.Write(manager.SampleFormats())
+}
+
+func (cmd *ChannelLayoutsCmd) Run(globals *Globals) error {
+	manager := media.NewManager()
+	writer := tablewriter.New(os.Stdout, tablewriter.OptHeader(), tablewriter.OptOutputText())
+	return writer.Write(manager.ChannelLayouts())
+}
+
+func (cmd *PixelFormatsCmd) Run(globals *Globals) error {
+	manager := media.NewManager()
+	writer := tablewriter.New(os.Stdout, tablewriter.OptHeader(), tablewriter.OptOutputText())
+	return writer.Write(manager.PixelFormats())
+}

cmd/cli/main.go

@@ -14,12 +14,15 @@ type Globals struct {
 
 type CLI struct {
 	Globals
-	Version  VersionCmd  `cmd:"version" help:"Print version information"`
-	Demuxers DemuxersCmd `cmd:"demuxers" help:"List media demultiplex (input) formats"`
-	Muxers   MuxersCmd   `cmd:"muxers" help:"List media multiplex (output) formats"`
-	Metadata MetadataCmd `cmd:"metadata" help:"Display media metadata information"`
-	Probe    ProbeCmd    `cmd:"probe" help:"Probe media file or device"`
-	Decode   DecodeCmd   `cmd:"decode" help:"Decode media"`
+	Version        VersionCmd        `cmd:"version" help:"Print version information"`
+	Demuxers       DemuxersCmd       `cmd:"demuxers" help:"List media demultiplex (input) formats"`
+	Muxers         MuxersCmd         `cmd:"muxers" help:"List media multiplex (output) formats"`
+	SampleFormats  SampleFormatsCmd  `cmd:"samplefmts" help:"List audio sample formats"`
+	ChannelLayouts ChannelLayoutsCmd `cmd:"channellayouts" help:"List audio channel layouts"`
+	PixelFormats   PixelFormatsCmd   `cmd:"pixelfmts" help:"List video pixel formats"`
+	Metadata       MetadataCmd       `cmd:"metadata" help:"Display media metadata information"`
+	Probe          ProbeCmd          `cmd:"probe" help:"Probe media file or device"`
+	Decode         DecodeCmd         `cmd:"decode" help:"Decode media"`
 }
 
 func main() {

cmd/cli/metadata.go

@@ -14,7 +14,8 @@ type MetadataCmd struct {
 }
 
 func (cmd *MetadataCmd) Run(globals *Globals) error {
-	reader, err := media.Open(cmd.Path, nil)
+	manager := media.NewManager()
+	reader, err := manager.Open(cmd.Path, nil)
 	if err != nil {
 		return err
 	}

decoder.go

@@ -40,20 +40,40 @@ func newDemuxer(input *ff.AVFormatContext, mapfn DecoderMapFunc) (*demuxer, erro
 	// Get all the streams
 	streams := input.Streams()
 
+	// Use standard map function if none provided
+	if mapfn == nil {
+		mapfn = func(stream Stream) (Parameters, error) {
+			return stream.Parameters(), nil
+		}
+	}
+
 	// Create a decoder for each stream
 	// The decoder map function should be returning the parameters for the
 	// destination frame. If it's nil then it's mostly a copy.
+	var result error
 	for _, stream := range streams {
-		if mapfn == nil || mapfn(stream) {
-			if decoder, err := demuxer.newDecoder(stream); err != nil {
-				return nil, errors.Join(err, demuxer.close())
-			} else {
-				streamNum := stream.Index()
-				demuxer.decoders[streamNum] = decoder
-			}
+		// Get decoder parameters
+		parameters, err := mapfn(newStream(stream))
+		if err != nil {
+			result = errors.Join(result, err)
+		} else if parameters == nil {
+			continue
+		}
+
+		// Create the decoder with the parameters
+		if decoder, err := demuxer.newDecoder(stream, parameters); err != nil {
+			result = errors.Join(result, err)
+		} else {
+			streamNum := stream.Index()
+			demuxer.decoders[streamNum] = decoder
 		}
 	}
 
+	// Return any errors
+	if result != nil {
+		return nil, errors.Join(result, demuxer.close())
+	}
+
 	// Create a frame for encoding - after resampling and resizing
 	if frame := ff.AVUtil_frame_alloc(); frame == nil {
 		return nil, errors.Join(demuxer.close(), errors.New("failed to allocate frame"))
@@ -65,10 +85,12 @@ func newDemuxer(input *ff.AVFormatContext, mapfn DecoderMapFunc) (*demuxer, erro
 	return demuxer, nil
 }
 
-func (d *demuxer) newDecoder(stream *ff.AVStream) (*decoder, error) {
+func (d *demuxer) newDecoder(stream *ff.AVStream, parameters Parameters) (*decoder, error) {
 	decoder := new(decoder)
 	decoder.stream = stream.Id()
 
+	// TODO: Use parameters to create the decoder
+
 	// Create a codec context for the decoder
 	codec := ff.AVCodec_find_decoder(stream.CodecPar().CodecID())
 	if codec == nil {
@@ -192,6 +214,14 @@ FOR_LOOP:
 	return ctx.Err()
 }
 
+func (d *demuxer) Decode(context.Context, FrameFunc) error {
+	// TODO
+	return errors.New("not implemented")
+}
+
+////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
 func (d *decoder) decode(fn DecoderFunc, packet *ff.AVPacket) error {
 	// Send the packet to the user defined packet function or
 	// to the default version

decoder_test.go

@@ -22,10 +22,10 @@ func Test_decoder_001(t *testing.T) {
 	}
 	defer media.Close()
 
-	decoder, err := media.Decoder(func (stream Stream) Parameters {
+	decoder, err := media.Decoder(func(stream Stream) (Parameters, error) {
 		// Copy parameters from the stream
-		return stream.Parameters()
-	}
+		return stream.Parameters(), nil
+	})
 	if !assert.NoError(err) {
 		t.SkipNow()
 	}

interfaces.go

@@ -13,26 +13,6 @@ import (
 // Manager represents a manager for media formats and devices.
 // Create a new manager object using the NewManager function.
 type Manager interface {
-	// Return supported input formats which match any filter, which can be
-	// a name, extension (with preceeding period) or mimetype. The MediaType
-	// can be NONE (for any) or combinations of DEVICE and STREAM.
-	InputFormats(MediaType, ...string) []Format
-
-	// Return supported output formats which match any filter, which can be
-	// a name, extension (with preceeding period) or mimetype. The MediaType
-	// can be NONE (for any) or combinations of DEVICE and STREAM.
-	OutputFormats(MediaType, ...string) []Format
-
-	// Return supported input devices for a given format name
-	// Not all devices may be supported on all platforms or listed
-	// if the device does not support enumeration.
-	InputDevices(string) []Device
-
-	// Return supported output devices for a given format name
-	// Not all devices may be supported on all platforms or listed
-	// if the device does not support enumeration.
-	OutputDevices(string) []Device
-
 	// Open a media file or device for reading, from a path or url.
 	// If a format is specified, then the format will be used to open
 	// the file. Close the media object when done.
@@ -57,9 +37,25 @@ type Manager interface {
 	// TODO
 	Write(io.Writer, Format) (Media, error)
 
-	// Return version information for the media manager as a set of
-	// metadata
-	Version() []Metadata
+	// Return supported input formats which match any filter, which can be
+	// a name, extension (with preceeding period) or mimetype. The MediaType
+	// can be NONE (for any) or combinations of DEVICE and STREAM.
+	InputFormats(MediaType, ...string) []Format
+
+	// Return supported output formats which match any filter, which can be
+	// a name, extension (with preceeding period) or mimetype. The MediaType
+	// can be NONE (for any) or combinations of DEVICE and STREAM.
+	OutputFormats(MediaType, ...string) []Format
+
+	// Return supported input devices for a given format name
+	// Not all devices may be supported on all platforms or listed
+	// if the device does not support enumeration.
+	InputDevices(string) []Device
+
+	// Return supported output devices for a given format name
+	// Not all devices may be supported on all platforms or listed
+	// if the device does not support enumeration.
+	OutputDevices(string) []Device
 
 	// Return all supported channel layouts
 	ChannelLayouts() []Metadata
@@ -71,12 +67,16 @@ type Manager interface {
 	PixelFormats() []Metadata
 
 	// Return audio parameters for encoding
-	// ChannelLayout, SampleFormat, SampleRate
+	// ChannelLayout, SampleFormat, Samplerate
 	AudioParameters(string, string, int) (AudioParameters, error)
 
 	// Return video parameters for encoding
-	// Width, Height, PixelFormat, FrameRate
-	VideoParameters(int, int, string, int) (VideoParameters, error)
+	// Width, Height, PixelFormat, Framerate
+	VideoParameters(int, int, string, float32) (VideoParameters, error)
+
+	// Return version information for the media manager as a set of
+	// metadata
+	Version() []Metadata
 }
 
 // Device represents a device for input or output of media streams.

manager.go

@@ -163,6 +163,68 @@ func (manager *manager) OutputDevices(format string) []Device {
 	panic("TODO")
 }
 
+// Return all supported channel layouts
+func (manager *manager) ChannelLayouts() []Metadata {
+	var result []Metadata
+	var iter uintptr
+	for {
+		ch := ff.AVUtil_channel_layout_standard(&iter)
+		if ch == nil {
+			break
+		}
+		if name, err := ff.AVUtil_channel_layout_describe(ch); err != nil {
+			continue
+		} else {
+			result = append(result, newMetadata(name, ch))
+		}
+	}
+	return result
+}
+
+// Return all supported sample formats
+func (manager *manager) SampleFormats() []Metadata {
+	var result []Metadata
+	var opaque uintptr
+	for {
+		samplefmt := ff.AVUtil_next_sample_fmt(&opaque)
+		if samplefmt == ff.AV_SAMPLE_FMT_NONE {
+			break
+		}
+		if name := ff.AVUtil_get_sample_fmt_name(samplefmt); name != "" {
+			result = append(result, newMetadata(name, samplefmt))
+		}
+	}
+	return result
+}
+
+// Return all supported  pixel formats
+func (manager *manager) PixelFormats() []Metadata {
+	var result []Metadata
+	var opaque uintptr
+	for {
+		pixfmt := ff.AVUtil_next_pixel_fmt(&opaque)
+		if pixfmt == ff.AV_PIX_FMT_NONE {
+			break
+		}
+		if name := ff.AVUtil_get_pix_fmt_name(pixfmt); name != "" {
+			result = append(result, newMetadata(name, pixfmt))
+		}
+	}
+	return result
+}
+
+// Return audio parameters for encoding
+// ChannelLayout, SampleFormat, Samplerate
+func (manager *manager) AudioParameters(string, string, int) (AudioParameters, error) {
+	return nil, ErrNotImplemented
+}
+
+// Return video parameters for encoding
+// Width, Height, PixelFormat, Framerate
+func (manager *manager) VideoParameters(int, int, string, float32) (VideoParameters, error) {
+	return nil, ErrNotImplemented
+}
+
 // Open a media file or device for reading, from a path or url.
 func (manager *manager) Open(url string, format Format, opts ...string) (Media, error) {
 	return newMedia(url, format, opts...)

manager_test.go

@@ -46,3 +46,39 @@ func Test_manager_003(t *testing.T) {
 
 	tablewriter.New(os.Stderr, tablewriter.OptHeader(), tablewriter.OptOutputText()).Write(version)
 }
+
+func Test_manager_004(t *testing.T) {
+	assert := assert.New(t)
+
+	manager := NewManager()
+	assert.NotNil(manager)
+
+	channel_layouts := manager.ChannelLayouts()
+	assert.NotNil(channel_layouts)
+
+	tablewriter.New(os.Stderr, tablewriter.OptHeader(), tablewriter.OptOutputText()).Write(channel_layouts)
+}
+
+func Test_manager_005(t *testing.T) {
+	assert := assert.New(t)
+
+	manager := NewManager()
+	assert.NotNil(manager)
+
+	sample_formats := manager.SampleFormats()
+	assert.NotNil(sample_formats)
+
+	tablewriter.New(os.Stderr, tablewriter.OptHeader(), tablewriter.OptOutputText()).Write(sample_formats)
+}
+
+func Test_manager_006(t *testing.T) {
+	assert := assert.New(t)
+
+	manager := NewManager()
+	assert.NotNil(manager)
+
+	pixel_formats := manager.PixelFormats()
+	assert.NotNil(pixel_formats)
+
+	tablewriter.New(os.Stderr, tablewriter.OptHeader(), tablewriter.OptOutputText()).Write(pixel_formats)
+}

stream.go

@@ -0,0 +1,43 @@
+package media
+
+import (
+	// Packages
+	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type stream struct {
+	*ff.AVStream
+}
+
+var _ Stream = (*stream)(nil)
+
+////////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+// Open media from a url, file path or device
+func newStream(ctx *ff.AVStream) *stream {
+	return &stream{ctx}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (stream *stream) Type() MediaType {
+	switch stream.CodecPar().CodecType() {
+	case ff.AVMEDIA_TYPE_AUDIO:
+		return AUDIO
+	case ff.AVMEDIA_TYPE_VIDEO:
+		return VIDEO
+	case ff.AVMEDIA_TYPE_SUBTITLE:
+		return SUBTITLE
+	}
+	return DATA
+}
+
+func (stream *stream) Parameters() Parameters {
+	// TODO
+	return nil
+}