Added methods for thumbnails

Author: djthorpe

cmd/cli/main.go

@@ -35,6 +35,7 @@ type CLI struct {
 	Artwork        ArtworkCmd        `cmd:"artwork" help:"Save artwork from media file"`
 	Probe          ProbeCmd          `cmd:"probe" help:"Probe media file or device"`
 	Decode         DecodeCmd         `cmd:"decode" help:"Decode media"`
+	Thumbnails     ThumbnailsCmd     `cmd:"thumbnails" help:"Generate thumbnails from media file"`
 }
 
 func main() {

cmd/cli/thumbnails.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"image/png"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"time"
+
+	// Packages
+	"github.com/mutablelogic/go-media"
+	"github.com/mutablelogic/go-media/pkg/file"
+)
+
+type ThumbnailsCmd struct {
+	Path  string        `arg:"" required:"" help:"Media file or path" type:"path"`
+	Dur   time.Duration `name:"duration" help:"Duration between thumnnails" type:"duration" default:"1m"`
+	Width int           `name:"width" help:"Width of thumbnail" type:"int" default:"320"`
+}
+
+func (cmd *ThumbnailsCmd) 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 *ThumbnailsCmd) 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 video - output 320x240 frames
+	// We should adjust this to match the output size of the thumbnail
+	decoder, err := reader.Decoder(func(stream media.Stream) (media.Parameters, error) {
+		if stream.Type().Is(media.VIDEO) {
+			// TODO: We need to use the sample aspect ratio
+			width := cmd.Width
+			height := stream.Parameters().Height() * width / stream.Parameters().Width()
+			return manager.VideoParameters(width, height, "rgb24")
+		} else {
+			return nil, nil
+		}
+	})
+	if err != nil {
+		return err
+	}
+
+	// Decode the frames
+	var t time.Duration = -1
+	return decoder.Decode(ctx, func(frame media.Frame) error {
+		// Logic to return if we have a frame within the duration
+		if frame.Time() < 0 {
+			return nil
+		} else if t != -1 && frame.Time()-t < cmd.Dur {
+			return nil
+		} else {
+			t = frame.Time()
+		}
+
+		// Save the frame
+		filename := fmt.Sprintf("%s.%s.png", filepath.Base(path), t.Truncate(time.Second))
+		image, err := frame.Image()
+		if err != nil {
+			return err
+		}
+
+		w, err := os.Create(filename)
+		if err != nil {
+			return err
+		}
+		defer w.Close()
+
+		fmt.Println("Writing", filename)
+		if err := png.Encode(w, image); err != nil {
+			return errors.Join(err, os.Remove(filename))
+		}
+
+		return nil
+	})
+}

decoder.go

@@ -77,6 +77,11 @@ func newDemuxer(input *ff.AVFormatContext, mapfn DecoderMapFunc, force bool) (*d
 		return nil, errors.Join(result, demuxer.close())
 	}
 
+	// If no streams were selected, return an error
+	if len(demuxer.decoders) == 0 {
+		return nil, errors.Join(demuxer.close(), errors.New("no streams to decode"))
+	}
+
 	// Create a frame for encoding - after resampling and resizing
 	if frame := ff.AVUtil_frame_alloc(); frame == nil {
 		return nil, errors.Join(demuxer.close(), errors.New("failed to allocate frame"))

frame.go

@@ -3,6 +3,7 @@ package media
 import (
 	"encoding/json"
 	"image"
+	"time"
 
 	// Packages
 	imagex "github.com/mutablelogic/go-media/pkg/image"
@@ -70,6 +71,15 @@ func (frame *frame) Type() MediaType {
 	return NONE
 }
 
+// Return the timestamp as a duration, or minus one if not set
+func (frame *frame) Time() time.Duration {
+	pts := frame.ctx.Pts()
+	if pts == ff.AV_NOPTS_VALUE {
+		return -1
+	}
+	return secondsToDuration(float64(pts) * ff.AVUtil_q2d(frame.ctx.TimeBase()))
+}
+
 // Return the number of planes for a specific PixelFormat
 // or SampleFormat and ChannelLayout combination
 func (frame *frame) NumPlanes() int {
@@ -213,3 +223,10 @@ func (frame *frame) PixelFormat() string {
 	}
 	return ff.AVUtil_get_pix_fmt_name(frame.ctx.PixFmt())
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func secondsToDuration(seconds float64) time.Duration {
+	return time.Duration(seconds * float64(time.Second))
+}

interfaces.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"image"
 	"io"
+	"time"
 )
 
 // Manager represents a manager for media formats and devices.
@@ -257,6 +258,10 @@ type Frame interface {
 	// Return a frame plane as a byte slice.
 	Bytes(int) []byte
 
+	// Return the presentation timestamp for the frame or
+	// a negative number if not set
+	Time() time.Duration
+
 	// Return a frame as an image, which supports the following
 	// pixel formats: AV_PIX_FMT_GRAY8, AV_PIX_FMT_RGBA,
 	// AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV420P

sys/ffmpeg61/avutil_rational.go

@@ -60,9 +60,15 @@ func (r AVRational) Float(multiplier int64) float64 {
 ////////////////////////////////////////////////////////////////////////////////
 // BINDINGS
 
+// Convert a double precision floating point number to a rational.
 func AVUtil_rational_d2q(d float64, max int) AVRational {
 	if max == 0 {
 		max = C.INT_MAX
 	}
 	return AVRational(C.av_d2q(C.double(d), C.int(max)))
 }
+
+// Convert an AVRational to a double.
+func AVUtil_q2d(a AVRational) float64 {
+	return float64(C.av_q2d(C.AVRational(a)))
+}