Updated manager

Author: djthorpe

interfaces.go renamed to _old/interfaces.go

@@ -0,0 +1,104 @@
+/*
+This is a package for reading, writing and inspecting media files. In
+order to operate on media, call NewManager() and then use the manager
+functions to determine capabilities and manage media files and devices.
+*/
+package media
+
+// Manager represents a manager for media formats and devices.
+// Create a new manager object using the NewManager function.
+//
+//		  import "github.com/mutablelogic/go-media/pkg/ffmpeg"
+//
+//		  manager, err := ffmpeg.NewManager()
+//		  if err != nil {
+//			...
+//	      }
+//
+// Various options are available to control the manager, for
+// logging and affecting decoding.
+//
+// Only one manager can be created. If NewManager is called
+// a second time, the previously created manager is returned,
+// but any new options are applied.
+type Manager interface {
+	// 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.
+	//Open(string, Format, ...string) (Media, error)
+
+	// Open a media stream for reading.  If a format is
+	// specified, then the format will be used to open the file. Close the
+	// media object when done. It is the responsibility of the caller to
+	// also close the reader when done.
+	//Read(io.Reader, Format, ...string) (Media, error)
+
+	// Create a media file or device for writing, from a path. If a format is
+	// specified, then the format will be used to create the file or else
+	// the format is guessed from the path. If no parameters are provided,
+	// then the default parameters for the format are used.
+	//Create(string, Format, []Metadata, ...Parameters) (Media, error)
+
+	// Create a media stream for writing. The format will be used to
+	// determine the format and one or more CodecParameters used to
+	// create the streams. If no parameters are provided, then the
+	// default parameters for the format are used. It is the responsibility
+	// of the caller to also close the writer when done.
+	//Write(io.Writer, Format, []Metadata, ...Parameters) (Media, error)
+
+	// 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(Type, ...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(Type, ...string) []Format
+
+	// Return supported devices for a given format.
+	// Not all devices may be supported on all platforms or listed
+	// if the device does not support enumeration.
+	//Devices(Format) []Device
+
+	// Return all supported channel layouts
+	//ChannelLayouts() []Metadata
+
+	// Return all supported sample formats
+	//SampleFormats() []Metadata
+
+	// Return all supported  pixel formats
+	//PixelFormats() []Metadata
+
+	// Return all supported codecs
+	//Codecs() []Metadata
+
+	// Return audio parameters for encoding
+	// ChannelLayout, SampleFormat, Samplerate
+	//AudioParameters(string, string, int) (Parameters, error)
+
+	// Return video parameters for encoding
+	// Width, Height, PixelFormat
+	//VideoParameters(int, int, string) (Parameters, error)
+
+	// Return codec parameters for audio encoding
+	// Codec name and AudioParameters
+	//AudioCodecParameters(string, AudioParameters) (Parameters, error)
+
+	// Return codec parameters for video encoding
+	// Codec name, Profile name, Framerate (fps) and VideoParameters
+	//VideoCodecParameters(string, string, float64, VideoParameters) (Parameters, error)
+
+	// Return version information for the media manager as a set of
+	// metadata
+	Version() []Metadata
+
+	// Log error messages with arguments
+	Errorf(string, ...any)
+
+	// Log warning messages with arguments
+	Warningf(string, ...any)
+
+	// Log info messages  with arguments
+	Infof(string, ...any)
+}

manager.go

@@ -0,0 +1,28 @@
+/*
+This is a package for reading, writing and inspecting media files. In
+order to operate on media, call NewManager() and then use the manager
+functions to determine capabilities and manage media files and devices.
+*/
+package media
+
+import "image"
+
+// Metadata is a key/value pair which can be used to describe a media object
+// or other metadata. The value can be retrieved as a string value,
+// data, or other type. If the value is a byte slice, then it can also
+// be retrieved as an image (for artwork)
+type Metadata interface {
+	// Return the metadata key
+	Key() string
+
+	// Return the value as a string. Returns the mimetype
+	// if the value is a byte slice, and the mimetype can be
+	// detected.
+	Value() string
+
+	// Returns the value as a byte slice
+	Bytes() []byte
+
+	// Returns the value as an image
+	Image() image.Image
+}

metadata.go

@@ -0,0 +1,127 @@
+package ffmpeg
+
+import (
+
+	// Packages
+	media "github.com/mutablelogic/go-media"
+	"github.com/mutablelogic/go-media/pkg/version"
+	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Manager struct {
+	opts []Opt
+}
+
+var _ media.Manager = (*Manager)(nil)
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+var (
+	manager *Manager
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+// Create a new media manager which enumerates the available codecs, formats
+// and devices
+func NewManager(opt ...Opt) (*Manager, error) {
+	var options opts
+
+	// Return existing manager if it exists
+	if manager == nil {
+		manager = new(Manager)
+	}
+
+	// Set default options
+	options.level = ff.AV_LOG_WARNING
+
+	// Apply options
+	for _, opt := range opt {
+		if err := opt(&options); err != nil {
+			return nil, err
+		}
+	}
+
+	// Set logging
+	ff.AVUtil_log_set_level(options.level)
+	if options.callback != nil {
+		ff.AVUtil_log_set_callback(func(level ff.AVLog, message string, userInfo any) {
+			options.callback(message)
+		})
+	}
+
+	// Initialise network
+	ff.AVFormat_network_init()
+
+	// Set force flag - this is used to resample or resize decoded
+	// frames even if the target format is the same as the source format
+	if options.force {
+		manager.opts = append(manager.opts, OptForce())
+	}
+
+	// Retyrn success
+	return manager, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// 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. You can add additional options to the open call as
+// key=value pairs
+/*
+func (manager *Manager) Open(url string, format media.Format, opts ...string) (media.Media, error) {
+	opt := append([]Opt{OptInputOpt(opts...)}, manager.opts...)
+	if format != nil {
+		opt = append(opt, OptInputFormat(format.Name()))
+	}
+	return Open(url, opt...)
+}
+
+// Open an io.Reader for reading. If a format is specified, then the
+// format will be used to open the file. You can add additional options
+// to the open call as key=value pairs
+func (manager *Manager) NewReader(r io.Reader, format media.Format, opts ...string) (media.Media, error) {
+	opt := append([]Opt{OptInputOpt(opts...)}, manager.opts...)
+	if format != nil {
+		opt = append(opt, OptInputFormat(format.Name()))
+	}
+	return NewReader(r, opt...)
+}
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS - VERSION
+
+// Return version information
+func (manager *Manager) Version() []media.Metadata {
+	var result []media.Metadata
+	for _, v := range version.Version() {
+		result = append(result, NewMetadata(v.Key, v.Value))
+	}
+	return result
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS - LOGGING
+
+// Log error messages
+func (manager *Manager) Errorf(v string, args ...any) {
+	ff.AVUtil_log(nil, ff.AV_LOG_ERROR, v, args...)
+}
+
+// Log warning messages
+func (manager *Manager) Warningf(v string, args ...any) {
+	ff.AVUtil_log(nil, ff.AV_LOG_WARNING, v)
+}
+
+// Log info messages
+func (manager *Manager) Infof(v string, args ...any) {
+	ff.AVUtil_log(nil, ff.AV_LOG_INFO, v, args...)
+}

pkg/ffmpeg/manager.go

@@ -0,0 +1,40 @@
+package ffmpeg_test
+
+import (
+	"testing"
+
+	ffmpeg "github.com/mutablelogic/go-media/pkg/ffmpeg"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_manager_001(t *testing.T) {
+	assert := assert.New(t)
+
+	// Create a manager
+	manager, err := ffmpeg.NewManager(ffmpeg.OptLog(true, func(v string) {
+		t.Log(v)
+	}))
+	if !assert.NoError(err) {
+		t.FailNow()
+	}
+
+	manager.Infof("INFO test")
+	manager.Warningf("WARNING test")
+	manager.Errorf("ERROR test")
+}
+
+func Test_manager_002(t *testing.T) {
+	assert := assert.New(t)
+
+	// Create a manager
+	manager, err := ffmpeg.NewManager(ffmpeg.OptLog(true, func(v string) {
+		t.Log(v)
+	}))
+	if !assert.NoError(err) {
+		t.FailNow()
+	}
+
+	for _, v := range manager.Version() {
+		t.Log(v)
+	}
+}