Added logging

Author: djthorpe

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)
@@ -39,19 +38,19 @@ func (cmd *DecodeCmd) Run(globals *Globals) error {
 	defer reader.Close()
 
 	// Create a decoder - copy streams
-	decoder, err := reader.Decoder(nil, false)
+	decoder, err := reader.Decoder(nil)
 	if err != nil {
 		return err
 	}
 
 	// 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/formats.go

@@ -1,11 +1,8 @@
 package main
 
 import (
-	"os"
-
 	// Packages
 	"github.com/djthorpe/go-tablewriter"
-	"github.com/mutablelogic/go-media"
 )
 
 type CodecsCmd struct{}
@@ -17,28 +14,29 @@ type ChannelLayoutsCmd struct{}
 type PixelFormatsCmd struct{}
 
 func (cmd *CodecsCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
-	writer := tablewriter.New(os.Stdout, tablewriter.OptHeader(), tablewriter.OptOutputText())
-
+	manager := globals.manager
+	writer := globals.writer
 	codecs := manager.Codecs()
-
-	return writer.Write(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())
 }

cmd/cli/main.go

@@ -1,15 +1,24 @@
 package main
 
 import (
+	"context"
 	"os"
 	"path/filepath"
+	"syscall"
 
 	// Packages
 	kong "github.com/alecthomas/kong"
+	tablewriter "github.com/djthorpe/go-tablewriter"
+	media "github.com/mutablelogic/go-media"
 )
 
 type Globals struct {
+	manager media.Manager
+	writer  *tablewriter.Writer
+	ctx     context.Context
+
 	Debug bool `name:"debug" help:"Enable debug mode"`
+	Force bool `name:"force" help:"Force resampling and resizing on decode, even if the input and output parameters are the same"`
 }
 
 type CLI struct {
@@ -41,6 +50,23 @@ func main() {
 		kong.UsageOnError(),
 		kong.ConfigureHelp(kong.HelpOptions{Compact: true}),
 	)
+
+	// Create a manager object
+	// Only print out FATAL messages
+	manager, err := media.NewManager(media.OptLog(cli.Debug, nil))
+	if err != nil {
+		ctx.FatalIfErrorf(err)
+	}
+	cli.Globals.manager = manager
+
+	// Create a tablewriter object with text output
+	writer := tablewriter.New(os.Stdout, tablewriter.OptOutputText())
+	cli.Globals.writer = writer
+
+	// Create a context
+	cli.Globals.ctx = ContextForSignal(os.Interrupt, syscall.SIGQUIT)
+
+	// Run the command
 	if err := ctx.Run(&cli.Globals); err != nil {
 		ctx.FatalIfErrorf(err)
 	}

cmd/cli/metadata_artwork.go

@@ -1,74 +1,85 @@
 package main
 
 import (
+	"context"
 	"errors"
 	"fmt"
-	"mime"
-	"net/http"
+	"io/fs"
 	"os"
 	"path/filepath"
-	"strings"
 
 	// Packages
-	"github.com/djthorpe/go-tablewriter"
+
 	"github.com/mutablelogic/go-media"
+	"github.com/mutablelogic/go-media/pkg/file"
 )
 
 type MetadataCmd struct {
-	Path string `arg:"" required:"" help:"Media file" type:"path"`
+	Path string `arg:"" required:"" help:"Media file or directory of files" type:"path"`
 }
 
 type ArtworkCmd struct {
 	Path string `arg:"" required:"" help:"Media file" type:"path"`
 }
 
 func (cmd *MetadataCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
-	reader, err := manager.Open(cmd.Path, nil)
-	if err != nil {
+	// Create the walker with the processor callback
+	walker := file.NewWalker(func(ctx context.Context, abspath, relpath string, info fs.FileInfo) error {
+		// Ignore directories
+		if info.IsDir() {
+			return nil
+		}
+
+		// Open the file
+		reader, err := globals.manager.Open(filepath.Join(abspath, relpath), nil)
+		if err != nil {
+			globals.manager.Errorf("Error opening %q: %v\n", relpath, err)
+			return nil
+		}
+		defer reader.Close()
+
+		fmt.Println(info.Name())
+		for _, entry := range reader.Metadata() {
+			fmt.Println(entry)
+		}
+
+		return nil
+	})
+
+	if err := walker.Walk(globals.ctx, cmd.Path); err != nil {
 		return err
 	}
-	defer reader.Close()
 
-	// Print metadata
-	opts := []tablewriter.TableOpt{
-		tablewriter.OptHeader(),
-		tablewriter.OptOutputText(),
-	}
-	return tablewriter.New(os.Stdout, opts...).Write(reader.Metadata())
+	return nil
 }
 
 func (cmd *ArtworkCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
+	manager := globals.manager
 	reader, err := manager.Open(cmd.Path, nil)
 	if err != nil {
 		return err
 	}
 	defer reader.Close()
 
-	artwork := reader.Metadata(media.MetaArtwork)
-	if len(artwork) == 0 {
+	artworks := reader.Metadata(media.MetaArtwork)
+	if len(artworks) == 0 {
 		return errors.New("no artwork")
 	}
 
-	for i, a := range artwork {
-		data := a.Value().([]byte)
-		mimetype := http.DetectContentType(data)
-		if !strings.HasPrefix(mimetype, "image/") {
-			return fmt.Errorf("invalid mimetype %q for stream %d", mimetype, i)
-		}
-		ext, err := mime.ExtensionsByType(mimetype)
+	for i, artwork := range artworks {
+		data := artwork.Value().([]byte)
+		_, ext, err := file.MimeType(data)
 		if err != nil {
 			return err
-		}
-		if len(ext) == 0 {
-			return fmt.Errorf("no extension for mimetype %q", mimetype)
+		} else if ext == "" {
+			manager.Warningf("Artwork %d cannot be identified", i+1)
+			continue
 		}
 
-		// Use last extension
-		filename := filepath.Base(cmd.Path) + ext[len(ext)-1]
-		if len(artwork) > 1 {
-			filename = filepath.Base(cmd.Path) + fmt.Sprintf("%d.%s", i+1, ext[len(ext)-1])
+		// Modify the filename if there is more than one artwork
+		filename := filepath.Base(cmd.Path) + ext
+		if len(artworks) > 1 {
+			filename = filepath.Base(cmd.Path) + fmt.Sprintf("%d.%s", i+1, ext)
 		}
 
 		// Write the file

cmd/cli/muxers_demuxers.go

@@ -22,17 +22,20 @@ type DevicesCmd struct {
 }
 
 func (cmd *MuxersCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
+	manager := globals.manager
+
 	return Run(cmd.Filter, Outputs(manager, media.ANY, cmd.Filter))
 }
 
 func (cmd *DemuxersCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
+	manager := globals.manager
+
 	return Run(cmd.Filter, Inputs(manager, media.ANY, cmd.Filter))
 }
 
 func (cmd *DevicesCmd) Run(globals *Globals) error {
-	manager := media.NewManager()
+	manager := globals.manager
+
 	var formats []media.Format
 	formats = append(formats, Inputs(manager, media.DEVICE, cmd.Filter)...)
 	formats = append(formats, Outputs(manager, media.DEVICE, cmd.Filter)...)

cmd/cli/probe.go

@@ -21,7 +21,8 @@ var (
 func (cmd *ProbeCmd) Run(globals *Globals) error {
 	var format media.Format
 
-	manager := media.NewManager()
+	manager := globals.manager
+
 	filter := media.NONE
 
 	// Try device first

cmd/cli/version.go

@@ -4,15 +4,16 @@ import (
 	"os"
 
 	"github.com/djthorpe/go-tablewriter"
-	"github.com/mutablelogic/go-media"
 )
 
 type VersionCmd struct{}
 
 func (v *VersionCmd) Run(globals *Globals) error {
+	manager := globals.manager
+
 	opts := []tablewriter.TableOpt{
 		tablewriter.OptOutputText(),
 		tablewriter.OptDelimiter(' '),
 	}
-	return tablewriter.New(os.Stdout, opts...).Write(media.NewManager().Version())
+	return tablewriter.New(os.Stdout, opts...).Write(manager.Version())
 }

decoder.go

@@ -327,7 +327,7 @@ FOR_LOOP:
 func (d *decoder) decode(packet *ff.AVPacket, demuxfn DecoderFunc, framefn FrameFunc) error {
 	if demuxfn != nil {
 		// Send the packet (or a nil to flush) to the user defined packet function
-		return demuxfn(newPacket(packet))
+		return demuxfn(newPacket(packet, d.stream, d.codec.Codec().Type(), d.timeBase))
 	}
 
 	// Submit the packet to the decoder (nil packet will flush the decoder)