schema

package
v1.9.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 29, 2026 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	OptionBitrate = "bitrate"

	// Audio options
	OptionProfile       = "profile"
	OptionSampleRate    = "sample_rate"
	OptionSampleFormat  = "sample_format"
	OptionChannelLayout = "channel_layout"

	// Video options
	OptionWidth       = "width"
	OptionHeight      = "height"
	OptionPixelFormat = "pixel_format"
	OptionFrameRate   = "frame_rate"
)
View Source 
const (
	DefaultSchema = "gomedia"
)

Variables

View Source 
var Objects string
View Source 
var Queries string

Functions

This section is empty.

Types

type Artwork 

type Artwork struct {
	Type   string `json:"type,omitempty" help:"Artwork mimetype, e.g. \"image/jpeg\"." example:"image/jpeg"`
	Width  int    `json:"width,omitempty" help:"Artwork width, in pixels." example:"600"`
	Height int    `json:"height,omitempty" help:"Artwork height, in pixels." example:"600"`
	Data   []byte `json:"data,omitempty" help:"Raw artwork image data."`
}

Artwork is a JSON-friendly view of a gomedia.Metadata entry holding embedded artwork (cover art, thumbnail, ...) - the binary payload Metadata omits, decoded far enough to report its mimetype and pixel dimensions.

func NewArtwork 

func NewArtwork(entry gomedia.Metadata) *Artwork

NewArtwork converts a gomedia.Metadata entry holding artwork (see gomedia.MetaArtwork) into the JSON-friendly Artwork shape. Value() is used for Type since, per gomedia.Metadata's contract, it returns the mimetype when the underlying value is a byte slice. Width/Height are read from Image(), which is nil (leaving both zero) if the data can't be decoded as an image.

func NewArtworkList 

func NewArtworkList(entries []gomedia.Metadata) []Artwork

NewArtworkList converts gomedia.Metadata entries holding artwork (see gomedia.MetaArtwork) to the JSON-friendly Artwork shape, one per entry - e.g. an audio file with multiple attached-pic streams (cover, cover-2, ...).

type AudioProfile 

type AudioProfile struct {
	Id uuid.UUID `json:"id,omitempty"` // Unique identifier for the audio profile
	AudioProfileMeta
}

func NewAudioProfile 

func NewAudioProfile(codec string) (*AudioProfile, error)

func (AudioProfile) Codec 

func (r AudioProfile) Codec() *Codec

func (AudioProfile) Options 

func (r AudioProfile) Options() json.RawMessage

func (AudioProfile) Par 

func (r AudioProfile) Par() *ff.AVCodecParameters

func (*AudioProfile) Scan 

func (r *AudioProfile) Scan(row pg.Row) error

Expected column order: id, codec, bitrate, profile, sample_rate, sample_format, channel_layout, opts.

func (AudioProfile) String 

func (r AudioProfile) String() string

func (AudioProfile) TimeBase 

func (r AudioProfile) TimeBase() *ff.AVRational

func (AudioProfile) Type 

func (r AudioProfile) Type() CodecType

func (AudioProfile) UUID 

func (r AudioProfile) UUID() uuid.UUID

type AudioProfileMeta 

type AudioProfileMeta struct {
	Name string `json:"codec"  arg:"" required:""` // "aac", "libmp3lame", "copy", ...
	ProfileMetaAudio
	Opts json.RawMessage `json:"options,omitempty"` // Additional codec options
	// contains filtered or unexported fields
}

func (AudioProfileMeta) Insert 

func (r AudioProfileMeta) Insert(bind *pg.Bind) (string, error)

Insert binds values and returns the insert query for an audio profile row.

func (*AudioProfileMeta) Set 

func (r *AudioProfileMeta) Set(name string, value any) error

Set an audio profile option. If value is nil, the option is removed. TODO: If an error is returned, the option is not set and the profile is unchanged.

func (AudioProfileMeta) Update 

func (r AudioProfileMeta) Update(bind *pg.Bind) error

Update binds patch values for an audio profile row update.

type AudioProfileUUID 

type AudioProfileUUID uuid.UUID

func (AudioProfileUUID) Select 

func (r AudioProfileUUID) Select(bind *pg.Bind, op pg.Op) (string, error)

type ChannelLayout 

type ChannelLayout struct {
	Name        string `json:"name" help:"Channel layout name." example:"5.1"`
	NumChannels int    `json:"num_channels" help:"Number of channels." example:"6"`
	// contains filtered or unexported fields
}

func NewChannelLayout 

func NewChannelLayout(ch *ff.AVChannelLayout) *ChannelLayout

func (ChannelLayout) Cell 

func (r ChannelLayout) Cell(col int) string

func (ChannelLayout) Context 

func (r ChannelLayout) Context() *ff.AVChannelLayout

Context returns the underlying FFmpeg channel layout constant.

func (ChannelLayout) Header 

func (ChannelLayout) Header() []string

func (ChannelLayout) String 

func (r ChannelLayout) String() string

func (ChannelLayout) Width 

func (ChannelLayout) Width(col int) int

type ChannelLayoutList 

type ChannelLayoutList []ChannelLayout

func (ChannelLayoutList) String 

func (r ChannelLayoutList) String() string

type ChannelLayoutListRequest 

type ChannelLayoutListRequest struct {
	Name        *string `json:"name,omitempty" help:"Filter by channel layout name." placeholder:"5.1" example:"5.1"`
	NumChannels *uint64 `json:"num_channels,omitempty" help:"Filter by number of channels." placeholder:"6" example:"6"`
}

func (ChannelLayoutListRequest) Query 

func (r ChannelLayoutListRequest) Query() url.Values

type Chapter 

type Chapter struct {
	Start    Duration   `json:"start" help:"Chapter start time, as a duration string (e.g. \"1h2m3.5s\")." example:"1m30s"`
	End      Duration   `json:"end,omitempty" help:"Chapter end time, as a duration string." example:"3m45s"`
	Metadata []Metadata `json:"metadata,omitempty" help:"Chapter tags, e.g. \"title\"."`
}

Chapter is a JSON-friendly view of a gomedia.Chapter - a single chapter marker's position in the container plus its own metadata tags (usually just "title").

func NewChapter 

func NewChapter(chapter gomedia.Chapter) Chapter

NewChapter converts a gomedia.Chapter into the JSON-friendly Chapter shape. Tags are sorted by key for deterministic output, since a gomedia.Chapter's Metadata is a map and iteration order isn't stable.

func NewChapterList 

func NewChapterList(entries []gomedia.Metadata) []Chapter

NewChapterList converts gomedia.Metadata entries holding chapter markers (see gomedia.MetaChapter) to the JSON-friendly Chapter shape, one per entry, in the same order the chapters appear in the container.

type Codec 

type Codec struct {
	CodecMeta
	IsEncoder  bool     `json:"is_encoder"`            // Whether this codec can encode
	IsDecoder  bool     `json:"is_decoder"`            // Whether this codec can decode
	IsHardware bool     `json:"is_hardware,omitempty"` // Whether this codec is hardware-accelerated
	Opts       []Option `json:"opts,omitempty"`        // Codec options
	// contains filtered or unexported fields
}

func NewCodec 

func NewCodec(codec *ff.AVCodec) *Codec

func (Codec) Context 

func (r Codec) Context() *ff.AVCodec

func (Codec) String 

func (r Codec) String() string

type CodecGetRequest 

type CodecGetRequest struct {
	IsEncoder *bool `json:"is_encoder,omitempty"` // Prefer an encoder (true) or decoder (false); tries an encoder then a decoder if omitted
}

func (CodecGetRequest) Query 

func (r CodecGetRequest) Query() url.Values

type CodecList 

type CodecList struct {
	CodecListRequest
	Count uint64   `json:"count"`          // Number of codecs
	Body  []*Codec `json:"body,omitempty"` // List of codecs
}

func (CodecList) String 

func (r CodecList) String() string

type CodecListRequest 

type CodecListRequest struct {
	Type       *CodecType `json:"type,omitempty" enum:"audio,video,subtitle"` // Codec type to filter codecs by; "audio", "video", "subtitle"
	IsEncoder  *bool      `json:"is_encoder,omitempty"`                       // Filter by encoder capability; both encoders and decoders are returned if omitted
	IsDecoder  *bool      `json:"is_decoder,omitempty"`                       // Filter by decoder capability; both encoders and decoders are returned if omitted
	IsHardware *bool      `json:"is_hardware,omitempty"`                      // Filter by hardware acceleration; both hardware and software codecs are returned if omitted
	pg.OffsetLimit
}

func (CodecListRequest) Query 

func (r CodecListRequest) Query() url.Values

type CodecMeta 

type CodecMeta struct {
	Name        string    `json:"name"`                  // Codec name, e.g. "aac", "libmp3lame", "copy", ...
	Description string    `json:"description,omitempty"` // Codec description
	Type        CodecType `json:"type"`                  // Codec type; "audio", "video", "subtitle"
}

CodecMeta identifies a codec - its name, human-readable description, and media type - independent of its encode/decode capability or options.

type CodecType 

type CodecType ff.AVMediaType

func (CodecType) MarshalJSON 

func (r CodecType) MarshalJSON() ([]byte, error)

func (CodecType) String 

func (r CodecType) String() string

func (*CodecType) UnmarshalJSON 

func (r *CodecType) UnmarshalJSON(data []byte) error

func (*CodecType) UnmarshalText 

func (r *CodecType) UnmarshalText(data []byte) error

type Device 

type Device struct {
	Format      string   `json:"format" help:"Device format (driver) name." example:"avfoundation"`
	Index       int      `json:"index" help:"Device index within its format." example:"0"`
	Name        string   `json:"name" help:"Device name." example:"Built-in Microphone"`
	Description string   `json:"description,omitempty" help:"Device description." example:"Built-in Microphone"`
	IsDefault   bool     `json:"is_default,omitempty" help:"Whether this is the default device for its format." example:"true"`
	IsInput     bool     `json:"is_input" help:"Whether this device can be used as an input." example:"true"`
	IsOutput    bool     `json:"is_output" help:"Whether this device can be used as an output." example:"false"`
	MediaTypes  []string `json:"media_types,omitempty" help:"Media types supported by this device." example:"[\"audio\"]"`
}

func NewDevice 

func NewDevice(format string, isInput, isOutput bool, info *ff.AVDeviceInfo, index int, isDefault bool) *Device

func (Device) Cell 

func (r Device) Cell(col int) string

func (Device) Header 

func (Device) Header() []string

func (Device) Kind 

func (r Device) Kind() string

func (Device) Media 

func (r Device) Media() string

func (Device) String 

func (r Device) String() string

func (Device) Width 

func (Device) Width(col int) int

type DeviceList 

type DeviceList []Device

func (DeviceList) String 

func (r DeviceList) String() string

type DeviceListRequest 

type DeviceListRequest struct {
	Name     *string `json:"name,omitempty" help:"Filter by device name." placeholder:"Built-in Microphone" example:"Built-in Microphone"`
	Format   *string `json:"format,omitempty" help:"Filter by device format name." placeholder:"avfoundation" example:"avfoundation"`
	IsInput  *bool   `json:"is_input,omitempty" help:"Filter by input capability." example:"true"`
	IsOutput *bool   `json:"is_output,omitempty" help:"Filter by output capability." example:"false"`
}

func (DeviceListRequest) Query 

func (r DeviceListRequest) Query() url.Values

type Duration 

type Duration time.Duration

Duration is a time.Duration that marshals to/from its String() form (e.g. "1h2m3s") in JSON, rather than time.Duration's default of a raw count of nanoseconds.

func (Duration) MarshalJSON 

func (d Duration) MarshalJSON() ([]byte, error)

func (Duration) String 

func (d Duration) String() string

func (*Duration) UnmarshalJSON 

func (d *Duration) UnmarshalJSON(data []byte) error

type Format 

type Format struct {
	FormatMeta
	IsInput  bool     `json:"is_input,omitempty" help:"Whether this format can be used as an input (demuxer)." example:"true"`
	IsOutput bool     `json:"is_output,omitempty" help:"Whether this format can be used as an output (muxer)." example:"false"`
	Opts     []Option `json:"opts,omitempty" help:"Format-specific options."`
	Audio    []string `json:"audio,omitempty" help:"Audio codecs supported by this format; the first is the default." example:"[\"aac\"]"`
	Video    []string `json:"video,omitempty" help:"Video codecs supported by this format; the first is the default." example:"[\"h264\"]"`
	Subtitle []string `json:"subtitle,omitempty" help:"Subtitle codecs supported by this format; the first is the default." example:"[\"mov_text\"]"`
}

Format is an output (muxer) format - or an input (demuxer) format, sharing the same shape with Audio/Video/Subtitle left empty, so both can appear together in a FormatList.

func NewInputFormat 

func NewInputFormat(format *ff.AVInputFormat) *Format

NewInputFormat builds a Format from an input (demuxer) format. Unlike NewOutputFormat, there's no meaningful Audio/Video/Subtitle codec list to populate - "default codec to encode with" is an output-format concept a demuxer doesn't have - so those fields are left empty.

func NewOutputFormat 

func NewOutputFormat(format *ff.AVOutputFormat) *Format

func (Format) String 

func (r Format) String() string

type FormatList 

type FormatList struct {
	FormatListRequest
	Count uint64    `json:"count" help:"Number of formats." example:"1"`
	Body  []*Format `json:"body,omitempty" help:"List of formats."`
}

func (FormatList) String 

func (r FormatList) String() string

type FormatListRequest 

type FormatListRequest struct {
	Name     *string `json:"name,omitempty" help:"Filter by format name." placeholder:"mp4" example:"mp4"`
	Type     *string `json:"type,omitempty" help:"Filter by MIME content type." placeholder:"video/mp4" example:"video/mp4"`
	Ext      *string `json:"ext,omitempty" help:"Filter by file extension." placeholder:"mp4" example:"mp4"`
	IsInput  *bool   `json:"is_input,omitempty" help:"Filter by input capability." example:"true"`
	IsOutput *bool   `json:"is_output,omitempty" help:"Filter by output capability." example:"false"`
	pg.OffsetLimit
}

func (FormatListRequest) Query 

func (r FormatListRequest) Query() url.Values

type FormatMeta 

type FormatMeta struct {
	Name        string `json:"name" help:"Format name." example:"mp4"`
	Description string `json:"description,omitempty" help:"Human-readable format description." example:"MP4 (MPEG-4 Part 14)"`
	Type        string `json:"type,omitempty" help:"MIME content type." example:"video/mp4"`
	Ext         string `json:"ext,omitempty" help:"File extensions associated with this format." example:"mp4,m4a,m4v"`
}

FormatMeta identifies a format - its name, human-readable description, MIME type, and file extensions - independent of whether it's usable as an input, an output, or what codecs it supports. This is the subset of Format fit to embed in output that isn't specifically about container format capabilities, e.g. ProbeResponse.

type Metadata 

type Metadata struct {
	Key   string `json:"key" help:"Metadata tag name, e.g. \"title\", \"artist\", \"language\"." example:"title"`
	Value string `json:"value,omitempty" help:"Metadata tag value." example:"Sample Track"`
	Any   any    `json:"any,omitempty" help:"Metadata tag value, as a JSON-friendly type (string, number, bool, array, or object)."`
}

Metadata is a JSON-friendly key/value view of a gomedia.Metadata entry - binary payloads (e.g. artwork) aren't represented here.

func NewMetadata 

func NewMetadata(key string, value any) Metadata

NewMetadata builds a Metadata entry from a key and an arbitrary value. Value is always a display-friendly string - the value itself, if it's already a string, or its fmt.Sprint representation otherwise. Any additionally carries the original value when it wasn't already a plain string, so JSON-friendly types (numbers, bools, slices, objects) survive round-tripping instead of being flattened to their string form.

func NewMetadataList 

func NewMetadataList(entries []gomedia.Metadata) []Metadata

NewMetadataList converts gomedia.Metadata entries (an interface - which encoding/json can marshal but never unmarshal, having no concrete type to instantiate) to the JSON-friendly, round-trippable Metadata shape. Used both for StreamProfile's per-stream metadata and for container-level metadata elsewhere (e.g. task.ProbeResponse).

func (Metadata) MarshalJSON 

func (m Metadata) MarshalJSON() ([]byte, error)

MarshalJSON omits Any from the output when it's redundant with Value - e.g. a metadata handler whose stored value is already a plain string, so Any() and Value() return the exact same thing. Any exists to carry richer JSON-friendly types (numbers, bools, slices, objects) beyond what the display string can hold; showing both when Any adds nothing over Value is just noise.

type Option 

type Option struct {
	Name        string        `json:"name,omitempty" help:"Option name." example:"b"`
	Description string        `json:"description,omitempty" help:"Human-readable option description." example:"Set bitrate in bits/s."`
	Type        string        `` /* 234-byte string literal not displayed */
	Default     any           `json:"default,omitempty" help:"Default value." example:"128000"`
	Const       []OptionConst `json:"const,omitempty" help:"Fixed set of allowed values, if this option only accepts specific values."`
	Min         any           `json:"min,omitempty" help:"Minimum allowed value, if applicable." example:"0"`
	Max         any           `json:"max,omitempty" help:"Maximum allowed value, if applicable." example:"192000"`
	Unit        string        `json:"unit,omitempty" help:"Unit the value is expressed in, if applicable." example:"bps"`
}

func AudioOptionsForCodec 

func AudioOptionsForCodec(codec *ff.AVCodec) []Option

func NewOption 

func NewOption(ctx *ff.AVOption) Option

func OptionsForCodec 

func OptionsForCodec(codec *ff.AVCodec) []Option

func OptionsForFormat 

func OptionsForFormat(format *ff.AVOutputFormat) []Option

func OptionsForInputFormat 

func OptionsForInputFormat(format *ff.AVInputFormat) []Option

func SubtitleOptionsForCodec 

func SubtitleOptionsForCodec(_ *ff.AVCodec) []Option

func VideoOptionsForCodec 

func VideoOptionsForCodec(codec *ff.AVCodec) []Option

func (Option) String 

func (o Option) String() string

func (Option) Validate 

func (o Option) Validate(value any) (any, error)

type OptionConst 

type OptionConst struct {
	Name        string `json:"name,omitempty" help:"Symbolic name for this value, if any." example:"fast"`
	Description string `json:"description,omitempty" help:"Human-readable description of this value."`
	Type        string `` /* 227-byte string literal not displayed */
	Default     any    `json:"default,omitempty" help:"The underlying value." example:"1"`
	Min         any    `json:"min,omitempty" help:"Minimum allowed value, if applicable."`
	Max         any    `json:"max,omitempty" help:"Maximum allowed value, if applicable."`
	Unit        string `json:"unit,omitempty" help:"Unit the value is expressed in, if applicable."`
}

OptionConst describes one of an Option's fixed set of allowed values (an AV_OPT_TYPE_CONST entry, or a hand-built constant like a supported sample rate, pixel format or codec profile). It's a separate, non-recursive type from Option - rather than reusing Option itself - because a const entry is always terminal: it never has its own set of constants. Option.Const being []Option would make Option a self-referential type, which the JSONSchema generator can't represent.

func NewOptionConst 

func NewOptionConst(ctx *ff.AVOption) OptionConst

NewOptionConst builds a terminal OptionConst (e.g. an AV_OPT_TYPE_CONST entry) from an FFmpeg option. Use this instead of NewOption when building an Option's Const list.

type Output 

type Output struct {
	Id     uuid.UUID `json:"id,omitempty"` // Unique identifier for the format profile
	Format string    `json:"format"`       // Format name, e.g. "mp4", "mkv", "flv", ...
	OutputMeta
}

func OutputWithName 

func OutputWithName(format string, opt ...Option) *Output

func OutputWithType 

func OutputWithType(contenttype string, opt ...Option) *Output

func OutputWithURL 

func OutputWithURL(url *url.URL, opt ...Option) *Output

type OutputMeta 

type OutputMeta struct {
	Description string          `json:"description,omitempty"` // Format description
	Opts        json.RawMessage `json:"options,omitempty"`     // Additional format options
	// contains filtered or unexported fields
}

func (*OutputMeta) Context 

func (o *OutputMeta) Context() *ff.AVOutputFormat

type OutputUUID 

type OutputUUID uuid.UUID

type PixelFormat 

type PixelFormat struct {
	Name        string `json:"name" help:"Pixel format name." example:"yuv420p"`
	NumPlanes   int    `json:"num_planes" help:"Number of image planes." example:"3"`
	BitDepth    int    `json:"bit_depth" help:"Bits per pixel." example:"12"`
	IsPlanar    bool   `json:"is_planar" help:"Whether planes are stored separately rather than interleaved." example:"true"`
	IsRGB       bool   `json:"is_rgb" help:"Whether the format is RGB, rather than YUV." example:"false"`
	HasAlpha    bool   `json:"has_alpha" help:"Whether the format includes an alpha channel." example:"false"`
	IsHWAccel   bool   `json:"is_hwaccel" help:"Whether this is a hardware-acceleration surface with no accessible pixel data." example:"false"`
	IsFloat     bool   `json:"is_float" help:"Whether samples are floating point, rather than integer." example:"false"`
	IsBigEndian bool   `json:"is_bigendian" help:"Whether multi-byte samples are stored big-endian." example:"false"`
	// contains filtered or unexported fields
}

func NewPixelFormat 

func NewPixelFormat(pixfmt ff.AVPixelFormat) *PixelFormat

func (PixelFormat) Cell 

func (r PixelFormat) Cell(col int) string

func (PixelFormat) Context 

func (r PixelFormat) Context() ff.AVPixelFormat

Context returns the underlying FFmpeg pixel format constant.

func (PixelFormat) Flags 

func (r PixelFormat) Flags() string

func (PixelFormat) Header 

func (PixelFormat) Header() []string

func (PixelFormat) String 

func (r PixelFormat) String() string

func (PixelFormat) Width 

func (PixelFormat) Width(col int) int

type PixelFormatList 

type PixelFormatList []PixelFormat

func (PixelFormatList) String 

func (r PixelFormatList) String() string

type PixelFormatListRequest 

type PixelFormatListRequest struct {
	Name      *string `json:"name,omitempty" help:"Filter by pixel format name." placeholder:"yuv420p" example:"yuv420p"`
	NumPlanes *uint64 `json:"num_planes,omitempty" help:"Filter by number of planes." placeholder:"3" example:"3"`
}

func (PixelFormatListRequest) Query 

func (r PixelFormatListRequest) Query() url.Values

type Profile 

type Profile interface {
	UUID() uuid.UUID            // Unique identifier for this profile
	Type() CodecType            // Type for this profile
	Codec() *Codec              // Codec for this profile
	Par() *ff.AVCodecParameters // Codec parameters for this profile
	TimeBase() *ff.AVRational   // Time base for this profile
	Options() json.RawMessage   // Additional codec-specific options
}

type ProfileMeta 

type ProfileMeta struct {
	UUID    uuid.UUID       `json:"id,omitzero"`
	Type    CodecType       `json:"type"`
	Codec   *CodecMeta      `json:"codec,omitempty"`
	Options json.RawMessage `json:"options,omitempty"`

	*ProfileMetaAudio
	*ProfileMetaVideo
	*ProfileMetaStream
}

ProfileMeta is a JSON representation of a Profile, uniform across AudioProfile, VideoProfile, SubtitleProfile, and StreamProfile. Audio/Video carry their type-specific fields; Subtitle has none beyond Options, which is already common to every profile type. A StreamProfile additionally carries Stream, describing the demuxed stream itself rather than its codec configuration.

func NewProfileMeta 

func NewProfileMeta(p Profile) *ProfileMeta

NewProfileMeta builds a JSON representation of any Profile implementation.

type ProfileMetaAudio 

type ProfileMetaAudio struct {
	Bitrate       *uint64 `json:"bitrate,omitempty"`        // bps
	Profile       *string `json:"profile,omitempty"`        // Codec profile; "LC", "HE-AAC", ...
	SampleRate    *uint64 `json:"sample_rate,omitempty"`    // Hz
	SampleFormat  *string `json:"sample_format,omitempty"`  // Audio sample format; "fltp", "s16"
	ChannelLayout *string `json:"channel_layout,omitempty"` // Audio channel layout; "mono", "stereo"
}

ProfileMetaAudio holds the audio-specific fields of a ProfileMeta - the canonical definition of "audio encoding parameters", embedded both here (for StreamProfile, whose values are derived from demuxed codec parameters) and in AudioProfileMeta (whose values are user-configured), so the two can't drift out of sync with each other.

type ProfileMetaStream 

type ProfileMetaStream struct {
	Index       int              `json:"index"`
	Disposition ff.AVDisposition `json:"disposition,omitempty"`
	TimeBase    *ff.AVRational   `json:"timebase,omitempty"`
	Metadata    []Metadata       `json:"metadata,omitempty"`
}

ProfileMetaStream holds the fields specific to a stream already discovered in a media file - as opposed to a codec configuration to encode with - so it's only populated for a StreamProfile.

type ProfileMetaVideo 

type ProfileMetaVideo struct {
	Bitrate     *uint64  `json:"bitrate,omitempty"`      // bps
	Profile     *string  `json:"profile,omitempty"`      // Codec profile; "high", "main", "baseline"
	Width       *uint64  `json:"width,omitempty"`        // Frame width in pixels
	Height      *uint64  `json:"height,omitempty"`       // Frame height in pixels
	PixelFormat *string  `json:"pixel_format,omitempty"` // Video pixel format; "yuv420p", "nv12"
	FrameRate   *float64 `json:"frame_rate,omitempty"`   // Frames per second
}

ProfileMetaVideo holds the video-specific fields of a ProfileMeta - see ProfileMetaAudio's doc comment; VideoProfileMeta embeds this the same way.

type SampleFormat 

type SampleFormat struct {
	Name      string `json:"name" help:"Sample format name." example:"fltp"`
	ByteDepth int    `json:"byte_depth" help:"Bytes per sample." example:"4"`
	IsPlanar  bool   `json:"is_planar" help:"Whether planes are stored separately rather than interleaved." example:"true"`
	// contains filtered or unexported fields
}

func NewSampleFormat 

func NewSampleFormat(samplefmt ff.AVSampleFormat) *SampleFormat

func (SampleFormat) Cell 

func (r SampleFormat) Cell(col int) string

func (SampleFormat) Context 

func (r SampleFormat) Context() ff.AVSampleFormat

Context returns the underlying FFmpeg sample format constant.

func (SampleFormat) Header 

func (SampleFormat) Header() []string

func (SampleFormat) String 

func (r SampleFormat) String() string

func (SampleFormat) Width 

func (SampleFormat) Width(col int) int

type SampleFormatList 

type SampleFormatList []SampleFormat

func (SampleFormatList) String 

func (r SampleFormatList) String() string

type SampleFormatListRequest 

type SampleFormatListRequest struct {
	Name     *string `json:"name"`
	IsPlanar *bool   `json:"is_planar,omitempty"`
}

func (SampleFormatListRequest) Query 

func (r SampleFormatListRequest) Query() url.Values

type StreamProfile 

type StreamProfile struct {
	// contains filtered or unexported fields
}

StreamProfile describes a stream already discovered in an opened media file (via a Reader), rather than a codec configuration to encode with. Unlike AudioProfile/VideoProfile/SubtitleProfile, there is nothing here to validate or assemble: the underlying AVCodecParameters were already fully populated by the demuxer, so StreamProfile just wraps them.

A StreamProfile is valid only while the Reader it came from remains open: Par() aliases the AVCodecParameters extradata (SPS/PPS, OpusHead, ...) owned by the underlying AVFormatContext, and Codec() the AVCodec found for its codec ID. This is not a limitation in practice — the typical use (e.g. feeding writer.WithProfile for a remux) requires the source Reader to stay open anyway, since packets still need to be read from it.

func NewStreamProfile 

func NewStreamProfile(stream *ff.AVStream) (*StreamProfile, error)

NewStreamProfile describes an existing AVStream (typically obtained from an opened reader.Reader) as a Profile - audio, video, subtitle, data and attachment streams alike, so a caller remuxing a whole container doesn't silently drop any of them. Returns an error for attached-pic streams (cover art, already surfaced separately via Reader.Metadata's "artwork" key), since representing it as a stream too would duplicate that.

func (StreamProfile) Codec 

func (r StreamProfile) Codec() *Codec

Codec is nil if no decoder is registered for this codec in the current build. Par/TimeBase/Type remain valid either way.

func (StreamProfile) Disposition 

func (r StreamProfile) Disposition() ff.AVDisposition

Disposition returns the stream's disposition flags (default, forced, attached pic, ...).

func (StreamProfile) Index 

func (r StreamProfile) Index() int

Index returns the stream's index within its container, e.g. for Seek.

func (StreamProfile) MarshalJSON 

func (r StreamProfile) MarshalJSON() ([]byte, error)

MarshalJSON is required because every field of StreamProfile is unexported (see the type's doc comment) - without it, encoding/json has nothing to marshal and every stream serializes as "{}". ProfileMeta is built from the Profile interface, which StreamProfile fully implements.

func (StreamProfile) Metadata 

func (r StreamProfile) Metadata() []gomedia.Metadata

Metadata returns the stream's own tags — e.g. "language" (ISO 639-2, such as "eng"), "title", "handler_name" — as opposed to Reader.Metadata, which returns container-level tags. Unlike WithProfile's Options, this is read-only: there is no way to set per-stream metadata via a Profile.

func (StreamProfile) Options 

func (r StreamProfile) Options() json.RawMessage

Options is always nil: there is nothing to configure on a stream that's already been demuxed.

func (StreamProfile) Par 

func (r StreamProfile) Par() *ff.AVCodecParameters

func (StreamProfile) String 

func (r StreamProfile) String() string

func (StreamProfile) TimeBase 

func (r StreamProfile) TimeBase() *ff.AVRational

func (StreamProfile) Type 

func (r StreamProfile) Type() CodecType

Type is read directly from the stream's codec parameters, so it's always available even if no decoder is registered for the codec.

func (StreamProfile) UUID 

func (r StreamProfile) UUID() uuid.UUID

UUID is always the zero value: a StreamProfile describes a stream discovered in a file, not a persisted, identifiable configuration.

func (*StreamProfile) UnmarshalJSON 

func (r *StreamProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON is the counterpart to MarshalJSON - without it, a client decoding a StreamProfile from JSON would silently get a zero-value struct (every field is unexported, so encoding/json has nothing to write into) that then re-marshals as bogus data (e.g. a zero AVCodecParameters, whose zero-valued codec_type of 0 happens to collide with AVMEDIA_TYPE_VIDEO).

codec is resolved from CodecMeta's own name, which round-trips exactly (unlike a codec ID's generic name, which can differ from its default decoder's own registered name - e.g. ID "mp3"'s default decoder is "mp3float"; see AVCodecID.UnmarshalJSON). par is then rebuilt field by field from whichever of ProfileMetaAudio/ProfileMetaVideo is present, since ProfileMeta no longer carries a raw AVCodecParameters.

type SubtitleProfile 

type SubtitleProfile struct {
	Id uuid.UUID `json:"id,omitempty"` // Unique identifier for the subtitle profile
	SubtitleProfileMeta
}

func NewSubtitleProfile 

func NewSubtitleProfile(codec string) (*SubtitleProfile, error)

func (SubtitleProfile) Codec 

func (r SubtitleProfile) Codec() *Codec

func (SubtitleProfile) Options 

func (r SubtitleProfile) Options() json.RawMessage

func (SubtitleProfile) Par 

func (r SubtitleProfile) Par() *ff.AVCodecParameters

func (*SubtitleProfile) Scan 

func (r *SubtitleProfile) Scan(row pg.Row) error

Expected column order: id, codec, opts.

func (SubtitleProfile) String 

func (r SubtitleProfile) String() string

func (SubtitleProfile) TimeBase 

func (r SubtitleProfile) TimeBase() *ff.AVRational

TimeBase always returns nil: unlike audio (sample rate) or video (frame rate), subtitle codecs have no rate-like field to derive one from, so the muxer/stream default applies.

func (SubtitleProfile) Type 

func (r SubtitleProfile) Type() CodecType

func (SubtitleProfile) UUID 

func (r SubtitleProfile) UUID() uuid.UUID

type SubtitleProfileMeta 

type SubtitleProfileMeta struct {
	Name string          `json:"codec"  arg:"" required:""` // "srt", "ass", "webvtt", "mov_text", "copy", ...
	Opts json.RawMessage `json:"options,omitempty"`         // Additional codec options
	// contains filtered or unexported fields
}

SubtitleProfileMeta is deliberately minimal compared to Audio/VideoProfileMeta: subtitle codecs have no universal structural parameter analogous to audio's sample rate or video's width/height/frame rate — every sampled encoder (srt, ass, webvtt, mov_text, dvbsub, dvdsub) declares neither a static profile list nor any shared option. Codec-specific knobs (mov_text's "height", dvbsub's "min_bpp", dvdsub's "palette") flow through Opts like any other private codec option, the same as x264's crf/preset.

func (SubtitleProfileMeta) Insert 

func (r SubtitleProfileMeta) Insert(bind *pg.Bind) (string, error)

Insert binds values and returns the insert query for a subtitle profile row.

func (*SubtitleProfileMeta) Set 

func (r *SubtitleProfileMeta) Set(name string, value any) error

Set a subtitle profile option. Every subtitle option is codec-specific (there's no universal field like bitrate or width), so this only ever touches the generic Opts dict. If value is nil, the option is removed.

func (SubtitleProfileMeta) Update 

func (r SubtitleProfileMeta) Update(bind *pg.Bind) error

Update binds patch values for a subtitle profile row update.

type SubtitleProfileUUID 

type SubtitleProfileUUID uuid.UUID

func (SubtitleProfileUUID) Select 

func (r SubtitleProfileUUID) Select(bind *pg.Bind, op pg.Op) (string, error)

type VideoProfile 

type VideoProfile struct {
	Id uuid.UUID `json:"id,omitempty"` // Unique identifier for the video profile
	VideoProfileMeta
}

func NewVideoProfile 

func NewVideoProfile(codec string) (*VideoProfile, error)

func (VideoProfile) Codec 

func (r VideoProfile) Codec() *Codec

func (VideoProfile) Options 

func (r VideoProfile) Options() json.RawMessage

func (VideoProfile) Par 

func (r VideoProfile) Par() *ff.AVCodecParameters

func (*VideoProfile) Scan 

func (r *VideoProfile) Scan(row pg.Row) error

Expected column order: id, codec, bitrate, profile, width, height, pixel_format, frame_rate, opts.

func (VideoProfile) String 

func (r VideoProfile) String() string

func (VideoProfile) TimeBase 

func (r VideoProfile) TimeBase() *ff.AVRational

func (VideoProfile) Type 

func (r VideoProfile) Type() CodecType

func (VideoProfile) UUID 

func (r VideoProfile) UUID() uuid.UUID

type VideoProfileMeta 

type VideoProfileMeta struct {
	Name string `json:"codec"  arg:"" required:""` // "libx264", "libx265", "copy", ...
	ProfileMetaVideo
	Opts json.RawMessage `json:"options,omitempty"` // Additional codec options
	// contains filtered or unexported fields
}

func (VideoProfileMeta) Insert 

func (r VideoProfileMeta) Insert(bind *pg.Bind) (string, error)

Insert binds values and returns the insert query for a video profile row.

func (*VideoProfileMeta) Set 

func (r *VideoProfileMeta) Set(name string, value any) error

Set a video profile option. If value is nil, the option is removed. TODO: If an error is returned, the option is not set and the profile is unchanged.

func (VideoProfileMeta) Update 

func (r VideoProfileMeta) Update(bind *pg.Bind) error

Update binds patch values for a video profile row update.

type VideoProfileUUID 

type VideoProfileUUID uuid.UUID

func (VideoProfileUUID) Select 

func (r VideoProfileUUID) Select(bind *pg.Bind, op pg.Op) (string, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.