parser

type AtomBuilder func(t Track) ([]byte, error)

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

type DASHAtomParser func(d *DASHDemuxer, reader io.ReadSeeker, size int, t *Track)

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

type DASHManifest struct {
	XMLName  xml.Name `xml:"MPD"`
	Duration string   `xml:"mediaPresentationDuration,attr"`
	Period   DASHXMLPeriod
}

type DASHXMLAdaptionSet struct {
	XMLName         xml.Name `xml:"AdaptationSet"`
	Group           string   `xml:"group,attr"`
	MimeType        string   `xml:"mimeType,attr"`
	MinWidth        int      `xml:"minWidth,attr"`
	MaxWidth        int      `xml:"maxWidth,attr"`
	MinHeight       int      `xml:"minHeight,attr"`
	Maxheight       int      `xml:"maxHeight,attr"`
	Template        DASHXMLSegmentTemplate
	Representations []DASHXMLRepresentation `xml:"Representation"`
}

type DASHXMLInitialization struct {
	XMLName xml.Name `xml:"Initialization"`
	Range   string   `xml:"range,attr"`
}

type DASHXMLPeriod struct {
	XMLName        xml.Name             `xml:"Period"`
	BaseURL        string               `xml:"BaseURL"`
	AdaptationSets []DASHXMLAdaptionSet `xml:"AdaptationSet"`
}

type DASHXMLRepresentation struct {
	XMLName           xml.Name `xml:"Representation"`
	Id                string   `xml:"id,attr"`
	Bandwidth         string   `xml:"bandwidth,attr"`
	Codecs            string   `xml:"codecs,attr"`
	AudioSamplingRate string   `xml:"audioSamplingRate,attr"`
	Width             int      `xml:"width,attr"`
	Height            int      `xml:"height,attr"`
	Sar               int      `xml:"sar,attr"`
	Base              DASHXMLSegmentBase
	BaseURL           string `xml:"BaseURL">`
}

type DASHXMLSegment struct {
	XMLName    xml.Name `xml:"S"`
	Duration   int      `xml:"d,attr"`
	Time       int      `xml:"t,attr"`
	Repetition int      `xml:"r,attr"`
}

type DASHXMLSegmentBase struct {
	XMLName        xml.Name                `xml:"SegmentBase"`
	Timescale      int                     `xml:"timescale,attr"`
	Range          string                  `xml:"indexRange,attr"`
	Initialization []DASHXMLInitialization `xml:"Initialization"`
}

type DASHXMLSegmentTemplate struct {
	XMLName        xml.Name         `xml:"SegmentTemplate"`
	Timescale      int              `xml:"timescale,attr"`
	Initialization string           `xml:"initialization,attr"`
	Media          string           `xml:"media,attr"`
	StartNumber    int              `xml:"startNumber,attr"`
	Segments       []DASHXMLSegment `xml:"SegmentTimeline>S"`
}

type Demuxer interface {
	Open(path string) error
	GetTracks(tracks *[]*Track) error
	Close()
	ExtractChunk(tracks *[]*Track, isLive bool) bool
}

type DemuxerConstructor func() Demuxer

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

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

type HTTPRequest struct {
	Url     string
	Headers []struct {
		// contains filtered or unexported fields
	}
}

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

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

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

type SmoothAtomParser func(d *SmoothDemuxer, reader io.ReadSeeker, size int, t *Track)

type SmoothChunk struct {
	XMLName   xml.Name `xml:"c"`
	Duration  int64    `xml:"d,attr"`
	StartTime int64    `xml:"t,attr"`
}

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

type SmoothProtectionHeader struct {
	XMLName  xml.Name `xml:"ProtectionHeader"`
	SystemId string   `xml:"SystemID,attr"`
	Blob     string   `xml:",chardata"`
}

type SmoothQualityLevel struct {
	XMLName          xml.Name `xml:"QualityLevel"`
	Index            int      `xml:"Index,attr"`
	Bitrate          int      `xml:"Bitrate,attr"`
	MaxWidth         int      `xml:"MaxWidth,attr"`
	MaxHeight        int      `xml:"MaxHeight,attr"`
	FourCC           string   `xml:"FourCC,attr"`
	CodecPrivateData string   `xml:"CodecPrivateData,attr"`
	AudioTag         int      `xml:"AudioTag,attr"`
	SamplingRate     int      `xml:"SamplingRate,attr"`
	BitsPerSample    int      `xml:"BitsPerSample,attr"`
	PacketSize       int      `xml:"PacketSize,attr"`
	Channels         int      `xml:"Channels,attr"`
}

type SmoothStreamIndex struct {
	XMLName       xml.Name             `xml:"StreamIndex"`
	Type          string               `xml:"Type,attr"`
	Url           string               `xml:"Url,attr"`
	Name          string               `xml:"Name,attr"`
	Chunks        int                  `xml:"Chunks,attr"`
	QualityLevels int                  `xml:"QualityLevels,attr"`
	MaxWidth      int                  `xml:"MaxWidth,attr"`
	MaxHeight     int                  `xml:"MaxHeight,attr"`
	DisplayWidth  int                  `xml:"DisplayWidth,attr"`
	DisplayHeight int                  `xml:"DisplayHeight,attr"`
	QualityInfos  []SmoothQualityLevel `xml:"QualityLevel"`
	ChunksInfos   []SmoothChunk        `xml:"c"`
}

type SmoothStreamingMedia struct {
	XMLName        xml.Name                 `xml:"SmoothStreamingMedia"`
	MajorVersion   int                      `xml:"MajorVersion,attr"`
	MinorVersion   int                      `xml:"MinorVersion,attr"`
	Timescale      int                      `xml:"TimeScale,attr"`
	Duration       int                      `xml:"Duration,attr"`
	IsLive         bool                     `xml:"IsLive,attr"`
	LookaheadCount int                      `xml:"LookaheadCount,attr"`
	StreamIndexes  []SmoothStreamIndex      `xml:"StreamIndex"`
	Protection     []SmoothProtectionHeader `xml:"Protection>ProtectionHeader"`
}

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

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

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