codec

package
v0.0.0-...-b6c7913 Latest Latest
Warning

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

 Go to latest Published: May 31, 2025 License: MIT Imports: 9 Imported by: 0

README

Codec Package

The codec package provides codec detection and depacketization for various video formats in the Mirror platform. It supports H.264, HEVC/H.265, AV1, and JPEG-XS with automatic detection and efficient processing.

Overview

Key components:

  • Codec Detector: Automatic codec identification from packet data
  • Depacketizers: Format-specific packet handling
  • Frame Assembly: Codec-aware frame reconstruction

Supported Codecs

H.264/AVC
depacketizer := codec.NewH264Depacketizer()

// Process NAL units
nalUnit, err := depacketizer.Depacketize(packet)

// Access SPS/PPS
sps := depacketizer.GetSPS()
pps := depacketizer.GetPPS()
HEVC/H.265
depacketizer := codec.NewHEVCDepacketizer()

// Supports VPS/SPS/PPS
vps := depacketizer.GetVPS()

// Handle temporal layers
layer := depacketizer.GetTemporalID()
AV1
depacketizer := codec.NewAV1Depacketizer()

// OBU parsing
obu, err := depacketizer.ParseOBU(data)

// Sequence header access
seqHeader := depacketizer.GetSequenceHeader()
JPEG-XS
depacketizer := codec.NewJPEGXSDepacketizer()

// Low-latency image handling
image, err := depacketizer.AssembleImage(packets)

Codec Detection

Automatic codec identification:

detector := codec.NewDetector()

// Detect from packet
codecType := detector.Detect(packet)

switch codecType {
case codec.H264:
    // Use H.264 depacketizer
case codec.HEVC:
    // Use HEVC depacketizer
case codec.AV1:
    // Use AV1 depacketizer
}

Features

  • Automatic detection from packet headers
  • Efficient NAL/OBU parsing with zero-copy
  • Parameter set caching (SPS/PPS/VPS)
  • Error resilience for packet loss
  • Temporal layer support for scalable codecs

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func GetBitDepth 

func GetBitDepth(bitDepthCode uint8) int

GetBitDepth returns the actual bit depth from the encoded value

func GetChromaFormatString 

func GetChromaFormatString(chromaFormat uint8) string

GetChromaFormatString returns a string representation of the chroma format

func GetNALType 

func GetNALType(nalHeader byte) byte

GetNALType extracts the NAL unit type from a NAL header

func GetOBUTypeName 

func GetOBUTypeName(obuType uint8) string

GetOBUTypeName returns a human-readable name for an OBU type

func GetProfileName 

func GetProfileName(profile JPEGXSProfile) string

GetProfileName returns a human-readable name for a JPEG XS profile

func IsKeyFrame 

func IsKeyFrame(nalType byte) bool

IsKeyFrame checks if the NAL unit type indicates a key frame

func ValidateProfile 

func ValidateProfile(profile JPEGXSProfile) bool

ValidateProfile checks if a profile value is valid

Types

type AV1Depacketizer 

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

AV1Depacketizer handles depacketization of AV1 RTP streams Based on draft-ietf-payload-av1 (RTP Payload Format for AV1)

func (*AV1Depacketizer) Depacketize 

func (d *AV1Depacketizer) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet and returns complete OBUs

func (*AV1Depacketizer) Reset 

func (d *AV1Depacketizer) Reset()

Reset clears the depacketizer state

type AV1DepacketizerWithMemory 

type AV1DepacketizerWithMemory struct {
	AV1Depacketizer
	// contains filtered or unexported fields
}

AV1DepacketizerWithMemory extends AV1Depacketizer with memory management

func (*AV1DepacketizerWithMemory) Depacketize 

func (d *AV1DepacketizerWithMemory) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet with memory management

func (*AV1DepacketizerWithMemory) Reset 

func (d *AV1DepacketizerWithMemory) Reset()

Reset clears the depacketizer state and releases memory

type Depacketizer 

type Depacketizer interface {
	Depacketize(packet *rtp.Packet) ([][]byte, error)
	Reset()
}

Depacketizer is the interface for RTP depacketizers

func NewAV1Depacketizer 

func NewAV1Depacketizer() Depacketizer

NewAV1Depacketizer creates a new AV1 depacketizer

func NewAV1DepacketizerWithMemory 

func NewAV1DepacketizerWithMemory(streamID string, memController *memory.Controller, limit int64) Depacketizer

NewAV1DepacketizerWithMemory creates a memory-aware AV1 depacketizer

func NewH264Depacketizer 

func NewH264Depacketizer() Depacketizer

NewH264Depacketizer creates a new H264 depacketizer

func NewH264DepacketizerWithMemory 

func NewH264DepacketizerWithMemory(streamID string, memController *memory.Controller, limit int64) Depacketizer

NewH264DepacketizerWithMemory creates a memory-aware H264 depacketizer

func NewHEVCDepacketizer 

func NewHEVCDepacketizer() Depacketizer

NewHEVCDepacketizer creates a new HEVC depacketizer

func NewHEVCDepacketizerWithMemory 

func NewHEVCDepacketizerWithMemory(streamID string, memController *memory.Controller, limit int64) Depacketizer

NewHEVCDepacketizerWithMemory creates a memory-aware HEVC depacketizer

func NewJPEGXSDepacketizer 

func NewJPEGXSDepacketizer() Depacketizer

NewJPEGXSDepacketizer creates a new JPEG XS depacketizer

func NewJPEGXSDepacketizerWithMemory 

func NewJPEGXSDepacketizerWithMemory(streamID string, memController *memory.Controller, limit int64) Depacketizer

NewJPEGXSDepacketizerWithMemory creates a memory-aware JPEG-XS depacketizer

type DepacketizerFactory 

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

DepacketizerFactory creates depacketizers for different codecs

func NewDepacketizerFactory 

func NewDepacketizerFactory(memController *memory.Controller) *DepacketizerFactory

NewDepacketizerFactory creates a new depacketizer factory with default codecs

func (*DepacketizerFactory) Create 

func (f *DepacketizerFactory) Create(codecType Type, streamID string) (Depacketizer, error)

Create creates a new depacketizer for the given codec type and stream

func (*DepacketizerFactory) IsSupported 

func (f *DepacketizerFactory) IsSupported(codecType Type) bool

IsSupported checks if a codec type is supported

func (*DepacketizerFactory) Register 

func (f *DepacketizerFactory) Register(codecType Type, creator func(streamID string) Depacketizer)

Register adds a depacketizer creator for a codec type

func (*DepacketizerFactory) RegisterDefaults 

func (f *DepacketizerFactory) RegisterDefaults()

RegisterDefaults registers all built-in depacketizers

func (*DepacketizerFactory) SupportedCodecs 

func (f *DepacketizerFactory) SupportedCodecs() []Type

SupportedCodecs returns a list of supported codec types

func (*DepacketizerFactory) Unregister 

func (f *DepacketizerFactory) Unregister(codecType Type)

Unregister removes a codec type from the factory

type DepacketizerPool 

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

DepacketizerPool manages a pool of depacketizers for each codec type

func NewDepacketizerPool 

func NewDepacketizerPool(factory *DepacketizerFactory) *DepacketizerPool

NewDepacketizerPool creates a new depacketizer pool

func (*DepacketizerPool) Get 

func (p *DepacketizerPool) Get(codecType Type, streamID string) (Depacketizer, error)

Get retrieves a depacketizer from the pool or creates a new one

func (*DepacketizerPool) Put 

func (p *DepacketizerPool) Put(codecType Type, depacketizer Depacketizer)

Put returns a depacketizer to the pool

type Detector 

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

Detector detects video codec from various sources

func NewDetector 

func NewDetector() *Detector

NewDetector creates a new codec detector

func (*Detector) DetectFromRTPPacket 

func (d *Detector) DetectFromRTPPacket(packet *rtp.Packet) (Type, error)

DetectFromRTPPacket attempts to detect codec from RTP packet

func (*Detector) DetectFromSDP 

func (d *Detector) DetectFromSDP(sdp string) (Type, *Info, error)

DetectFromSDP parses SDP and extracts codec information

func (*Detector) DetectFromSRTMetadata 

func (d *Detector) DetectFromSRTMetadata(metadata map[string]string) (Type, *Info, error)

DetectFromSRTMetadata extracts codec info from SRT metadata

func (*Detector) Reset 

func (d *Detector) Reset()

Reset clears the detector state

type H264Depacketizer 

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

H264Depacketizer handles depacketization of H.264 (AVC) RTP streams Based on RFC 6184

func (*H264Depacketizer) Depacketize 

func (d *H264Depacketizer) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet and returns complete NAL units

func (*H264Depacketizer) Reset 

func (d *H264Depacketizer) Reset()

Reset clears the depacketizer state

type H264DepacketizerWithMemory 

type H264DepacketizerWithMemory struct {
	H264Depacketizer
	// contains filtered or unexported fields
}

H264DepacketizerWithMemory extends H264Depacketizer with memory management

func (*H264DepacketizerWithMemory) Depacketize 

func (d *H264DepacketizerWithMemory) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet with memory management

func (*H264DepacketizerWithMemory) Reset 

func (d *H264DepacketizerWithMemory) Reset()

Reset clears the depacketizer state and releases memory

type HEVCDepacketizer 

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

HEVCDepacketizer handles depacketization of HEVC (H.265) RTP streams Based on RFC 7798

func (*HEVCDepacketizer) Depacketize 

func (d *HEVCDepacketizer) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet and returns complete NAL units

func (*HEVCDepacketizer) Reset 

func (d *HEVCDepacketizer) Reset()

Reset clears the depacketizer state

type HEVCDepacketizerWithMemory 

type HEVCDepacketizerWithMemory struct {
	HEVCDepacketizer
	// contains filtered or unexported fields
}

HEVCDepacketizerWithMemory extends HEVCDepacketizer with memory management

func (*HEVCDepacketizerWithMemory) Depacketize 

func (d *HEVCDepacketizerWithMemory) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet with memory management

func (*HEVCDepacketizerWithMemory) Reset 

func (d *HEVCDepacketizerWithMemory) Reset()

Reset clears the depacketizer state and releases memory

type Info 

type Info struct {
	Type       Type
	Profile    string
	Level      string
	Width      int
	Height     int
	FrameRate  float64
	BitDepth   int
	ChromaFmt  string // e.g., "4:2:0", "4:2:2"
	Parameters map[string]string
}

Info contains codec-specific information

func (*Info) Validate 

func (i *Info) Validate() error

Validate checks if the codec info is valid

type JPEGXSDepacketizer 

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

JPEGXSDepacketizer handles depacketization of JPEG XS RTP streams Based on RFC 9134 (RTP Payload Format for JPEG XS)

func (*JPEGXSDepacketizer) Depacketize 

func (d *JPEGXSDepacketizer) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet and returns complete JPEG XS frames

func (*JPEGXSDepacketizer) GetProfile 

func (d *JPEGXSDepacketizer) GetProfile() JPEGXSProfile

GetProfile returns the current JPEG XS profile

func (*JPEGXSDepacketizer) Reset 

func (d *JPEGXSDepacketizer) Reset()

Reset clears the depacketizer state

func (*JPEGXSDepacketizer) SetProfile 

func (d *JPEGXSDepacketizer) SetProfile(profile JPEGXSProfile)

SetProfile sets the expected JPEG XS profile

type JPEGXSDepacketizerWithMemory 

type JPEGXSDepacketizerWithMemory struct {
	JPEGXSDepacketizer
	// contains filtered or unexported fields
}

JPEGXSDepacketizerWithMemory extends JPEGXSDepacketizer with memory management

func (*JPEGXSDepacketizerWithMemory) Depacketize 

func (d *JPEGXSDepacketizerWithMemory) Depacketize(packet *rtp.Packet) ([][]byte, error)

Depacketize processes an RTP packet with memory management

func (*JPEGXSDepacketizerWithMemory) Reset 

func (d *JPEGXSDepacketizerWithMemory) Reset()

Reset clears the depacketizer state and releases memory

type JPEGXSProfile 

type JPEGXSProfile uint8

JPEGXSProfile represents JPEG XS profiles 

const (
	// JPEG XS Profile values from RFC 9134
	ProfileLight        JPEGXSProfile = 0x1A // Light profile
	ProfileMain         JPEGXSProfile = 0x2A // Main profile
	ProfileHigh         JPEGXSProfile = 0x3A // High profile
	ProfileHigh444_12   JPEGXSProfile = 0x4A // High 4:4:4 12-bit profile
	ProfileLightSubline JPEGXSProfile = 0x1B // Light Subline profile
	ProfileMainSubline  JPEGXSProfile = 0x2B // Main Subline profile
)

type Type 

type Type string

Type represents a video codec type 

const (
	// TypeHEVC represents H.265/HEVC codec
	TypeHEVC Type = "HEVC"
	// TypeH264 represents H.264/AVC codec
	TypeH264 Type = "H264"
	// TypeAV1 represents AV1 codec
	TypeAV1 Type = "AV1"
	// TypeJPEGXS represents JPEG XS codec
	TypeJPEGXS Type = "JPEGXS"
	// TypeUnknown represents an unknown codec
	TypeUnknown Type = "UNKNOWN"
)

func ParseType 

func ParseType(s string) Type

ParseType parses a string into a codec type

func (Type) IsValid 

func (t Type) IsValid() bool

IsValid checks if the codec type is valid and supported

func (Type) String 

func (t Type) String() string

String returns the string representation of the codec type

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.