Added new manager

Author: djthorpe

manager.go

@@ -5,6 +5,8 @@ functions to determine capabilities and manage media files and devices.
 */
 package media
 
+import "io"
+
 // Manager represents a manager for media formats and devices.
 // Create a new manager object using the NewManager function.
 //
@@ -26,7 +28,7 @@ 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(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
@@ -47,11 +49,6 @@ type Manager interface {
 	// of the caller to also close the writer when done.
 	//Write(io.Writer, Format, []Metadata, ...Parameters) (Media, error)
 
-	// 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 audio parameters for encoding
 	// ChannelLayout, SampleFormat, Samplerate
 	//AudioParameters(string, string, int) (Parameters, error)
@@ -113,3 +110,13 @@ type Format interface {
 	// The unique name that the format can be referenced as
 	Name() string
 }
+
+// A container format for a media file, reader, device or
+// network stream
+type Media interface {
+	io.Closer
+
+	// The type of the format, which can be combinations of
+	// INPUT, OUTPUT, DEVICE
+	Type() Type
+}

pkg/ffmpeg/decoder.go

@@ -8,6 +8,9 @@ import (
 
 	// Packages
 	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -35,7 +38,7 @@ func NewDecoder(stream *ff.AVStream, dest *Par, force bool) (*Decoder, error) {
 	// 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")
+		return nil, ErrInternalAppError.With("failed to allocate frame")
 	}
 
 	// Create a codec context for the decoder
@@ -114,12 +117,12 @@ func (d *Decoder) Close() error {
 // correct timebase, etc set
 func (d *Decoder) decode(packet *ff.AVPacket, fn DecoderFrameFn) error {
 	if fn == nil {
-		return errors.New("DecoderFrameFn is nil")
+		return ErrBadParameter.With("DecoderFrameFn is nil")
 	}
 
 	// 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
+		return ErrInternalAppError.With("AVCodec_send_packet:", err)
 	}
 
 	// get all the available frames from the decoder
@@ -136,7 +139,7 @@ func (d *Decoder) decode(packet *ff.AVPacket, fn DecoderFrameFn) error {
 			// Finished decoding packet or EOF
 			break
 		} else if err != nil {
-			return err
+			return ErrInternalAppError.With("AVCodec_receive_frame:", err)
 		}
 
 		// Obtain the output frame. If a new frame is returned, it is

pkg/ffmpeg/manager.go

@@ -8,6 +8,9 @@ import (
 	media "github.com/mutablelogic/go-media"
 	version "github.com/mutablelogic/go-media/pkg/version"
 	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -95,6 +98,24 @@ func (manager *Manager) NewReader(r io.Reader, format media.Format, opts ...stri
 }
 */
 
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS - READER
+
+func (manager *Manager) Open(url string, format media.Format, opts ...string) (media.Media, error) {
+	o := append([]Opt{}, manager.opts[:]...)
+	if format != nil {
+		if format_, ok := format.(*Format); ok && format_.Input != nil {
+			o = append(o, optInputFormat(format_))
+		} else {
+			return nil, ErrBadParameter.With("invalid input format")
+		}
+	}
+	if len(opts) > 0 {
+		o = append(o, OptInputOpt(opts...))
+	}
+	return Open(url, o...)
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS - FORMATS
 

pkg/ffmpeg/opts.go

@@ -2,7 +2,7 @@ package ffmpeg
 
 import (
 	// Package imports
-
+	media "github.com/mutablelogic/go-media"
 	ffmpeg "github.com/mutablelogic/go-media/sys/ffmpeg61"
 
 	// Namespace imports
@@ -32,6 +32,7 @@ type opts struct {
 	metadata []*Metadata
 
 	// Reader options
+	t       media.Type
 	iformat *ffmpeg.AVInputFormat
 	opts    []string // These are key=value pairs
 }
@@ -87,6 +88,19 @@ func OptInputFormat(name string) Opt {
 	}
 }
 
+// Input format from ff.AVInputFormat
+func optInputFormat(format *Format) Opt {
+	return func(o *opts) error {
+		if format != nil && format.Input != nil {
+			o.iformat = format.Input
+			o.t = format.Type()
+		} else {
+			return ErrBadParameter.With("invalid input format")
+		}
+		return nil
+	}
+}
+
 // Input format options
 func OptInputOpt(opt ...string) Opt {
 	return func(o *opts) error {

pkg/ffmpeg/reader.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"slices"
 	"strings"
+	"syscall"
 	"time"
 
 	// Packages
@@ -22,6 +23,7 @@ import (
 
 // Media reader which reads from a URL, file path or device
 type Reader struct {
+	t     media.Type
 	input *ff.AVFormatContext
 	avio  *ff.AVIOContextEx
 	force bool
@@ -122,8 +124,9 @@ func (r *Reader) open(options *opts) (*Reader, error) {
 		return nil, err
 	}
 
-	// Set force flag
+	// Set force flag and type
 	r.force = options.force
+	r.t = options.t | media.INPUT
 
 	// Return success
 	return r, nil
@@ -164,6 +167,11 @@ func (r *Reader) String() string {
 ////////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
+// Return the media type
+func (r *Reader) Type() media.Type {
+	return r.t
+}
+
 // Return the duration of the media stream, returns zero if unknown
 func (r *Reader) Duration() time.Duration {
 	duration := r.input.Duration()
@@ -391,8 +399,10 @@ FOR_LOOP:
 		default:
 			if err := ff.AVFormat_read_frame(r.input, packet); errors.Is(err, io.EOF) {
 				break FOR_LOOP
+			} else if errors.Is(err, syscall.EAGAIN) {
+				continue FOR_LOOP
 			} else if err != nil {
-				return err
+				return ErrInternalAppError.With("AVFormat_read_frame: ", err)
 			}
 			stream_index := packet.StreamIndex()
 			if decoder := decoders[stream_index]; decoder != nil {

sys/ffmpeg61/avformat_demux.go

@@ -112,6 +112,8 @@ func AVFormat_read_frame(ctx *AVFormatContext, packet *AVPacket) error {
 	if err := AVError(C.av_read_frame((*C.struct_AVFormatContext)(ctx), (*C.struct_AVPacket)(packet))); err < 0 {
 		if err == AVERROR_EOF {
 			return io.EOF
+		} else if err.IsErrno(syscall.EAGAIN) {
+			return syscall.EAGAIN
 		} else {
 			return err
 		}