codec

type ADTS struct {
	ADTSFixedHeader
	ADTSVariableHeader
}

type ADTSFixedHeader struct {
	SyncWord               uint16 // 12 bits The bit string ‘1111 1111 1111’. See ISO/IEC 11172-3,subclause 2.4.2.3 (Table 8)
	ID                     byte   // 1 bit MPEG identifier, set to ‘1’. See ISO/IEC 11172-3,subclause 2.4.2.3 (Table 8)
	Layer                  byte   // 2 bits Indicates which layer is used. Set to ‘00’. See ISO/IEC 11172-3,subclause 2.4.2.3 (Table 8)
	ProtectionAbsent       byte   // 1 bit Indicates whether error_check() data is present or not. Same assyntax element ‘protection_bit’ in ISO/IEC 11172-3,subclause 2.4.1 and 2.4.2 (Table 8)
	Profile                byte   // 2 bits profile used. See clause 2 (Table 8)
	SamplingFrequencyIndex byte   // 4 bits indicates the sampling frequency used according to the followingtable (Table 8)
	PrivateBit             byte   // 1 bit see ISO/IEC 11172-3, subclause 2.4.2.3 (Table 8)
	ChannelConfiguration   byte   // 3 bits indicates the channel configuration used. Ifchannel_configuration is greater than 0, the channelconfiguration is given in Table 42, see subclause 8.5.3.1. Ifchannel_configuration equals 0, the channel configuration is notspecified in the header and must be given by aprogram_config_element() following as first syntactic element inthe first raw_data_block() after the header (seesubclause 8.5.3.2), or by the implicit configuration (seesubclause 8.5.3.3) or must be known in the application (Table 8)
	OriginalCopy           byte   // 1 bit see ISO/IEC 11172-3, definition of data element copyright
	Home                   byte   // 1 bit see ISO/IEC 11172-3, definition of data element original/copy
}

type ADTSVariableHeader struct {
	CopyrightIdentificationBit   byte   // 1 bit One bit of the 72-bit copyright identification field (seecopyright_id above). The bits of this field are transmitted frame by frame; the first bit is indicated by the copyright_identification_start bit set to ‘1’. The field consists of an 8-bit copyright_identifier, followed by a 64-bit copyright_number.The copyright identifier is given by a Registration Authority as designated by SC29. The copyright_number is a value which identifies uniquely the copyrighted material. See ISO/IEC 13818-3, subclause 2.5.2.13 (Table 9)
	CopyrightIdentificationStart byte   // 1 bit One bit to indicate that the copyright_identification_bit in this audio frame is the first bit of the 72-bit copyright identification. If no copyright identification is transmitted, this bit should be kept '0'.'0' no start of copyright identification in this audio frame '1' start of copyright identification in this audio frame See ISO/IEC 13818-3, subclause 2.5.2.13 (Table 9)
	AACFrameLength               uint16 // 13 bits Length of the frame including headers and error_check in bytes(Table 9)
	ADTSBufferFullness           uint16 // 11 bits state of the bit reservoir in the course of encoding the ADTS frame, up to and including the first raw_data_block() and the optionally following adts_raw_data_block_error_check(). It is transmitted as the number of available bits in the bit reservoir divided by NCC divided by 32 and truncated to an integer value (Table 9). A value of hexadecimal 7FF signals that the bitstream is a variable rate bitstream. In this case, buffer fullness is not applicable
	NumberOfRawDataBlockInFrame  byte   // 2 bits Number of raw_data_block()’s that are multiplexed in the adts_frame() is equal to number_of_raw_data_blocks_in_frame + 1. The minimum value is 0 indicating 1 raw_data_block()(Table 9)
}

type AV1CodecConfigurationRecord struct {
	Version                          byte
	SeqProfile                       byte
	SeqLevelIdx0                     byte
	SeqTier0                         byte
	HighBitdepth                     byte
	TwelveBit                        byte
	MonoChrome                       byte
	ChromaSubsamplingX               byte
	ChromaSubsamplingY               byte
	ChromaSamplePosition             byte
	InitialPresentationDelayPresent  byte
	InitialPresentationDelayMinusOne byte
	ConfigOBUs                       []byte
}

type AVCDecoderConfigurationRecord struct {
	ConfigurationVersion       byte // 8 bits Version
	AVCProfileIndication       byte // 8 bits
	ProfileCompatibility       byte // 8 bits
	AVCLevelIndication         byte // 8 bits
	Reserved1                  byte // 6 bits
	LengthSizeMinusOne         byte // 2 bits 非常重要,每个NALU包前面都(lengthSizeMinusOne & 3)+1个字节的NAL包长度描述
	Reserved2                  byte // 3 bits
	NumOfSequenceParameterSets byte // 5 bits SPS 的个数,计算方法是 numOfSequenceParameterSets & 0x1F
	NumOfPictureParameterSets  byte // 8 bits PPS 的个数

	SequenceParameterSetLength  uint16 // 16 byte SPS Length
	SequenceParameterSetNALUnit []byte // n byte  SPS
	PictureParameterSetLength   uint16 // 16 byte PPS Length
	PictureParameterSetNALUnit  []byte // n byte  PPS
}

type AdditionalMetadataContainerBox struct {
	MP4BoxHeader // standard header
}

type AudioCodecID byte

type AudioSampleEntry struct {
	Reserved1    [2]uint32 // 32 bits array,
	ChannelCount uint16    // 16 bits, is the number of channels such as 1 (mono) or 2 (stereo)
	SampleSize   uint16    // 16 bits, is in bits, and takes the default value of 16
	PreDefined   uint16    // 16 bits,
	Reserved2    uint16    // 16 bits,
	SampleRate   uint32    // 32 bits, is the sampling rate expressed as a 16.16 fixed-point number (hi.lo)
}

type AudioSampleGroupEntry struct{}

type AudioSpecificConfig struct {
	AudioObjectType        byte // 5 bits
	SamplingFrequencyIndex byte // 4 bits
	ChannelConfiguration   byte // 4 bits
	GASpecificConfig
}

type AuxInfo struct {
	AuxInfoType          uint32 // 32 bits,
	AuxInfoTypeParameter uint32 // 32 bits,
}

type BinaryXMLBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Data []uint8 // 8 bits array,
}

type BitRateBox struct {
	MP4BoxHeader // standard header

	BufferSizeDB uint32 // 32 bits, gives the size of the decoding buffer for the elementary stream in bytes.
	MaxBitrate   uint32 // 32 bits, gives the maximum rate in bits/second over any window of one second.
	AvgBitrate   uint32 // 32 bits, gives the average rate in bits/second over the entire presentation.
}

type ChunkLargeOffsetBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount  uint32   // 32 bits, is an integer that gives the number of entries in the following table
	ChunkOffset []uint64 // 64 bits array, entry count elements.
}

type ChunkOffsetBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount  uint32   // 32 bits, is an integer that gives the number of entries in the following table
	ChunkOffset []uint32 // 32 bits array, entry count elements.
}

type CleanApertureBox struct {
	MP4BoxHeader // standard header

	CleanApertureWidthN  uint32 // 32 bits, a fractional number which defines the exact clean aperture width, in counted pixels, of the video image
	CleanApertureWidthD  uint32 // 32 bits, a fractional number which defines the exact clean aperture width, in counted pixels, of the video image
	CleanApertureHeightN uint32 // 32 bits, a fractional number which defines the exact clean aperture height, in counted pixels, of the video image
	CleanApertureHeightD uint32 // 32 bits, a fractional number which defines the exact clean aperture height, in counted pixels, of the video image
	HorizOffN            uint32 // 32 bits, a fractional number which defines the horizontal offset of clean aperture centre minus (width-1)/2. Typically 0
	HorizOffD            uint32 // 32 bits, a fractional number which defines the horizontal offset of clean aperture centre minus (width-1)/2. Typically 0
	VertOffN             uint32 // 32 bits, a fractional number which defines the vertical offset of clean aperture centre minus (height-1)/2. Typically 0
	VertOffD             uint32 // 32 bits, a fractional number which defines the vertical offset of clean aperture centre minus (height-1)/2. Typically 0
}

type ColourInformationBox struct {
	MP4BoxHeader // standard header

	ColourType uint32 // 32 bits, an indication of the type of colour information supplied. For colour_type ‘nclx’: these fields are exactly the four bytes defined for PTM_COLOR_INFO( ) in A.7.2 of ISO/IEC 29199-2 but note that the full range flag is here in a different bit position
}

type CompactSampleSizeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Reserved    [3]uint8    // 24 bits,
	FieldSize   uint8       // 8 bits, is an integer specifying the size in bits of the entries in the following table; it shall take the value 4, 8 or 16. If the value 4 is used, then each byte contains two values: entry[i]<<4 + entry[i+1]; if the sizes do not fill an integral number of bytes, the last byte is padded with zeros.
	SampleCount uint32      // 32 bits,  is an integer that gives the number of entries in the following table
	EntrySize   interface{} //
}

type CompositionOffsetBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32                   // 32 bits, is an integer that gives the number of entries in the following table
	Table      []CompositionOffsetTable // Composition Offset Table, EntryCount elements.
}

type CompositionOffsetTable struct {
	SampleCount  uint32      // 32 bits, is an integer that counts the number of consecutive samples that have the given offset.
	SampleOffset interface{} // int32 or uint32, is an integer that gives the offset between CT and DT, such that CT(n) = DT(n) + CTTS(n).
}

type CompositionToDecodeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	CompositionToDTSShift        int32 // 32 bits, signed, if this value is added to the composition times (as calculated by the CTS offsets from the DTS), then for all samples, their CTS is guaranteed to be greater than or equal to their DTS, and the buffer model implied by the indicated profile/level will be honoured; if leastDecodeToDisplayDelta is positive or zero, this field can be 0; otherwise it should be at least (- leastDecodeToDisplayDelta)
	LeastDecodeToDisplayDelta    int32 // 32 bits, signed, the smallest composition offset in the CompositionTimeToSample box in this track
	GreatestDecodeToDisplayDelta int32 // 32 bits, signed, the largest composition offset in the CompositionTimeToSample box in this track
	CompositionStartTime         int32 // 32 bits, signed, the smallest computed composition time (CTS) for any sample in the media of this track
	CompositionEndTime           int32 // 32 bits, signed, the composition time plus the composition duration, of the sample with the largest computed composition time (CTS) in the media of this track; if this field takes the value 0, the composition end time is unknown.
}

type CopyrightBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Pad      byte    // 1 bit,
	Language [2]byte // 15 bits, declares the language code for the following text. See ISO 639-2/T for the set of three character codes. Each character is packed as the difference between its ASCII value and 0x60. The code is confined to being three lower-case letters, so these values are strictly positive.
	Notice   string  // string, is a null-terminated string in either UTF-8 or UTF-16 characters, giving a copyright notice. If UTF- 16 is used, the string shall start with the BYTE ORDER MARK (0xFEFF), to distinguish it from a UTF- 8 string. This mark does not form part of the final string.
}

type DataEntryUrlBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Location string // string,
}

type DataEntryUrnBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Name     string // string,
	Location string // string,
}

type DataInformationBox struct {
	MP4BoxHeader // standard header
}

type DataReferenceBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32      // 32 bits, is an integer that gives the number of entries in the following table
	DataEntry  interface{} // DataEntryUrlBox or DataEntryUrnBox.
}

type DegradationPriorityBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Priority []uint16 // 16 bits array, sample count elements, is integer specifying the degradation priority for each sample.
}

type EditBox struct {
	MP4BoxHeader // standard header
}

type EditListBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32          // 32 bits, is an integer that gives the number of entries in the following table
	Tables     []EditListTable // Edit List Table
}

type EditListTable struct {
	SegmentDuration   interface{} // uint64 or uint32, is an integer that specifies the duration of this edit segment in units of the timescale in the Movie Header Box
	MediaTime         interface{} // uint64 or uint32, is an integer containing the starting time within the media of this edit segment (in media time scale units, in composition time). If this field is set to –1, it is an empty edit. The last edit in a track shall never be an empty edit. Any difference between the duration in the Movie Header Box, and the track’s duration is expressed as an implicit empty edit at the end.
	MediaRateInteger  int16       // 16 bits,
	MediaRateFraction int16       // 16 bits,
}

type FDItemInformationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint16            // 16 bits,
	PE         []PartitionEntry  // EntryCount elements.
	FDSGB      FDSessionGroupBox // optional
	GidToNameB GroupIdToNameBox  // optional
}

type FDSessionGroupBox struct {
	MP4BoxHeader // standard header

	NumSessionGroups uint16                // 16 bits,
	Table            []FDSessionGroupTable // FD Session Group Table, NumSessionGroups elements.
}

type FDSessionGroupIDTable struct {
	GroupID uint32 // 32 bits
}

type FDSessionGroupTable struct {
	EntryCount                uint8                       // 8 bits,
	GIDTable                  []FDSessionGroupIDTable     // FDSession Group ID Table, EntryCount elements.
	NumChannelsInSessionGroup uint16                      // 16 bits
	HTIDTable                 []FDSessionHintTrackIDTable // FDSession Hint Track ID Table, NumChannelsInSessionGroup elements.
}

type FDSessionHintTrackIDTable struct {
	HintTrackID uint32 // 32 bits
}

type FECReservoirBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint16              // 16 bits,
	Table      []FECReservoirTable // FEC Reservoir Table, EntryCount elements.
}

type FECReservoirTable struct {
	ItemID      uint16 // 16 bits, indicates the location of the FEC reservoir associated with a source block.
	SymbolCount uint32 // 32 bits, indicates the number of repair symbols contained in the FEC reservoir.
}

type FilePartitionBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ItemID                     uint16               // 16 bits,
	PacketPayloadSize          uint16               // 16 bits,
	Reserved                   uint8                // 8 bits,
	FECEncodingID              uint8                // 8 bits,
	FECInstanceID              uint16               // 16 bits,
	MaxSourceBlockLength       uint16               // 16 bits,
	EncodingSymbolLength       uint16               // 16 bits,
	MaxNumberOfEncodingSymbols uint16               // 16 bits,
	SchemeSpecificInfo         string               // string,
	EntryCount                 uint16               // 16 bits,
	Tanble                     []FilePartitionTable //File Partition Table, EntryCount elements.
}

type FilePartitionTable struct {
	BlockCount uint16 // 16 bits,
	BlockSize  uint32 // 32 bits,
}

type FileReservoirBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint16               // 16 bits, gives the number of entries in the following list. An entry count here should match the total number or blocks in the corresponding file partition box.
	Table      []FileReservoirTable // EntryCount elements.
}

type FileReservoirTable struct {
	ItemID      uint16 // 16 bits, indicates the location of the File reservoir associated with a source block.
	SymbolCount uint32 // 32 bits, indicates the number of source symbols contained in the File reservoir.
}

type FileTypeBox struct {
	MP4BoxHeader // standard header

	MajorBrand       uint32   // 32 bits, is a brand identifier
	MinorVersion     uint32   // 32 bits, is an informative integer for the minor version of the major brand
	CompatibleBrands []uint32 // 32 bits array, is a list, to the end of the box, of brands
}

type FreeSpaceBox struct {
	MP4BoxHeader // standard header

	Data []uint8 // 8 bits array,
}

type GASpecificConfig struct {
	FrameLengthFlag    byte // 1 bit
	DependsOnCoreCoder byte // 1 bit
	ExtensionFlag      byte // 1 bit
}

type GroupIdToNameBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint16             // 16 bits, gives the number of entries in the following list.
	Table      []GroupIdToNameBox // Group Id To Name Table, EntryCount elements.
}

type GroupIdToNameTable struct {
	GroupID   uint32 // 32 bits, indicates a file group.
	GroupName string // string, is a null-terminated string in UTF-8 characters containing a file group name.
}

type H264NALUType byte

type H265NALUType byte

type HVCDecoderConfigurationRecord struct {
	PicWidthInLumaSamples  uint32 // sps
	PicHeightInLumaSamples uint32 // sps
	// contains filtered or unexported fields
}

type HandlerBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	PreDefined  uint32    // 32 bits,
	HandlerType uint32    // 32 bits, when present in a meta box, contains an appropriate value to indicate the format of the meta box contents. The value 'null' can be used in the primary meta box to indicate that it is merely being used to hold resources
	Reserved    [3]uint32 // 32 bits,
	Name        string    // string, is a null-terminated string in UTF-8 characters which gives a human-readable name for the track type (for debugging and inspection purposes).
}

type HintMediaHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	MaxPDUSize uint16 // 16 bits, gives the size in bytes of the largest PDU in this (hint) stream
	AvgPDUSize uint16 // 16 bits, gives the average size of a PDU over the entire presentation
	MaxBitrate uint32 // 32 bits, gives the maximum rate in bits/second over any window of one second
	AvgBitrate uint32 // 32 bits, gives the average rate in bits/second over the entire presentation
	Reserved   uint32 // 32 bits,
}

type HintSampleEntry struct {
	Data []uint8 // 8 bits array,
}

type HintSampleGroupEntry struct{}

type IPMPControlBox struct{}

type IndependentAndDisposableSamplesBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Table []IndependentAndDisposableSamplesTable // Independent And Disposable Samples Table, sample count elements
}

type IndependentAndDisposableSamplesTable struct {
	IsLeading           byte // 2 bits,
	SampleDependsOn     byte // 2 bits,
	SampleIsDependedOn  byte // 2 bits,
	SampleHasTedundancy byte // 2 bits,
}

type ItemDataBox struct {
	MP4BoxHeader // standard header

	Data []byte // 8 bits array, is the contained meta data
}

type ItemInfoBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint16          // 16 bits,
	ItemInfos  []ItemInfoEntry // EntryCount elements.
}

type ItemInfoEntry struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ItemID              uint16 // 16 bits
	ItemProtectionIndex uint16 // 16 bits
	ItemType            uint32 // 32 bits,
	ItemName            string // string,
	ContentType         string // string,
	ContentEncoding     string // string, optional
	ItemUriType         string // string,
	ExtensionType       uint32 // 32 bits, optional
	ItemInfoExtension          // optional
}

type ItemInfoExtension struct {
}

type ItemLocationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	OffsetSize     byte        // 4 bits,
	LengthSize     byte        // 4 bits,
	BaseOffsetSize byte        // 4 bits,
	IndexSize      byte        // 4 bits, if version == 1, index_size replace to reserved.
	ItemCount      uint16      // 16 bits,
	Table          interface{} // version == 1 -> ItemLocationTable1 , version == 2 -> ItemLocationTable2, ItemCount elements.
}

type ItemLocationExtentTable1 struct {
	ExtentIndex interface{} // unsigned int(index_size*8)
	ItemLocationExtentTable2
}

type ItemLocationExtentTable2 struct {
	ExtentOffset interface{} // unsigned int(offset_size*8)
	ExtentLength interface{} // unsigned int(length_size*8)
}

type ItemLocationTable1 struct {
	ItemID             uint16                     // 16 bits,
	Reserved           uint16                     // 12 bits,
	ConstructionMethod byte                       // 4 bits,
	DataReferenceIndex uint16                     // 16 bits,
	BaseOffset         interface{}                // unsigned int(base_offset_size*8),
	ExtentCount        uint16                     // 16 bits,
	ExtentTable        []ItemLocationExtentTable1 // Item Location Extent Table1, ExtentCount elements.
}

type ItemLocationTable2 struct {
	ItemID             uint16                     // 16 bits,
	DataReferenceIndex uint16                     // 16 bits,
	BaseOffset         interface{}                // unsigned int(base_offset_size*8),
	ExtentCount        uint16                     // 16 bits,
	ExtentTable        []ItemLocationExtentTable2 // Item Location Extent Table2, ExtentCount elements.
}

type ItemProtectionBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ProtectionCount uint16                // 16 bits,
	Table           []ItemProtectionTable // Item Protection Table, ProtectionCount elements.
}

type ItemProtectionTable struct {
	ProtectionInformation ProtectionSchemeInfoBox
}

type ItemReferenceBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SITRB []SingleItemTypeReferenceBox
}

type LevelAssignmentBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	LevelCount uint8                  // 8 bits, specifies the number of levels each fraction is grouped into. level_count shall be greater than or equal to 2.
	Table      []LevelAssignmentTable // Level Assignment Table, level count elements.
}

type LevelAssignmentTable struct {
	TrackId        uint32 // 32 bits, for loop entry j specifies the track identifier of the track assigned to level j.
	PaddingFlag    byte   // 1 bit, equal to 1 indicates that a conforming fraction can be formed by concatenating any positive integer number of levels within a fraction and padding the last Media Data box by zero bytes up to the full size that is indicated in the header of the last Media Data box. The semantics of padding_flag equal to 0 are that this is not assured.
	AssignmentType byte   // 7 bits,
}

type MP4 interface {
}

type MP4Body struct{}

type MP4Box interface {
	Header() *MP4Header
	Body() *MP4Body
}

type MP4BoxHeader struct {
	BoxSize uint32 // 32 bits, is an integer that specifies the number of bytes in this box, including all its fields and contained boxes; if size is 1 then the actual size is in the field largesize; if size is 0, then this box is the last one in the file, and its contents extend to the end of the file (normally only used for a Media Data Box)
	BoxType uint32 // 32 bits, identifies the box type; standard boxes use a compact type, which is normally four printable characters, to permit ease of identification, and is shown so in the boxes below. User extensions use an extended type; in this case, the type field is set to ‘uuid’.
}

type MP4BoxLargeHeader struct {
	LargeSize uint64    // 64 bits
	UUIDs     [16]uint8 // 128 bits
}

type MP4FullBoxHeader struct {
	Version uint8   // 8 bits, is an integer that specifies the version of this format of the box.
	Flags   [3]byte // 24 bits, is a map of flags
}

type MP4Header struct {
	MP4BoxHeader
}

type MediaBox struct {
	MP4BoxHeader // standard header

	Mhb MediaHeaderBox // the first child box(header box)
}

type MediaDataBox struct {
	MP4BoxHeader // standard header

	Data []byte // 8 bits array, is the contained media data.
}

type MediaHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	CreationTime     interface{} // int64 or int32, is an integer that declares the creation time of the presentation (in seconds since midnight, Jan. 1, 1904, in UTC time)
	ModificationTime interface{} // int64 or int32, is an integer that declares the most recent time the presentation was modified (in seconds since midnight, Jan. 1, 1904, in UTC time)
	TimeScale        uint32      // 32 bits, is an integer that specifies the time-scale for the entire presentation; this is the number of time units that pass in one second. For example, a time coordinate system that measures time in sixtieths of a second has a time scale of 60.
	Duration         interface{} // int64 or int32, is an integer that declares length of the presentation (in the indicated timescale). This property is derived from the presentation's tracks: the value of this field corresponds to the duration of the longest track in the presentation. If the duration cannot be determined then duration is set to all 1s.
	Pad              byte        // 1 bit,
	Language         [2]byte     // 15 bits, unsigned int(5)[3], declares the language code for this media. See ISO 639-2/T for the set of three charactercodes. Each character is packed as the difference between its ASCII value and 0x60. Since the code is confined to being three lower-case letters, these values are strictly positive
	PreDefined       uint16      // 16 bits,
}

type MediaInformationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header
}

type MediaInformationHeaderBoxes struct {
}

type MetaBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	PrimaryResource PrimaryItemBox     // optional
	FileLocations   DataInformationBox // optional
	ItemLocations   ItemLocationBox    // optional
	Protections     ItemProtectionBox  // optional
	ItemInfos       ItemInfoBox        // optional
	IPMPControl     IPMPControlBox     // optional
	ItemRefs        ItemReferenceBox   // optional
	ItemData        ItemDataBox        // optional

}

type MetaDataSampleEntry struct{}

type MetaboxRelationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	FirstMetaboxHandlerType  uint32 // 32 bits, indicates the first meta box to be related.
	SecondMetaboxHandlerType uint32 // 32 bits,  indicates the second meta box to be related.
	MetaboxRelation          uint8  // 8 bits, indicates the relation between the two meta boxes.
}

type MovieBox struct {
	MP4BoxHeader // standard header

}

type MovieExtendsBox struct {
	MP4BoxHeader // standard header
}

type MovieExtendsHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header
}

type MovieFragmentBox struct {
	MP4BoxHeader // standard header
}

type MovieFragmentHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SequenceNumber uint32 // 32 bits, the ordinal number of this fragment, in increasing order
}

type MovieFragmentRandomAccessBox struct {
	MP4BoxHeader // standard header
}

type MovieFragmentRandomAccessOffsetBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Size uint32 // 32 bits, is an integer gives the number of bytes of the enclosing ‘mfra’ box. This field is placed at the last of the enclosing box to assist readers scanning from the end of the file in finding the ‘mfra’ box.
}

type MovieHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	CreationTime     interface{} // uint64 or uint32, is an integer that declares the creation time of the presentation (in seconds since midnight, Jan. 1, 1904, in UTC time)
	ModificationTime interface{} // uint64 or uint32, is an integer that declares the most recent time the presentation was modified (in seconds since midnight, Jan. 1, 1904, in UTC time)
	TimeScale        uint32      // 32 bits, is an integer that specifies the time-scale for the entire presentation; this is the number of time units that pass in one second. For example, a time coordinate system that measures time in sixtieths of a second has a time scale of 60.
	Duration         interface{} // uint64 or uint32, is an integer that declares length of the presentation (in the indicated timescale). This property is derived from the presentation's tracks: the value of this field corresponds to the duration of the longest track in the presentation. If the duration cannot be determined then duration is set to all 1s.
	Rate             int32       // 32 bits, is a fixed point 16.16 number that indicates the preferred rate to play the presentation; 1.0 (0x00010000) is normal forward playback
	Volume           int16       // 16 bits, is a fixed point 8.8 number that indicates the preferred playback volume. 1.0 (0x0100) is full volume.
	Reserved1        int16       // 16 bits, bit[16]
	Reserved2        [2]uint32   // 32 bits array, const unsigned int(32)[2]
	Matrix           [9]int32    // 32 bits array, provides a transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex values(0,0,0x40000000).
	PreDefined       [6]int32    // 32 bits array, bit(32)[6]
	NextTrackID      uint32      // 32 bits, is a non-zero integer that indicates a value to use for the track ID of the next track to be added to this presentation. Zero is not a valid track ID value. The value of next_track_ID shall be larger than the largest track-ID in use. If this value is equal to all 1s (32-bit maxint), and a new media track is to be added, then a search must be made in the file for an unused track identifier.
}

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

type NALUnit struct {
	NALUHeader
	RBSP
}

type NullMediaHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header
}

type OriginalFormatBox struct {
	MP4BoxHeader // standard header

	DataFormat uint32 // 32 bits, is the four-character-code of the original un-transformed sample entry (e.g. “mp4v” if the stream contains protected or restricted MPEG-4 visual material).
}

type PaddingBitsBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SampleCount uint32             // 32 bits, counts the number of samples in the track; it should match the count in other tables
	Table       []PaddingBitsTable // Padding Bits Table, (sample count + 1) / 2 elements.
}

type PaddingBitsTable struct {
	Reserved1 byte // 1 bit,
	Pad1      byte // 3 bits, a value from 0 to 7, indicating the number of bits at the end of sample (i*2)+1.
	Reserved2 byte // 1 bit,
	Pad2      byte // 3 bits, a value from 0 to 7, indicating the number of bits at the end of sample (i*2)+2.
}

type PartitionEntry struct {
	FPB   FilePartitionBox //
	FECRB FECReservoirBox  //optional
	FRB   FileReservoirBox //optional
}

type PixelAspectRatioBox struct {
	MP4BoxHeader // standard header

	HSpacing uint32 // 32 bits, define the relative width and height of a pixel;
	VSpacing uint32 // 32 bits, define the relative width and height of a pixel;
}

type PrimaryItemBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ItemID uint16 // 16 bits, is the identifier of the primary item
}

type ProducerReferenceTimeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ReferenceTrackID uint32      // 32 bits, provides the track_ID for the reference track.
	NtpTimestamp     uint64      // 64 bits, indicates a UTC time in NTP format corresponding to decoding_time.
	MediaTime        interface{} // uint32 or uint64, corresponds to the same time as ntp_timestamp, but in the time units used for the reference track, and is measured on this media clock as the media is produced.
}

type ProgressiveDownloadInformationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Rate         uint32 // 32 bits, is a download rate expressed in bytes/second
	InitialDelay uint32 // 32 bits, is the suggested delay to use when playing the file, such that if download continues at the given rate, all data within the file will arrive in time for its use and playback should not need to stall.
}

type ProtectionSchemeInfoBox struct {
	MP4BoxHeader // standard header

	OriginalFormat OriginalFormatBox    //
	Type           SchemeTypeBox        // optional
	Info           SchemeInformationBox // optional
}

type RBSP interface {
}

type SPSInfo struct {
	ProfileIdc uint
	LevelIdc   uint

	MbWidth  uint
	MbHeight uint

	CropLeft   uint
	CropRight  uint
	CropTop    uint
	CropBottom uint

	Width  uint
	Height uint
}

type SampleAuxiliaryInformationOffsetsBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

}

type SampleAuxiliaryInformationSizesBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Table interface{} // SampleAuxiliaryInformationSizesTable1 or SampleAuxiliaryInformationSizesTable2.
}

type SampleAuxiliaryInformationSizesTable1 struct {
	AuxInfoType           uint32 // 32 bits,
	AuxInfoTypeParameter  uint32 // 32 bits,
	DefaultSampleInfoSize uint8  // 8 bits,  is an integer specifying the sample auxiliary information size for the case where all the indicated samples have the same sample auxiliary information size. If the size varies then this field shall be zero.
	SampleCount           uint32 // 32 bits,
}

type SampleAuxiliaryInformationSizesTable2 struct {
	DefaultSampleInfoSize uint8  // 8 bits,  is an integer specifying the sample auxiliary information size for the case where all the indicated samples have the same sample auxiliary information size. If the size varies then this field shall be zero.
	SampleCount           uint32 // 32 bits,
}

type SampleDescriptionBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32 // 32 bits, is an integer that gives the number of entries in the following table
}

type SampleEntry struct {
	Reserved           [6]uint8 // 48 bits,
	DataReferenceIndex uint16   // 16 bits, is an integer that contains the index of the data reference to use to retrieve data associated with samples that use this sample description. Data references are stored in Data Reference Boxes. The index ranges from 1 to the number of data references.
}

type SampleGroupDescriptionBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	GroupingType uint32 // 32 bits, is an integer that identifies the SampleToGroup box that is associated with this sample group description.
	EntryCount   uint32 // 32 bits, is an integer that gives the number of entries in the following table.
}

type SampleGroupDescriptionEntry struct{}

type SampleSizeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SampleSize  uint32      // 32 bits, is integer specifying the default sample size. If all the samples are the same size, this field contains that size value. If this field is set to 0, then the samples have different sizes, and those sizes are stored in the sample size table. If this field is not 0, it specifies the constant sample size, and no array follows.
	SampleCount uint32      // 32 bits, is an integer that gives the number of samples in the track; if sample-size is 0, then it is also the number of entries in the following table.
	EntrySize   interface{} // 32 bits array, SampleCount elements, is an integer specifying the size of a sample, indexed by its number.
}

type SampleSizeBoxes struct{}

type SampleTableBox struct {
	MP4BoxHeader // standard header
}

type SampleToChunkBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32               // 32 bits, is an integer that gives the number of entries in the following table
	Table      []SampleToChunkTable // Sample To Chunk Table, entry count elements.
}

type SampleToChunkTable struct {
	FirstChunk             []uint32 // 32 bits, is an integer that gives the index of the first chunk in this run of chunks that share the same samples-per-chunk and sample-description-index; the index of the first chunk in a track has the value 1 (the first_chunk field in the first record of this box has the value 1, identifying that the first sample maps to the first chunk).
	SamplesPerChunk        []uint32 // 32 bits, is an integer that gives the number of samples in each of these chunks
	SampleDescriptionIndex []uint32 // 32 bits, is an integer that gives the index of the sample entry that describes the samples in this chunk. The index ranges from 1 to the number of sample entries in the Sample Description Box
}

type SampleToGroupBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	GroupingType uint32               // 32 bits, is an integer that identifies the type (i.e. criterion used to form the sample groups) of the sample grouping and links it to its sample group description table with the same value for grouping type. At most one occurrence of this box with the same value for grouping_type (and, if used, grouping_type_parameter) shall exist for a track.
	EntryCount   uint32               // 32 bits, is an integer that gives the number of entries in the following table.
	Table        []SampleToGroupTable // Sample To Group Table, entry count elements.
}

type SampleToGroupTable struct {
	SampleCount           uint32 // 32 bits, is an integer that gives the number of consecutive samples with the same sample group descriptor. If the sum of the sample count in this box is less than the total sample count, then the reader should effectively extend it with an entry that associates the remaining samples with no group. It is an error for the total in this box to be greater than the sample_count documented elsewhere, and the reader behaviour would then be undefined.
	GroupDescriptionIndex uint32 // 32 bits, is an integer that gives the index of the sample group entry which describes the samples in this group. The index ranges from 1 to the number of sample group entries in the SampleGroupDescription Box, or takes the value 0 to indicate that this sample is a member of no group of this type.
}

type SchemeInformationBox struct {
	MP4BoxHeader // standard header

	SchemeSpecificData []SchemeTypeBox
}

type SchemeTypeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SchemeType    uint32 // 32 bits, is the code defining the protection or restriction scheme.
	SchemeVersion uint32 // 32 bits, is the version of the scheme (used to create the content)
}

type SegmentIndexBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	ReferenceID              uint32              // 32 bits,
	TimeScale                uint32              // 32 bits,
	EarliestPresentationTime interface{}         // uint32 or uint64,
	FirstOffset              interface{}         // uint32 or uint64,
	Reserved                 uint16              // 16 bits,
	ReferenceCount           uint16              // 16 bits,
	Table                    []SegmentIndexTable // Segment Index Table, ReferenceCount elements
}

type SegmentIndexTable struct {
	ReferenceType      byte   // 1 bit
	ReferencedSize     uint32 // 32 bits
	SubSegmentDuration uint32 // 32 bits,
	StartsWithSAP      byte   // 1 bit
	SAPType            byte   // 3 bits,
	SAPDeltaTime       uint32 // 28 bits,
}

type ShadowSyncSampleBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32                  // 32 bits, is an integer that gives the number of entries in the following table.
	Table      []ShadowSyncSampleTable // Shadow Sync Sample Table, entry count elements.
}

type ShadowSyncSampleTable struct {
	ShadowedSampleNumber uint32 // 32 bits, gives the number of a sample for which there is an alternative sync sample.
	SyncSampleNumber     uint32 // 32 bits, gives the number of the alternative sync sample.
}

type SingleItemTypeReferenceBox struct {
	MP4BoxHeader // standard header

	FromItemID     uint16                         // 16 bits, contains the ID of the item that refers to other items
	ReferenceCount uint16                         // 16 bits, is the number of references
	Table          []SingleItemTypeReferenceTable // Single Item Type Reference Table, ReferenceCount elements.
}

type SingleItemTypeReferenceTable struct {
	ToItemID uint16 // 16 bits, contains the ID of the item referred to
}

type SoundMediaHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	Balance  int16  // 16 bits, is a fixed-point 8.8 number that places mono audio tracks in a stereo space; 0 is centre (the normal value); full left is -1.0 and full right is 1.0
	Reserved uint16 // 16 bits,
}

type SubSampleCountTable struct {
	SubsampleSize     interface{} // uint16 or uint32, is an integer that specifies the size, in bytes, of the current sub-sample
	SubsamplePriority uint8       // 8 bits, is an integer specifying the degradation priority for each sub-sample. Higher values of subsample_priority, indicate sub-samples which are important to, and have a greater impact on, the decoded quality.
	DiscardAble       uint8       // 8 bits, equal to 0 means that the sub-sample is required to decode the current sample, while equal to 1 means the sub-sample is not required to decode the current sample but may be used for enhancements, e.g., the sub-sample consists of supplemental enhancement information (SEI) messages.
	Reserved          uint32      // 32 bits,
}

type SubSampleInformationBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32                      // 32 bits, is an integer that gives the number of entries in the following table.
	Table      []SubSampleInformationTable // Sub-Sample Information Table, entry count elements.

}

type SubSampleInformationTable struct {
	SampleDelta    uint32                // 32 bits, is an integer that specifies the sample number of the sample having sub-sample structure. It is coded as the difference between the desired sample number, and the sample number indicated in the previous entry. If the current entry is the first entry, the value indicates the sample number of the first sample having sub-sample information, that is, the value is the difference between the sample number and zero (0).
	SubsampleCount uint16                // 16 bits, is an integer that specifies the number of sub-sample for the current sample. If there is no sub-sample structure, then this field takes the value 0.
	CountTable     []SubSampleCountTable // Sub-Sample Information Table1, subsample count elements.
}

type SubTrack struct {
	MP4BoxHeader // standard header
}

type SubTrackDefinition struct {
	MP4BoxHeader // standard header
}

type SubTrackInformation struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SwitchGroup    int16    // 16 bits,
	AlternateGroup int16    // 16 bits,
	SubTrackID     uint32   // 32 bits, is an integer. A non-zero value uniquely identifies the sub track locally within the track. A zero value (default) means that sub track ID is not assigned.
	AttributeList  []uint32 // 32 bits array, is a list, to the end of the box, of attributes. The attributes in this list should be used as descriptions of sub tracks or differentiating criteria for tracks and sub tracks in the same alternate or switch group
}

type SubsegmentIndexBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SubSegmentCount uint32                 // 32 bits, is a positive integer specifying the number of subsegments for which partial subsegment information is specified in this box. subsegment_count shall be equal to reference_count (i.e., the number of movie fragment references) in the immediately preceding Segment Index box.
	Table           []SubsegmentIndexTable // Subsegment Index Table, SubSegmentCount elements.
}

type SubsegmentIndexTable struct {
	RangesCount uint32                  // 32 bits, specifies the number of partial subsegment levels into which the media data is grouped. This value shall be greater than or equal to 2.
	Rtable      []SubsegmentRangesTable // Subsegment Ranges Table, RangesCount elements.
}

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

type SyncSampleBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount   uint32   // 32 bits, is an integer that gives the number of entries in the following table. If entry_count is zero, there are no sync samples within the stream and the following table is empty
	SampleNumber []uint32 // 32 bits array, entry count elements. gives the numbers of the samples that are sync samples in the stream.
}

type TextMetaDataSampleEntry struct {
	ContentEncoding string     // optional, is a null-terminated string in UTF-8 characters, and provides a MIME type which identifies the content encoding of the timed metadata
	MimeFormat      string     // string, provides a MIME type which identifies the content format of the timed metadata. Examples for this field are ‘text/html’ and ‘text/plain’.
	Brb             BitRateBox // optional
}

type TimeToSampleBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	EntryCount uint32              // 32 bits, is an integer that gives the number of entries in the following table
	Table      []TimeToSampleTable // Time To Sample Table , EntryCount elements
}

type TimeToSampleTable struct {
	SampleCount []uint32 // 32 bits, is an integer that counts the number of consecutive samples that have the given duration
	SampleDelta []uint32 // 32 bits, is an integer that gives the delta of these samples in the time-scale of the media.
}

type TrackBox struct {
	MP4BoxHeader // standard header

	Thb TrackHeaderBox // the first child box(header box)
}

type TrackExtendsBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	TrackID                       uint32 // 32 bits, identifies the track; this shall be the track ID of a track in the Movie Box
	DefaultSampleDescriptionIndex uint32 // 32 bits,
	DefaultSampleDuration         uint32 // 32 bits,
	DefaultSampleSize             uint32 // 32 bits,
	DefaultSampleFlags            uint32 // 32 bits,
}

type TrackFragmentBaseMediaDecodeTimeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	BaseMediaDecodeTime interface{} // uint32 or uint64, is an integer equal to the sum of the decode durations of all earlier samples in the media, expressed in the media's timescale. It does not include the samples added in the enclosing track fragment.
}

type TrackFragmentBox struct {
	MP4BoxHeader // standard header
}

type TrackFragmentHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	TrackID uint32 // 32 bits,

	// all the following are optional fields
	BaseDataOffset         uint64 // 64 bits, the base offset to use when calculating data offsets
	SampleDescriptionIndex uint32 // 32 bits,
	DefaultSampleDuration  uint32 // 32 bits,
	DefaultSampleSize      uint32 // 32 bits,
	DefaultSampleFlags     uint32 // 32 bits,
}

type TrackFragmentRandomAccessBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	TrackID               uint32                           // 32 bits, is an integer identifying the track_ID.
	Reserved              uint32                           // 26 bits,
	LengthSizeOfTrafNum   byte                             // 2 bits, indicates the length in byte of the traf_number field minus one.
	LengthSizeOfTrunNum   byte                             // 2 bits, indicates the length in byte of the trun_number field minus one.
	LengthSizeOfSampleNum byte                             // 2 bits, indicates the length in byte of the sample_number field minus one.
	NumberOfEntry         uint32                           // 32 bits, is an integer that gives the number of the entries for this track. If this value is zero, it indicates that every sample is a sync sample and no table entry follows.
	Table                 []TrackFragmentRandomAccessTable // Track Fragment RandomAccess Table 1, NumberOfEntry elements.
}

type TrackFragmentRandomAccessTable struct {
	Time         interface{} // uint32 or uint64, is 32 or 64 bits integer that indicates the presentation time of the sync sample in units defined in the ‘mdhd’ of the associated track.
	Moofoffset   interface{} // uint32 or uint64, is 32 or 64 bits integer that gives the offset of the ‘moof’ used in this entry. Offset is the byte-offset between the beginning of the file and the beginning of the ‘moof’.
	TrafNumber   interface{} // unsigned int((length_size_of_traf_num+1) * 8). indicates the ‘traf’ number that contains the sync sample. The number ranges from 1 (the first ‘traf’ is numbered 1) in each ‘moof’.
	TrunNumber   interface{} // unsigned int((length_size_of_trun_num+1) * 8). indicates the ‘trun’ number that contains the sync sample. The number ranges from 1 in each ‘traf’
	SampleNumber interface{} // unsigned int((length_size_of_sample_num+1) * 8) . indicates the sample number of the sync sample. The number ranges from 1 in each ‘trun’.
}

type TrackFragmentRunBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SampleCount uint32 // 32 bits, the number of samples being added in this run; also the number of rows in the following table (the rows can be empty)

	// the following are optional fields
	DataOffset       int32  // 32 bits, signed, is added to the implicit or explicit data_offset established in the track fragment header.
	FirstSampleFlags uint32 // 32 bits, provides a set of flags for the first sample only of this run.

	// all fields in the following array are optional
	Table []TrackFragmentRunTable // Track Fragment Run Table 1, SampleCount elements.
}

type TrackFragmentRunTable struct {
	SampleDuration              uint32      // 32 bits,
	SampleSize                  uint32      // 32 bits,
	SampleFlags                 uint32      // 32 bits,
	SampleCompositionTimeOffset interface{} // uint32 or int32,
}

type TrackGroupBox struct {
	MP4BoxHeader // standard header
}

type TrackGroupTypeBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	TrackGroupID uint32 // 32 bits, indicates the grouping type and shall be set to one of the following values, or a value registered, or a value from a derived specification or registration
}

type TrackHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	CreationTime     interface{} // uint64 or uint32,
	ModificationTime interface{} // uint64 or uint32,
	TrackID          uint32      // 32 bits, is an integer that uniquely identifies this track over the entire life-time of this presentation. Track IDs are never re-used and cannot be zero
	Reserved1        uint32      // 32 bits,
	Duration         interface{} // uint64 or uint32,
	Reserved2        [2]uint32   // 32 bits array,
	Layer            int16       // 16 bits, specifies the front-to-back ordering of video tracks; tracks with lower numbers are closer to the viewer. 0 is the normal value, and -1 would be in front of track 0, and so on
	AlternateGroup   int16       // 16 bits,
	Volume           int16       // 16 bits, if track_is_audio 0x0100 else 0
	Reserved3        uint16      // 16 bits,
	Matrix           [9]int32    // 32 bits array, provides a transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex (0,0,0x40000000). { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }
	Width            uint32      // 32 bits,
	Height           uint32      // 32 bits,
}

type TrackReferenceBox struct {
	MP4BoxHeader // standard header
}

type TrackReferenceTypeBox struct {
	MP4BoxHeader // standard header

	TrackIDs []uint32 // 32 bits, is an integer that provides a reference from the containing track to another track in the presentation. track_IDs are never re-used and cannot be equal to zero
}

type TrackSelectionBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	SwitchGroup   int32    // 32 bits, is an integer that specifies a group or collection of tracks. If this field is 0 (default value) or if the Track Selection box is absent there is no information on whether the track can be used for switching during playing or streaming. If this integer is not 0 it shall be the same for tracks that can be used for switching between each other. Tracks that belong to the same switch group shall belong to the same alternate group. A switch group may have only one member.
	AttributeList []uint32 // 32 bits array, to end of the box, is a list, to the end of the box, of attributes. The attributes in this list should be used as descriptions of tracks or differentiation criteria for tracks in the same alternate or switch group. Each differentiating attribute is associated with a pointer to the field or information that distinguishes the track.
}

type URIBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	TheURI string // string, is a URI formatted according to the rules in 6.2.4
}

type URIInitBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	UriInitializationData []uint8 // 8 bits array,  is opaque data whose form is defined in the documentation of the URI form.
}

type URIMetaSampleEntry struct {
	TheLabel URIBox
	Init     URIInitBox // optional

}

type UserDataBox struct {
	MP4BoxHeader // standard header
}

type VideoCodecID byte

type VideoMediaHeaderBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	GraphicsMode uint16    // 16 bits, specifies a composition mode for this video track, from the following enumerated set, which may be extended by derived specifications: copy = 0 copy over the existing image
	Opcolor      [3]uint16 // 16 bits array, is a set of 3 colour values (red, green, blue) available for use by graphics modes
}

type VisualSampleEntry struct {
	PreDefined1     uint16              // 16 bits,
	Reserved1       uint16              // 16 bits,
	PreDefined2     [3]uint32           // 96 bits,
	Width           uint16              // 16 bits, are the maximum visual width and height of the stream described by this sample description, in pixels
	Height          uint16              // 16 bits, are the maximum visual width and height of the stream described by this sample description, in pixels
	HorizreSolution uint32              // 32 bits, fields give the resolution of the image in pixels-per-inch, as a fixed 16.16 number
	VertreSolution  uint32              // 32 bits, fields give the resolution of the image in pixels-per-inch, as a fixed 16.16 number
	Reserved3       uint32              // 32 bits,
	FrameCount      uint16              // 16 bits, indicates how many frames of compressed video are stored in each sample. The default is 1, for one frame per sample; it may be more than 1 for multiple frames per sample
	CompressorName  [32]string          // 32 string, is a name, for informative purposes. It is formatted in a fixed 32-byte field, with the first byte set to the number of bytes to be displayed, followed by that number of bytes of displayable data, and then padding to complete 32 bytes total (including the size byte). The field may be set to 0.
	Depth           uint16              // 16 bits, takes one of the following values 0x0018 – images are in colour with no alpha
	PreDefined3     int16               // 16 bits,
	Cab             CleanApertureBox    // optional, other boxes from derived specifications
	Parb            PixelAspectRatioBox // optional, other boxes from derived specifications
}

type VisualSampleGroupEntry struct{}

type XMLBox struct {
	MP4BoxHeader     // standard header
	MP4FullBoxHeader // full box header

	XML string // string,
}

type XMLMetaDataSampleEntry struct {
	ContentEncoding string     // optional, is a null-terminated string in UTF-8 characters, and provides a MIME type which identifies the content encoding of the timed metadata
	NameSpace       string     // string, gives the namespace of the schema for the timed XML metadata
	SchemaLocation  string     // optional, optionally provides an URL to find the schema corresponding to the namespace. This is needed for decoding of the timed metadata by XML aware encoding mechanisms such as BiM.
	Brb             BitRateBox // optional
}