Merge pull request #29 from mutablelogic/ffmpeg61

Added Testcard generator

Author: djthorpe

README.md

@@ -61,6 +61,8 @@ and open media files and byte streams.
 ### Demultiplexing
 
 ```go
+package main
+
 import (
   media "github.com/mutablelogic/go-media"
 )
@@ -106,51 +108,82 @@ func main() {
 
 ### Decoding - Video
 
-This example shows you how to decode video frames from a media file into images.
+This example shows you how to decode video frames from a media file into images, and
+encode those images to JPEG format.
 
 ```go
+package main
+
 import (
-  media "github.com/mutablelogic/go-media"
+  "context"
+  "fmt"
+  "image/jpeg"
+  "io"
+  "log"
+  "os"
+  "path/filepath"
+
+  // Packages
+  ffmpeg "github.com/mutablelogic/go-media/pkg/ffmpeg"
+
+  // Namespace imports
+  . "github.com/mutablelogic/go-media"
 )
 
 func main() {
-  manager, err := media.NewManager()
+  // Open a media file for reading. The format of the file is guessed.
+  input, err := ffmpeg.Open(os.Args[1])
   if err != nil {
     log.Fatal(err)
   }
 
-  media, err := manager.Open("etc/test/sample.mp4", nil)
-  if err != nil {
-    log.Fatal(err)
+  // Make a map function which can be used to decode the streams and set
+  // the parameters we want from the decode. The audio and video streams
+  // are resampled and resized to fit the parameters we pass back the decoder.
+  mapfunc := func(stream int, par *ffmpeg.Par) (*ffmpeg.Par, error) {
+    if par.Type() == VIDEO {
+      // Convert frame to yuv420p to frame size and rate as source
+      return ffmpeg.VideoPar("yuv420p", par.WidthHeight(), par.FrameRate()), nil
+    }
+    // Ignore other streams
+    return nil, nil
   }
-  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
-    }
-  })
+  // Make a folder where we're going to store the thumbnails
+  tmp, err := os.MkdirTemp("", "decode")
   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()
+  // Decode the streams and receive the video frame
+  // If the map function is nil, the frames are copied. In this example,
+  // we get a yuv420p frame at the same size as the original.
+  n := 0
+  err = input.Decode(context.Background(), mapfunc, func(stream int, frame *ffmpeg.Frame) error {
+    // Write the frame to a file
+    w, err := os.Create(filepath.Join(tmp, fmt.Sprintf("frame-%d-%d.jpg", stream, n)))
     if err != nil {
       return err
     }
-    // TODO: Do something with the image here....
-    return nil
-  }
+    defer w.Close()
 
-  // decode frames from the stream
-  if err := decoder.Decode(context.Background(), framefn); err != nil {
+    // Convert to an image and encode a JPEG
+    if image, err := frame.Image(); err != nil {
+      return err
+    } else if err := jpeg.Encode(w, image, nil); err != nil {
+      return err
+    } else {
+      log.Println("Wrote:", w.Name())
+    }
+
+    // End after 10 frames
+    n++
+    if n >= 10 {
+      return io.EOF
+    }
+    return nil
+  })
+  if err != nil {
     log.Fatal(err)
   }
 }
@@ -159,68 +192,67 @@ func main() {
 ### Encoding - Audio and Video
 
 This example shows you how to encode video and audio frames into a media file.
+It creates a testcard signal overlayed with a timestamp, and a 1KHz tone at -5dB
 
 ```go
 package main
 
 import (
+  "fmt"
   "io"
   "log"
   "os"
-  "time"
 
-  media "github.com/mutablelogic/go-media"
+  // Packages
   ffmpeg "github.com/mutablelogic/go-media/pkg/ffmpeg"
   generator "github.com/mutablelogic/go-media/pkg/generator"
-  ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
 )
 
+// This example encodes an audio an video stream to a file
 func main() {
   // Create a new file with an audio and video stream
-  // 30fps and 22050Hz mono audio
   file, err := ffmpeg.Create(os.Args[1],
-    ffmpeg.OptStream(1, ffmpeg.VideoPar("yuv420p", "640x480", 30)),
+    ffmpeg.OptStream(1, ffmpeg.VideoPar("yuv420p", "1024x720", 30)),
     ffmpeg.OptStream(2, ffmpeg.AudioPar("fltp", "mono", 22050)),
   )
   if err != nil {
     log.Fatal(err)
   }
   defer file.Close()
 
-  // Make an video generator which can generate YUV420P frames
-  // with the same parameters as the video stream
-  video, err := generator.NewYUV420P(file.Stream(1).Par())
+  // Make an video generator which can generate frames with the same
+  // parameters as the video stream
+  video, err := generator.NewEBU(file.Stream(1).Par())
   if err != nil {
     log.Fatal(err)
   }
   defer video.Close()
 
-  // Make an audio generator which can generate a 440Hz tone
+  // Make an audio generator which can generate a 1KHz tone
   // at -5dB with the same parameters as the audio stream
-  audio, err := generator.NewSine(440, -5, file.Stream(2).Par())
+  audio, err := generator.NewSine(1000, -5, file.Stream(2).Par())
   if err != nil {
     log.Fatal(err)
   }
   defer audio.Close()
 
-  // Write 1 min of frames, passing video and audio frames to the encoder
+  // Write 90 seconds, passing video and audio frames to the encoder
   // and returning io.EOF when the duration is reached
-  duration := time.Minute
-  if err := file.Encode(func(stream int) (*ff.AVFrame, error) {
-    var frame media.Frame
+  duration := float64(90)
+  err = file.Encode(func(stream int) (*ffmpeg.Frame, error) {
+    var frame *ffmpeg.Frame
     switch stream {
     case 1:
       frame = video.Frame()
     case 2:
       frame = audio.Frame()
     }
-    if frame.Time() >= duration {
-      return nil, io.EOF
-    } else {
-      log.Println("Frame", stream, "=>", frame.Time().Truncate(time.Millisecond))
-      return frame.(*ffmpeg.Frame).AVFrame(), nil
+    if frame != nil && frame.Ts() < duration {
+      return frame, nil
     }
-  }, nil); err != nil {
+    return nil, io.EOF
+  }, nil)
+  if err != nil {
     log.Fatal(err)
   }
 }
@@ -233,6 +265,7 @@ TODO
 ### Retrieving Metadata and Artwork from a media file
 
 Here is an example of opening a media file and retrieving metadata and artwork.
+You have to read the artwork separately from the metadata.
 
 ```go
 package main
@@ -241,20 +274,13 @@ import (
   "log"
   "os"
 
-  media "github.com/mutablelogic/go-media"
-  file "github.com/mutablelogic/go-media/pkg/file"
+  // Packages
+  ffmpeg "github.com/mutablelogic/go-media/pkg/ffmpeg"
 )
 
 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)
+  reader, err := ffmpeg.Open(os.Args[1])
   if err != nil {
     log.Fatal(err)
   }
@@ -268,14 +294,13 @@ func main() {
   }
 
   // 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)
+  // which needs to be converted to an image. 
+  for _, artwork := range reader.Metadata(ffmpeg.MetaArtwork) {
+    mimetype := artwork.Value()
+    if mimetype != "" {
+      // Retrieve the data using the metadata.Bytes() method
+      log.Print("We got some artwork of mimetype ", mimetype)
     }
-    log.Print("got artwork", mimetype, ext)
   }
 }
 ```

interfaces.go renamed to _old/interfaces.go

@@ -2,49 +2,75 @@ package main
 
 import (
 	"context"
+	"fmt"
+	"image/jpeg"
+	"io"
 	"log"
 	"os"
+	"path/filepath"
 
-	media "github.com/mutablelogic/go-media"
+	// Packages
+	ffmpeg "github.com/mutablelogic/go-media/pkg/ffmpeg"
+
+	// Namespace imports
+	. "github.com/mutablelogic/go-media"
 )
 
 func main() {
-	manager, err := media.NewManager()
+	// Open a media file for reading. The format of the file is guessed.
+	input, err := ffmpeg.Open(os.Args[1])
 	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.
-	file, err := manager.Open(os.Args[1], nil)
-	if err != nil {
-		log.Fatal(err)
+	// Make a map function which can be used to decode the streams and set
+	// the parameters we want each audio and video stream to have.
+	// The audio and video streams are resampled and resized to fit the
+	// parameters we pass to the decoder.
+	mapfunc := func(stream int, par *ffmpeg.Par) (*ffmpeg.Par, error) {
+		if stream == input.BestStream(VIDEO) {
+			// Convert frame to yuv420p as needed
+			return ffmpeg.VideoPar("yuv420p", par.WidthHeight(), par.FrameRate()), nil
+		}
+		// Ignore other streams
+		return nil, nil
 	}
-	defer file.Close()
-
-	// Choose which streams to demultiplex - pass the stream parameters
-	// to the decoder. If you don't want to resample or reformat the streams,
-	// then you can pass nil as the function and all streams will be demultiplexed.
-	decoder, err := file.Decoder(func(stream media.Stream) (media.Parameters, error) {
-		// Copy streams, don't resample or resize
-		return stream.Parameters(), nil
-	})
+
+	// Make a folder where we're going to store the thumbnails
+	tmp, err := os.MkdirTemp("", "decode")
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	// Demuliplex the stream and receive the frames of audio and video.
-	if err := decoder.Decode(context.Background(), func(frame media.Frame) error {
-		// Each packet is specific to a stream. It can be processed here
-		// to receive audio or video frames, then resize or resample them,
-		// for example. Alternatively, you can pass the packet to an encoder
-		// to remultiplex the streams without processing them.
-		log.Print(frame)
+	// Decode the streams and receive the video frame
+	// If the map function is nil, the frames are copied. In this example,
+	// we get a yuv420p frame at the same size as the original.
+	n := 0
+	err = input.Decode(context.Background(), mapfunc, func(stream int, frame *ffmpeg.Frame) error {
+		// Write the frame to a file
+		w, err := os.Create(filepath.Join(tmp, fmt.Sprintf("frame-%d.jpg", n)))
+		if err != nil {
+			return err
+		}
+		defer w.Close()
+
+		// Coovert to an image and encode a JPEG
+		if image, err := frame.Image(); err != nil {
+			return err
+		} else if err := jpeg.Encode(w, image, nil); err != nil {
+			return err
+		} else {
+			log.Println("Wrote:", w.Name())
+		}
 
-		// Return io.EOF to stop processing, nil to continue
+		// End after 10 frames
+		n++
+		if n >= 10 {
+			return io.EOF
+		}
 		return nil
-	}); err != nil {
+	})
+	if err != nil {
 		log.Fatal(err)
 	}
 }