Merge pull request #16 from mutablelogic/ffmpeg61

Added images

Author: djthorpe

codec.go

@@ -0,0 +1,77 @@
+package media
+
+import (
+	"encoding/json"
+
+	// Packages
+	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type codec struct {
+	ctx *ff.AVCodec
+}
+
+var _ Codec = (*codec)(nil)
+
+////////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func newCodec(ctx *ff.AVCodec) *codec {
+	return &codec{ctx}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+type jsonCodec struct {
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	Type        string `json:"type"`
+}
+
+func (codec *codec) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&jsonCodec{
+		Name:        codec.Name(),
+		Description: codec.Description(),
+		Type:        codec.Type().String(),
+	})
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (codec *codec) Name() string {
+	return codec.ctx.Name()
+}
+
+// Return the codec description
+func (codec *codec) Description() string {
+	return codec.ctx.LongName()
+}
+
+// Return the codec type (AUDIO, VIDEO, SUBTITLE, DATA, INPUT, OUTPUT)
+func (codec *codec) Type() MediaType {
+	t := NONE
+	switch codec.ctx.Type() {
+	case ff.AVMEDIA_TYPE_AUDIO:
+		t = AUDIO
+	case ff.AVMEDIA_TYPE_VIDEO:
+		t = VIDEO
+	case ff.AVMEDIA_TYPE_SUBTITLE:
+		t = SUBTITLE
+	default:
+		t = DATA
+	}
+	if ff.AVCodec_is_encoder(codec.ctx) {
+		t |= OUTPUT
+	}
+	if ff.AVCodec_is_decoder(codec.ctx) {
+		t |= INPUT
+	}
+	return t
+}
+
+// TODO: Supported sample formats, channel layouts, pixel formats, etc.

decoder.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"syscall"
 
 	// Packages
 	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
@@ -161,122 +162,23 @@ func (d *decoder) close() error {
 // PUBLIC METHODS
 
 func (d *demuxer) Demux(ctx context.Context, fn DecoderFunc) error {
-	// If the decoder is nil then set it to default - which is to send the
-	// packet to the appropriate decoder
 	if fn == nil {
-		fn = func(packet Packet) error {
-			fmt.Println("TODO", packet)
-			return nil
-		}
-	}
-
-	// Allocate a packet
-	packet := ff.AVCodec_packet_alloc()
-	if packet == nil {
-		return errors.New("failed to allocate packet")
-	}
-	defer ff.AVCodec_packet_free(packet)
-
-	// Read packets
-FOR_LOOP:
-	for {
-		select {
-		case <-ctx.Done():
-			break FOR_LOOP
-		default:
-			if err := ff.AVFormat_read_frame(d.input, packet); errors.Is(err, io.EOF) {
-				break FOR_LOOP
-			} else if err != nil {
-				return err
-			}
-			stream := packet.StreamIndex()
-			if decoder := d.decoders[stream]; decoder != nil {
-				if err := decoder.decode(fn, packet); errors.Is(err, io.EOF) {
-					break FOR_LOOP
-				} else if err != nil {
-					return err
-				}
-			}
-			// Unreference the packet
-			ff.AVCodec_packet_unref(packet)
-		}
+		return errors.New("no decoder function provided")
 	}
-
-	// Flush the decoders
-	for _, decoder := range d.decoders {
-		if err := decoder.decode(fn, nil); err != nil {
-			return err
-		}
-	}
-
-	// Return the context error - will be cancelled, perhaps, or nil if the
-	// demuxer finished successfully without cancellation
-	return ctx.Err()
+	return d.demux(ctx, fn, nil)
 }
 
-func (d *demuxer) Decode(context.Context, FrameFunc) error {
-	// TODO
-	return errors.New("not implemented")
+func (d *demuxer) Decode(ctx context.Context, fn FrameFunc) error {
+	if fn == nil {
+		return errors.New("no decoder function provided")
+	}
+	return d.demux(ctx, nil, fn)
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // 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
-	return fn(newPacket(packet))
-}
-
-/*
-	// Get the codec
-	stream.
-
-		// Find the decoder for the stream
-		dec := ff.AVCodec_find_decoder(codec.ID())
-	if dec == nil {
-		return nil, fmt.Errorf("failed to find decoder for codec %q", codec.Name())
-	}
-
-	// Allocate a codec context for the decoder
-	dec_ctx := ff.AVCodec_alloc_context(dec)
-	if dec_ctx == nil {
-		return nil, fmt.Errorf("failed to allocate codec context for codec %q", codec.Name())
-	}
-
-	// Create a frame for encoding - after resampling and resizing
-	if frame := ff.AVUtil_frame_alloc(); frame == nil {
-		return nil, errors.New("failed to allocate frame")
-	} else {
-		decoder.frame = frame
-	}
-
-	// Return success
-	return decoder, nil
-}
-
-// Close the demuxer
-func (d *demuxer) close() error {
-
-}
-
-// Close the decoder
-func (d *decoder) close() error {
-
-}
-
-// Demultiplex streams from the reader
-func (d *demuxer) Demux(ctx context.Context, fn DecoderFunc) error {
-	// If the decoder is nil then set it to default
-	if fn == nil {
-		fn = func(packet Packet) error {
-			if packet == nil {
-				return d.decodePacket(nil)
-			}
-			return d.decodePacket(packet.(*ff.AVPacket))
-		}
-	}
-
+func (d *demuxer) demux(ctx context.Context, demuxfn DecoderFunc, framefn FrameFunc) error {
 	// Allocate a packet
 	packet := ff.AVCodec_packet_alloc()
 	if packet == nil {
@@ -292,13 +194,13 @@ FOR_LOOP:
 			break FOR_LOOP
 		default:
 			if err := ff.AVFormat_read_frame(d.input, packet); errors.Is(err, io.EOF) {
-				break
+				break FOR_LOOP
 			} else if err != nil {
 				return err
 			}
 			stream := packet.StreamIndex()
 			if decoder := d.decoders[stream]; decoder != nil {
-				if err := decoder.decode(fn, packet); errors.Is(err, io.EOF) {
+				if err := decoder.decode(packet, demuxfn, framefn); errors.Is(err, io.EOF) {
 					break FOR_LOOP
 				} else if err != nil {
 					return err
@@ -311,23 +213,23 @@ FOR_LOOP:
 
 	// Flush the decoders
 	for _, decoder := range d.decoders {
-		if err := decoder.decode(fn, nil); err != nil {
+		if err := decoder.decode(nil, demuxfn, framefn); err != nil {
 			return err
 		}
 	}
 
-	// Return success
-	return nil
+	// Return the context error - will be cancelled, perhaps, or nil if the
+	// demuxer finished successfully without cancellation
+	return ctx.Err()
 }
 
-func (d *decoder) decode(fn DecoderFunc, packet *ff.AVPacket) error {
-	// Send the packet to the user defined packet function or
-	// to the default version
-	return fn(packet)
-}
+func (d *decoder) decode(packet *ff.AVPacket, demuxfn DecoderFunc, framefn FrameFunc) error {
+	if demuxfn != nil {
+		// Send the packet to the user defined packet function
+		return demuxfn(newPacket(packet))
+	}
 
-func (d *demuxer) decodePacket(packet *ff.AVPacket) error {
-	// Submit the packet to the decoder. If nil then flush
+	// 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
 	}
@@ -341,62 +243,16 @@ func (d *demuxer) decodePacket(packet *ff.AVPacket) error {
 			return err
 		}
 
-		fmt.Println("TODO", d.frame)
-	}
-	return nil
-}
-
-// Resample or resize the frame, then pass back
-/*
-	if frame, err := d.re(d.frame); err != nil {
-		return err
-	} else if err := fn(frame); errors.Is(err, io.EOF) {
-		// End early
-		break
-	} else if err != nil {
-		return err
-	}*/
-
-// Flush
-/*
-	if frame, err := d.re(nil); err != nil {
-		return err
-	} else if frame == nil {
-		// NOOP
-	} else if err := fn(frame); errors.Is(err, io.EOF) {
-		// NOOP
-	} else if err != nil {
-		return err
-	}
-*/
-
-/*
-
-// Return a function to decode packets from the streams into frames
-func (r *reader) Decode(fn FrameFunc) DecoderFunc {
-	return func(codec Decoder, packet Packet) error {
-		if packet != nil {
-			// Submit the packet to the decoder
-			if err := ff.AVCodec_send_packet(codec.(*decoder).codec, packet.(*ff.AVPacket)); err != nil {
-				return err
-			}
-		} else {
-			// Flush remaining frames
-			if err := ff.AVCodec_send_packet(codec.(*decoder).codec, nil); err != nil {
-				return err
-			}
+		// Pass the frame
+		if err := framefn(newFrame(d.frame)); errors.Is(err, io.EOF) {
+			// End early
+			break
+		} else if err != nil {
+			return err
 		}
 
-		// get all the available frames from the decoder
-		for {
-			if err := ff.AVCodec_receive_frame(codec.(*decoder).codec, r.frame); errors.Is(err, syscall.EAGAIN) || errors.Is(err, io.EOF) {
-				// Finished decoding packet or EOF
-				break
-			} else if err != nil {
-				return err
-			}
-
-			// Resample or resize the frame, then pass back
+		// Resample or resize the frame, then pass back
+		/*
 			if frame, err := codec.(*decoder).re(r.frame); err != nil {
 				return err
 			} else if err := fn(frame); errors.Is(err, io.EOF) {
@@ -405,9 +261,11 @@ func (r *reader) Decode(fn FrameFunc) DecoderFunc {
 			} else if err != nil {
 				return err
 			}
-		}
+		*/
+	}
 
-		// Flush
+	// TODO: Flush
+	/*
 		if frame, err := codec.(*decoder).re(nil); err != nil {
 			return err
 		} else if frame == nil {
@@ -416,10 +274,8 @@ func (r *reader) Decode(fn FrameFunc) DecoderFunc {
 			// NOOP
 		} else if err != nil {
 			return err
-		}
+		}*/
 
-		// Success
-		return nil
-	}
+	// Return success
+	return nil
 }
-*/