Added parameters

Author: djthorpe

interfaces.go

@@ -72,7 +72,7 @@ type Manager interface {
 
 	// Return video parameters for encoding
 	// Width, Height, PixelFormat, Framerate
-	VideoParameters(int, int, string, float32) (VideoParameters, error)
+	VideoParameters(int, int, string, float64) (VideoParameters, error)
 
 	// Return version information for the media manager as a set of
 	// metadata
@@ -184,7 +184,7 @@ type AudioParameters interface {
 	SampleFormat() string
 
 	// Return the sample rate (Hz)
-	SampleRate() int
+	Samplerate() int
 
 	// TODO:
 	// Planar, number of planes, bits and bytes per sample
@@ -202,7 +202,7 @@ type VideoParameters interface {
 	PixelFormat() string
 
 	// Return the frame rate (fps)
-	FrameRate() int
+	Framerate() float64
 
 	// TODO:
 	// Planar, number of planes, names of the planes, bits and bytes per pixel

manager.go

@@ -215,14 +215,14 @@ func (manager *manager) PixelFormats() []Metadata {
 
 // Return audio parameters for encoding
 // ChannelLayout, SampleFormat, Samplerate
-func (manager *manager) AudioParameters(string, string, int) (AudioParameters, error) {
-	return nil, ErrNotImplemented
+func (manager *manager) AudioParameters(channels string, samplefmt string, samplerate int) (AudioParameters, error) {
+	return newAudioParametersEx(channels, samplefmt, samplerate)
 }
 
 // Return video parameters for encoding
 // Width, Height, PixelFormat, Framerate
-func (manager *manager) VideoParameters(int, int, string, float32) (VideoParameters, error) {
-	return nil, ErrNotImplemented
+func (manager *manager) VideoParameters(width int, height int, pixelfmt string, framerate float64) (VideoParameters, error) {
+	return newVideoParametersEx(width, height, pixelfmt, framerate)
 }
 
 // Open a media file or device for reading, from a path or url.

parameters.go

@@ -0,0 +1,186 @@
+package media
+
+import (
+	"encoding/json"
+	"math"
+
+	ff "github.com/mutablelogic/go-media/sys/ffmpeg61"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type par struct {
+	t MediaType
+	audiopar
+	videopar
+}
+
+type audiopar struct {
+	Ch           ff.AVChannelLayout
+	SampleFormat ff.AVSampleFormat
+	Samplerate   int
+}
+
+type videopar struct {
+	PixelFormat ff.AVPixelFormat
+	Width       int
+	Height      int
+	Framerate   ff.AVRational
+}
+
+var _ Parameters = (*par)(nil)
+
+////////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+// Create new parameters for audio sampling from number of channels, sample format and sample rate in Hz
+func newAudioParameters(numchannels int, samplefmt string, samplerate int) (*par, error) {
+	// Get channel layout from number of channels
+	var ch ff.AVChannelLayout
+	ff.AVUtil_channel_layout_default(&ch, numchannels)
+	if name, err := ff.AVUtil_channel_layout_describe(&ch); err != nil {
+		return nil, err
+	} else {
+		return newAudioParametersEx(name, samplefmt, samplerate)
+	}
+}
+
+// Create new parameters for audio sampling from a channel layout name, sample format and sample rate in Hz
+func newAudioParametersEx(channels string, samplefmt string, samplerate int) (*par, error) {
+	par := new(par)
+	par.t = AUDIO
+
+	// Set the  parameters
+	if err := ff.AVUtil_channel_layout_from_string(&par.audiopar.Ch, channels); err != nil {
+		return nil, err
+	}
+	if fmt := ff.AVUtil_get_sample_fmt(samplefmt); fmt == ff.AV_SAMPLE_FMT_NONE {
+		return nil, ErrBadParameter.Withf("sample format %q", samplefmt)
+	} else {
+		par.audiopar.SampleFormat = fmt
+	}
+	if samplerate <= 0 {
+		return nil, ErrBadParameter.Withf("samplerate %v", samplerate)
+	} else {
+		par.audiopar.Samplerate = samplerate
+	}
+
+	// Return success
+	return par, nil
+}
+
+// Create new parameters for video from a width, height, pixel format and framerate in fps
+func newVideoParametersEx(width int, height int, pixelfmt string, framerate float64) (*par, error) {
+	par := new(par)
+	par.t = VIDEO
+
+	// Set the  parameters
+	if width <= 0 {
+		// Negative widths might mean "flip" but not tested yet
+		return nil, ErrBadParameter.Withf("width %v", width)
+	} else {
+		par.videopar.Width = width
+	}
+	if height <= 0 {
+		// Negative heights might mean "flip" but not tested yet
+		return nil, ErrBadParameter.Withf("height %v", height)
+	} else {
+		par.videopar.Height = height
+	}
+	if fmt := ff.AVUtil_get_pix_fmt(pixelfmt); fmt == ff.AV_PIX_FMT_NONE {
+		return nil, ErrBadParameter.Withf("pixel format %q", pixelfmt)
+	} else {
+		par.videopar.PixelFormat = fmt
+	}
+	if framerate <= 0 {
+		return nil, ErrBadParameter.Withf("framerate %v", framerate)
+	} else {
+		par.videopar.Framerate = ff.AVUtil_rational_d2q(1/framerate, 0)
+	}
+
+	// Return success
+	return par, nil
+}
+
+// Create new parameters for video from a frame size, pixel format and framerate in fps
+func newVideoParameters(frame string, pixelfmt string, framerate float64) (*par, error) {
+	// Parse the frame size
+	w, h, err := ff.AVUtil_parse_video_size(frame)
+	if err != nil {
+		return nil, err
+	}
+	return newVideoParametersEx(w, h, pixelfmt, framerate)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (par *par) MarshalJSON() ([]byte, error) {
+	if par.t == AUDIO {
+		return json.Marshal(par.audiopar)
+	} else {
+		return json.Marshal(par.videopar)
+	}
+}
+
+func (par *par) String() string {
+	data, _ := json.MarshalIndent(par, "", "  ")
+	return string(data)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Return type
+func (par *par) Type() MediaType {
+	return par.t
+}
+
+// Return the channel layout
+func (par *par) ChannelLayout() string {
+	if name, err := ff.AVUtil_channel_layout_describe(&par.audiopar.Ch); err != nil {
+		return ""
+	} else {
+		return name
+	}
+}
+
+// Return the sample format
+func (par *par) SampleFormat() string {
+	return ff.AVUtil_get_sample_fmt_name(par.audiopar.SampleFormat)
+}
+
+// Return the sample rate (Hz)
+func (par *par) Samplerate() int {
+	return par.audiopar.Samplerate
+}
+
+// Return the sample format
+
+// Return the width of the video frame
+func (par *par) Width() int {
+	return par.videopar.Width
+}
+
+// Return the height of the video frame
+func (par *par) Height() int {
+	return par.videopar.Height
+}
+
+// Return the pixel format
+func (par *par) PixelFormat() string {
+	return ff.AVUtil_get_pix_fmt_name(par.videopar.PixelFormat)
+}
+
+// Return the frame rate (fps)
+func (par *par) Framerate() float64 {
+	if v := par.videopar.Framerate.Float(1); v == 0 {
+		return math.Inf(1)
+	} else {
+		return 1 / v
+	}
+}

parameters_test.go

@@ -0,0 +1,35 @@
+package media
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_parameters_001(t *testing.T) {
+	assert := assert.New(t)
+
+	for ch := 1; ch < 8; ch++ {
+		params, err := newAudioParameters(ch, "flt", 44100)
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+		assert.NotNil(params)
+		t.Log(params)
+	}
+
+}
+
+func Test_parameters_002(t *testing.T) {
+	assert := assert.New(t)
+
+	for ch := 1; ch < 8; ch++ {
+		params, err := newVideoParameters("100x100", "rgba", 25)
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+		assert.NotNil(params)
+		t.Log(params)
+	}
+
+}

sys/ffmpeg61/avutil_pixfmt.go

@@ -3,6 +3,7 @@ package ffmpeg
 import (
 	"encoding/json"
 	"fmt"
+	"unsafe"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -284,6 +285,14 @@ func AVUtil_get_pix_fmt_name(pixfmt AVPixelFormat) string {
 	return C.GoString(C.av_get_pix_fmt_name((C.enum_AVPixelFormat)(pixfmt)))
 }
 
+// Return the pixel format corresponding to name.
+// If no pixel format has been found, returns AV_PIX_FMT_NONE
+func AVUtil_get_pix_fmt(name string) AVPixelFormat {
+	cName := C.CString(name)
+	defer C.free(unsafe.Pointer(cName))
+	return AVPixelFormat(C.av_get_pix_fmt(cName))
+}
+
 func AVUtil_get_pix_fmt_desc(pixfmt AVPixelFormat) *AVPixFmtDescriptor {
 	return (*AVPixFmtDescriptor)(C.av_pix_fmt_desc_get(C.enum_AVPixelFormat(pixfmt)))
 }

sys/ffmpeg61/avutil_rational.go

@@ -56,3 +56,13 @@ func (r AVRational) IsZero() bool {
 func (r AVRational) Float(multiplier int64) float64 {
 	return float64(int64(r.num)*multiplier) / float64(r.den)
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// BINDINGS
+
+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)))
+}