Changes

Author: djthorpe

interfaces.go

@@ -29,14 +29,14 @@ type Manager interface {
 	// 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, ...Parameters) (Media, error)
+	Create(string, Format, []Metadata, ...Parameters) (Media, error)
 
 	// Create a media stream for writing. The format will be used to
 	// determine the formar type 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, ...Parameters) (Media, error)
+	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
@@ -48,7 +48,7 @@ type Manager interface {
 	// can be NONE (for any) or combinations of DEVICE and STREAM.
 	OutputFormats(MediaType, ...string) []Format
 
-	// Return supported devices for a given format name
+	// 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
@@ -87,7 +87,6 @@ type Manager interface {
 }
 
 // Device represents a device for input or output of media streams.
-// TODO
 type Device interface {
 	// Device name, format depends on the device
 	Name() string

manager.go

@@ -267,14 +267,14 @@ func (manager *manager) Read(r io.Reader, format Format, opts ...string) (Media,
 	return newReader(r, format, opts...)
 }
 
-// Create a media file for writing, from a path.
-func (manager *manager) Create(string, Format, ...Parameters) (Media, error) {
-	return nil, ErrNotImplemented
+// Create a media file for writing, from a url, path, or device.
+func (manager *manager) Create(url string, format Format, metadata []Metadata, params ...Parameters) (Media, error) {
+	return createMedia(url, format, metadata, params...)
 }
 
 // Create a media stream for writing.
-func (manager *manager) Write(io.Writer, Format, ...Parameters) (Media, error) {
-	return nil, ErrNotImplemented
+func (manager *manager) Write(w io.Writer, format Format, metadata []Metadata, params ...Parameters) (Media, error) {
+	return createWriter(w, format, metadata, params...)
 }
 
 // Return version information for the media manager as a set of metadata

mediatype.go

@@ -22,10 +22,11 @@ const (
 	OUTPUT                           // Muxer
 	FILE                             // File or byte stream
 	DEVICE                           // Device rather than stream
+	CODEC                            // Codec
 
 	// Set minimum and maximum values
 	MIN = UNKNOWN
-	MAX = DEVICE
+	MAX = CODEC
 
 	// Convenience values
 	ANY = NONE
@@ -71,6 +72,8 @@ func (v MediaType) FlagString() string {
 		return "FILE"
 	case DEVICE:
 		return "DEVICE"
+	case CODEC:
+		return "CODEC"
 	}
 	return ""
 }

stream.go

@@ -12,16 +12,39 @@ type stream struct {
 	*ff.AVStream
 }
 
+type writerstream struct {
+	*ff.AVStream
+}
+
 var _ Stream = (*stream)(nil)
+var _ Stream = (*writerstream)(nil)
 
 ////////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// Open media from a url, file path or device
+// Stream wrapper for decoding
 func newStream(ctx *ff.AVStream) *stream {
 	return &stream{ctx}
 }
 
+// Stream wrapper for encoding
+func newWriterStream(ctx *ff.AVFormatContext, param Parameters) (*writerstream, error) {
+	// Parameters - Codec
+	var codec_id ff.AVCodecID
+	if param.Type().Is(CODEC) {
+		codec_id = param.Codec().ID()
+	} else if param.Type().Is(VIDEO) {
+		codec_id = ctx.Input().VideoCodec()
+	} else if param.Type().Is(AUDIO) {
+		codec_id = ctx.Input().AudioCodec()
+	} else {
+		return nil, ErrBadParameter.With("invalid stream parameters")
+
+	}
+
+	return nil, ErrNotImplemented
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 

writer.go

@@ -0,0 +1,123 @@
+package media
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	// Packages
+	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type writer struct {
+	t      MediaType
+	output *ff.AVFormatContext
+	avio   *ff.AVIOContextEx
+}
+
+type writer_callback struct {
+	w io.Writer
+}
+
+var _ Media = (*writer)(nil)
+
+////////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+// Create media from a url or device
+func createMedia(url string, format Format, metadata []Metadata, params ...Parameters) (*writer, error) {
+	writer := new(writer)
+	writer.t = OUTPUT
+
+	// Guess the output format
+	var ofmt *ff.AVOutputFormat
+	if format == nil && url != "" {
+		ofmt = ff.AVFormat_guess_format("", url, "")
+	} else if format != nil {
+		ofmt = format.(*outputformat).ctx
+	}
+	if ofmt == nil {
+		return nil, ErrBadParameter.With("unable to guess the output format")
+	}
+
+	// Allocate the output media context
+	ctx, err := ff.AVFormat_create_file(url, ofmt)
+	if err != nil {
+		return nil, err
+	} else {
+		writer.output = ctx
+	}
+
+	// Add streams
+	for _, param := range params {
+		stream, err := newWriterStream(ctx, param)
+		if err != nil {
+			return nil, errors.Join(err, writer.Close())
+		} else {
+			fmt.Println("TODO: STREAM", stream)
+		}
+	}
+
+	// Open the output file, if needed
+	if !ctx.Flags().Is(ff.AVFMT_NOFILE) {
+		w, err := ff.AVFormat_avio_open(url, ff.AVIO_FLAG_WRITE)
+		if err != nil {
+			return nil, errors.Join(err, writer.Close())
+		} else {
+			ctx.SetPb(w)
+			writer.avio = w
+		}
+	}
+
+	// TODO: Metadata
+
+	// TODO: Write the header
+
+	// Return success
+	return writer, nil
+}
+
+// Create media from io.Writer
+// TODO
+func createWriter(w io.Writer, format Format, metadata []Metadata, params ...Parameters) (*writer, error) {
+	return nil, ErrNotImplemented
+}
+
+func (w *writer) Close() error {
+	var result error
+
+	// TODO: Write the trailer
+
+	// Free resources
+	if w.avio != nil {
+		result = errors.Join(result, ff.AVFormat_avio_close(w.avio))
+	}
+	result = errors.Join(result, ff.AVFormat_close_writer(w.output))
+
+	// Return any errors
+	return result
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (w *writer) Decoder(DecoderMapFunc) (Decoder, error) {
+	return nil, ErrNotImplemented
+}
+
+// Return OUTPUT and combination of DEVICE and STREAM
+func (w *writer) Type() MediaType {
+	return OUTPUT
+}
+
+// Return the metadata for the media.
+func (w *writer) Metadata() []Metadata {
+	// Not yet implemented
+	return nil
+}