Merge pull request #17 from mutablelogic/ffmpeg61

Lots of changes for decoding

Author: djthorpe

README.md

@@ -16,8 +16,7 @@ you are interested in, please see below "Contributing & Distribution" below.
 
 ## Requirements
 
-In order to build the examples, you'll need the library and header files for [ffmpeg 6](https://ffmpeg.org/download.html) installed. 
-The `chromaprint` library is also required for fingerprinting audio files. On Macintosh with [homebrew](http://bew.sh/), for example:
+In order to build the examples, you'll need the library and header files for [FFmpeg 6](https://ffmpeg.org/download.html) installed.The `chromaprint` library is also required for fingerprinting audio files. On Macintosh with [homebrew](http://bew.sh/), for example:
 
 ```bash
 brew install ffmpeg@6 chromaprint make
@@ -67,7 +66,10 @@ import (
 )
 
 func main() {
-  manager := media.NewManager()
+  manager, err := media.NewManager()
+  if err != nil {
+    log.Fatal(err)
+  }
 
   // Open a media file for reading. The format of the file is guessed.
   // Alteratively, you can pass a format as the second argument. Further optional
@@ -102,9 +104,57 @@ func main() {
 }
 ```
 
-### Decoding
+### Decoding - Video Frames
 
-TODO
+This example shows you how to decode video frames from a media file into images.
+
+```go
+import (
+  media "github.com/mutablelogic/go-media"
+)
+
+func main() {
+  manager, err := media.NewManager()
+  if err != nil {
+    log.Fatal(err)
+  }
+
+  media, err := manager.Open("etc/test/sample.mp4", nil)
+  if err != nil {
+    log.Fatal(err)
+  }
+  defer media.Close()
+
+  // Create a decoder for the media file. Only video streams are decoded
+  decoder, err := media.Decoder(func(stream Stream) (Parameters, error) {
+    if stream.Type() == VIDEO {
+      // Copy video
+      return stream.Parameters(), nil
+    } else {
+      // Ignore other stream types
+      return nil, nil
+    }
+  })
+  if err != nil {
+    log.Fatal(err)
+  }
+
+  // The frame function is called for each frame in the stream
+  framefn := func(frame Frame) error {
+    image, err := frame.Image()
+    if err != nil {
+      return err
+    }
+    // TODO: Do something with the image here....
+    return nil
+  }
+
+  // decode frames from the stream
+  if err := decoder.Decode(context.Background(), framefn); err != nil {
+    log.Fatal(err)
+  }
+}
+```
 
 ### Encoding
 
@@ -116,7 +166,53 @@ TODO
 
 ### Retrieving Metadata and Artwork from a media file
 
-TODO
+Here is an example of opening a media file and retrieving metadata and artwork.
+
+```go
+package main
+
+import (
+  "log"
+  "os"
+
+  media "github.com/mutablelogic/go-media"
+  file "github.com/mutablelogic/go-media/pkg/file"
+)
+
+func main() {
+  manager, err := media.NewManager()
+  if err != nil {
+    log.Fatal(err)
+  }
+
+  // Open a media file for reading. The format of the file is guessed.
+  // Alteratively, you can pass a format as the second argument. Further optional
+  // arguments can be used to set the format options.
+  reader, err := manager.Open(os.Args[1], nil)
+  if err != nil {
+    log.Fatal(err)
+  }
+  defer reader.Close()
+
+  // Retrieve all the metadata from the file, and display it. If you pass
+  // keys to the Metadata function, then only entries with those keys will be
+  // returned.
+  for _, metadata := range reader.Metadata() {
+    log.Print(metadata.Key(), " => ", metadata.Value())
+  }
+
+  // Retrieve artwork by using the MetaArtwork key. The value is of type []byte.
+  // which needs to be converted to an image. There is a utility method to
+  // detect the image type.
+  for _, artwork := range reader.Metadata(media.MetaArtwork) {
+    mimetype, ext, err := file.MimeType(artwork.Value().([]byte))
+    if err != nil {
+      log.Fatal(err)
+    }
+    log.Print("got artwork", mimetype, ext)
+  }
+}
+```
 
 ### Audio Fingerprinting
 
@@ -139,8 +235,14 @@ The license is Apache 2 so feel free to redistribute. Redistributions in either
 code or binary form must reproduce the copyright notice, and please link back to this
 repository for more information:
 
+> go-media
+> https://github.com/mutablelogic/go-media/
 > Copyright (c) 2021-2024 David Thorpe, All rights reserved.
 
+This software links to shared libraries of [FFmpeg](http://ffmpeg.org/) licensed under
+the [LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html).
+
 ## References
 
 * https://ffmpeg.org/doxygen/6.1/index.html
+* https://pkg.go.dev/github.com/mutablelogic/go-media

cmd/cli/context.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/signal"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// ContextForSignal returns a context object which is cancelled when a signal
+// is received. It returns nil if no signal parameter is provided
+func ContextForSignal(signals ...os.Signal) context.Context {
+	if len(signals) == 0 {
+		return nil
+	}
+
+	ch := make(chan os.Signal, 1)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// Send message on channel when signal received
+	signal.Notify(ch, signals...)
+
+	// When any signal received, call cancel
+	go func() {
+		<-ch
+		cancel()
+	}()
+
+	// Return success
+	return ctx
+}

cmd/cli/decode.go

@@ -3,7 +3,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
 
 	// Packages
 	"github.com/djthorpe/go-tablewriter"
@@ -20,7 +19,7 @@ type DecodeCmd struct {
 func (cmd *DecodeCmd) Run(globals *Globals) error {
 	var format media.Format
 
-	manager := media.NewManager()
+	manager := globals.manager
 	if cmd.Format != "" {
 		if formats := manager.InputFormats(media.NONE, cmd.Format); len(formats) == 0 {
 			return fmt.Errorf("unknown format %q", cmd.Format)
@@ -45,13 +44,13 @@ func (cmd *DecodeCmd) Run(globals *Globals) error {
 	}
 
 	// Demultiplex the stream
+	writer := globals.writer
 	header := []tablewriter.TableOpt{tablewriter.OptHeader()}
-	tablewriter := tablewriter.New(os.Stdout, tablewriter.OptOutputText())
 	return decoder.Demux(context.Background(), func(packet media.Packet) error {
 		if packet == nil {
 			return nil
 		}
-		if err := tablewriter.Write(packet, header...); err != nil {
+		if err := writer.Write(packet, header...); err != nil {
 			return err
 		}
 		// Reset the header

cmd/cli/fingerprint.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io/fs"
+	"path/filepath"
+	"time"
+
+	// Packages
+	"github.com/mutablelogic/go-media"
+	"github.com/mutablelogic/go-media/pkg/chromaprint"
+	"github.com/mutablelogic/go-media/pkg/file"
+)
+
+type FimgerprintCmd struct {
+	Path string `arg:"" required:"" help:"Media file or path" type:"path"`
+}
+
+func (cmd *FimgerprintCmd) Run(globals *Globals) error {
+	// Create the walker with the processor callback
+	walker := file.NewWalker(func(ctx context.Context, root, relpath string, info fs.FileInfo) error {
+		if info.IsDir() || info.Size() == 0 {
+			return nil
+		}
+		if err := cmd.mediaWalker(ctx, globals.manager, filepath.Join(root, relpath)); err != nil {
+			if err == context.Canceled {
+				globals.manager.Infof("Cancelled\n")
+			} else {
+				globals.manager.Errorf("Error processing %q: %v\n", relpath, err)
+			}
+		}
+		return nil
+	})
+
+	// Walk the filesystem
+	return walker.Walk(globals.ctx, cmd.Path)
+}
+
+func (cmd *FimgerprintCmd) mediaWalker(ctx context.Context, manager media.Manager, path string) error {
+	reader, err := manager.Open(path, nil)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+
+	// Create a decoder for audio - needs to be s16 pcm for chromaprint
+	decoder, err := reader.Decoder(func(stream media.Stream) (media.Parameters, error) {
+		if stream.Type().Is(media.AUDIO) {
+			return manager.AudioParameters("mono", "s16", 22050)
+		} else {
+			return nil, nil
+		}
+	})
+	if err != nil {
+		return err
+	}
+
+	// Create a fingerprinter
+	fingerprint := chromaprint.New(22050, 1, time.Minute)
+	defer fingerprint.Close()
+
+	// Decode the frames
+	if err := decoder.Decode(ctx, func(frame media.Frame) error {
+		_, err := fingerprint.Write(frame.Int16(0))
+		if err != nil {
+			return err
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	if hash, err := fingerprint.Finish(); err != nil {
+		return err
+	} else {
+		fmt.Println(path, "=>", hash)
+	}
+
+	// Return success
+	return nil
+}

cmd/cli/formats.go

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