800 lines
19 KiB
Go
800 lines
19 KiB
Go
package avif
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"image"
|
|
"io"
|
|
)
|
|
|
|
type fourCC [4]byte
|
|
|
|
var (
|
|
boxTypeFTYP = fourCC{'f', 't', 'y', 'p'}
|
|
boxTypeMDAT = fourCC{'m', 'd', 'a', 't'}
|
|
boxTypeMETA = fourCC{'m', 'e', 't', 'a'}
|
|
boxTypeHDLR = fourCC{'h', 'd', 'l', 'r'}
|
|
boxTypePITM = fourCC{'p', 'i', 't', 'm'}
|
|
boxTypeILOC = fourCC{'i', 'l', 'o', 'c'}
|
|
boxTypeIINF = fourCC{'i', 'i', 'n', 'f'}
|
|
boxTypeINFE = fourCC{'i', 'n', 'f', 'e'}
|
|
boxTypeIPRP = fourCC{'i', 'p', 'r', 'p'}
|
|
boxTypeIPCO = fourCC{'i', 'p', 'c', 'o'}
|
|
boxTypeISPE = fourCC{'i', 's', 'p', 'e'}
|
|
boxTypePASP = fourCC{'p', 'a', 's', 'p'}
|
|
boxTypeAV1C = fourCC{'a', 'v', '1', 'C'}
|
|
boxTypePIXI = fourCC{'p', 'i', 'x', 'i'}
|
|
boxTypeIPMA = fourCC{'i', 'p', 'm', 'a'}
|
|
|
|
itemTypeMIF1 = fourCC{'m', 'i', 'f', '1'}
|
|
itemTypeAVIF = fourCC{'a', 'v', 'i', 'f'}
|
|
itemTypeMIAF = fourCC{'m', 'i', 'a', 'f'}
|
|
itemTypePICT = fourCC{'p', 'i', 'c', 't'}
|
|
itemTypeMIME = fourCC{'m', 'i', 'm', 'e'}
|
|
itemTypeURI = fourCC{'u', 'r', 'i', ' '}
|
|
itemTypeAV01 = fourCC{'a', 'v', '0', '1'}
|
|
)
|
|
|
|
func ulen(s string) uint32 {
|
|
return uint32(len(s))
|
|
}
|
|
|
|
func bflag(b bool, pos uint8) uint8 {
|
|
if b {
|
|
return 1 << (pos - 1)
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func writeAll(w io.Writer, writers ...io.WriterTo) (err error) {
|
|
for _, wt := range writers {
|
|
_, err = wt.WriteTo(w)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func writeBE(w io.Writer, chunks ...interface{}) (err error) {
|
|
for _, v := range chunks {
|
|
err = binary.Write(w, binary.BigEndian, v)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
type box struct {
|
|
size uint32
|
|
typ fourCC
|
|
}
|
|
|
|
func (b *box) Size() uint32 {
|
|
return 8
|
|
}
|
|
|
|
func (b *box) WriteTo(w io.Writer) (n int64, err error) {
|
|
err = writeBE(w, b.size, b.typ)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
type fullBox struct {
|
|
box
|
|
version uint8
|
|
flags uint32
|
|
}
|
|
|
|
func (b *fullBox) Size() uint32 {
|
|
return 12
|
|
}
|
|
|
|
func (b *fullBox) WriteTo(w io.Writer) (n int64, err error) {
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
versionAndFlags := (uint32(b.version) << 24) | (b.flags & 0xffffff)
|
|
err = writeBE(w, versionAndFlags)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// File Type Box
|
|
type boxFTYP struct {
|
|
box
|
|
majorBrand fourCC
|
|
minorVersion uint32
|
|
compatibleBrands []fourCC
|
|
}
|
|
|
|
func (b *boxFTYP) Size() uint32 {
|
|
return b.box.Size() +
|
|
4 /*major_brand*/ + 4 /*minor_version*/ + uint32(len(b.compatibleBrands))*4
|
|
}
|
|
|
|
func (b *boxFTYP) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeFTYP
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.majorBrand, b.minorVersion, b.compatibleBrands)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Media Data Box
|
|
type boxMDAT struct {
|
|
box
|
|
data []byte
|
|
}
|
|
|
|
func (b *boxMDAT) Size() uint32 {
|
|
return b.box.Size() + uint32(len(b.data))
|
|
}
|
|
|
|
func (b *boxMDAT) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeMDAT
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(b.data)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// The Meta box
|
|
type boxMETA struct {
|
|
fullBox
|
|
theHandler boxHDLR
|
|
primaryResource boxPITM
|
|
itemLocations boxILOC
|
|
itemInfos boxIINF
|
|
itemProps boxIPRP
|
|
}
|
|
|
|
func (b *boxMETA) Size() uint32 {
|
|
return b.fullBox.Size() + b.theHandler.Size() + b.primaryResource.Size() +
|
|
b.itemLocations.Size() + b.itemInfos.Size() + b.itemProps.Size()
|
|
}
|
|
|
|
func (b *boxMETA) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeMETA
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeAll(w, &b.theHandler, &b.primaryResource, &b.itemLocations,
|
|
&b.itemInfos, &b.itemProps)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Handler Reference Box
|
|
type boxHDLR struct {
|
|
fullBox
|
|
preDefined uint32
|
|
handlerType fourCC
|
|
reserved [3]uint32
|
|
name string
|
|
}
|
|
|
|
func (b *boxHDLR) Size() uint32 {
|
|
return b.fullBox.Size() +
|
|
4 /*pre_defined*/ + 4 /*handler_type*/ + 12 /*reserved*/ +
|
|
ulen(b.name) + 1 /*\0*/
|
|
}
|
|
|
|
func (b *boxHDLR) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeHDLR
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.preDefined, b.handlerType, b.reserved, []byte(b.name), []byte{0})
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Primary Item Box
|
|
type boxPITM struct {
|
|
fullBox
|
|
itemID uint16
|
|
}
|
|
|
|
func (b *boxPITM) Size() uint32 {
|
|
return b.fullBox.Size() + 2 /*item_ID*/
|
|
}
|
|
|
|
func (b *boxPITM) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypePITM
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.itemID)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// The Item Location Box
|
|
type boxILOC struct {
|
|
fullBox
|
|
offsetSize uint8 // 4 bits
|
|
lengthSize uint8 // 4 bits
|
|
baseOffsetSize uint8 // 4 bits
|
|
reserved uint8 // 4 bits
|
|
itemCount uint16
|
|
items []boxILOCItem
|
|
}
|
|
|
|
func (b *boxILOC) Size() uint32 {
|
|
size := b.fullBox.Size() + 1 /*offset_size + length_size*/ +
|
|
1 /*base_offset_size + reserved*/ + 2 /*item_count*/
|
|
for _, i := range b.items {
|
|
size += 2 /*item_ID*/ + 2 /*data_reference_index*/ + uint32(b.baseOffsetSize) +
|
|
2 /*extent_count*/ + uint32(len(i.extents))*uint32(b.offsetSize+b.lengthSize)
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (b *boxILOC) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeILOC
|
|
b.itemCount = uint16(len(b.items))
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
offsetSizeAndLengthSize := (b.offsetSize << 4) | (b.lengthSize & 0xf)
|
|
baseOffsetSizeAndReserved := (b.baseOffsetSize << 4) | (b.reserved & 0xf)
|
|
err = writeBE(w, offsetSizeAndLengthSize, baseOffsetSizeAndReserved, b.itemCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, i := range b.items {
|
|
err = i.write(w, b.baseOffsetSize, b.offsetSize, b.lengthSize)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type boxILOCItem struct {
|
|
itemID uint16
|
|
dataReferenceIndex uint16
|
|
baseOffset uint64 // 0, 32 or 64 bits
|
|
extentCount uint16
|
|
extents []boxILOCItemExtent
|
|
}
|
|
|
|
func (i *boxILOCItem) write(w io.Writer, baseOffsetSize, offsetSize, lengthSize uint8) (err error) {
|
|
i.extentCount = uint16(len(i.extents))
|
|
var baseOffset interface{}
|
|
baseOffset = []byte{}
|
|
if baseOffsetSize == 4 {
|
|
baseOffset = uint32(i.baseOffset)
|
|
} else if baseOffsetSize == 8 {
|
|
baseOffset = i.baseOffset
|
|
}
|
|
err = writeBE(w, i.itemID, i.dataReferenceIndex, baseOffset, i.extentCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, e := range i.extents {
|
|
if err = e.write(w, offsetSize, lengthSize); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type boxILOCItemExtent struct {
|
|
extentOffset uint64 // 0, 32 or 64 bits
|
|
extentLength uint64 // 0, 32 or 64 bits
|
|
}
|
|
|
|
func (e *boxILOCItemExtent) write(w io.Writer, offsetSize, lengthSize uint8) (err error) {
|
|
var extentOffset interface{}
|
|
extentOffset = []byte{}
|
|
if offsetSize == 4 {
|
|
extentOffset = uint32(e.extentOffset)
|
|
} else if offsetSize == 8 {
|
|
extentOffset = e.extentOffset
|
|
}
|
|
var extentLength interface{}
|
|
extentLength = []byte{}
|
|
if lengthSize == 4 {
|
|
extentLength = uint32(e.extentLength)
|
|
} else if lengthSize == 8 {
|
|
extentLength = e.extentLength
|
|
}
|
|
err = writeBE(w, extentOffset, extentLength)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Item Information Box
|
|
type boxIINF struct {
|
|
fullBox
|
|
entryCount uint16
|
|
itemInfos []boxINFEv2
|
|
}
|
|
|
|
func (b *boxIINF) Size() uint32 {
|
|
size := b.fullBox.Size() + 2 /*entry_count*/
|
|
for _, ie := range b.itemInfos {
|
|
size += ie.Size()
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (b *boxIINF) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeIINF
|
|
b.entryCount = uint16(len(b.itemInfos))
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
if err = writeBE(w, b.entryCount); err != nil {
|
|
return
|
|
}
|
|
for _, ie := range b.itemInfos {
|
|
if _, err = ie.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Item Info Entry Box
|
|
type boxINFEv2 struct {
|
|
fullBox
|
|
itemID uint16
|
|
itemProtectionIndex uint16
|
|
itemType fourCC
|
|
itemName string
|
|
contentType string
|
|
contentEncoding string
|
|
itemURIType string
|
|
}
|
|
|
|
func (b *boxINFEv2) Size() uint32 {
|
|
size := b.fullBox.Size() + 2 /*item_ID*/ + 2 /*item_protection_index*/ +
|
|
4 /*item_type*/ + ulen(b.itemName) + 1 /*\0*/
|
|
if b.itemType == itemTypeMIME {
|
|
size += ulen(b.contentType) + 1 /*\0*/ + ulen(b.contentEncoding) + 1 /*\0*/
|
|
} else if b.itemType == itemTypeURI {
|
|
size += ulen(b.itemURIType)
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (b *boxINFEv2) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeINFE
|
|
b.version = 2
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.itemID, b.itemProtectionIndex, b.itemType,
|
|
[]byte(b.itemName), []byte{0})
|
|
if err != nil {
|
|
return
|
|
}
|
|
if b.itemType == itemTypeMIME {
|
|
// XXX(Kagami): Skip content_encoding if it's empty?
|
|
err = writeBE(w, []byte(b.contentType), []byte{0}, []byte(b.contentEncoding), []byte{0})
|
|
} else if b.itemType == itemTypeURI {
|
|
// XXX(Kagami): Shouldn't be null-terminated per spec?
|
|
err = writeBE(w, []byte(b.itemURIType))
|
|
}
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Item Properties Box
|
|
type boxIPRP struct {
|
|
box
|
|
propertyContainer boxIPCO
|
|
association boxIPMA
|
|
}
|
|
|
|
func (b *boxIPRP) Size() uint32 {
|
|
return b.box.Size() + b.propertyContainer.Size() + b.association.Size()
|
|
}
|
|
|
|
func (b *boxIPRP) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeIPRP
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeAll(w, &b.propertyContainer, &b.association)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Item Property Container Box
|
|
type boxIPCO struct {
|
|
box
|
|
properties []boxIPCOProperty
|
|
}
|
|
|
|
func (b *boxIPCO) Size() uint32 {
|
|
size := b.box.Size()
|
|
for _, p := range b.properties {
|
|
size += p.Size()
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (b *boxIPCO) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeIPCO
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
for _, p := range b.properties {
|
|
if _, err = p.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type boxIPCOProperty interface {
|
|
io.WriterTo
|
|
Size() uint32
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Image spatial extents
|
|
type boxISPE struct {
|
|
fullBox
|
|
imageWidth uint32
|
|
imageHeight uint32
|
|
}
|
|
|
|
func (b *boxISPE) Size() uint32 {
|
|
return b.fullBox.Size() + 4 /*image_width*/ + 4 /*image_height*/
|
|
}
|
|
|
|
func (b *boxISPE) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeISPE
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.imageWidth, b.imageHeight)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Pixel aspect ratio
|
|
type boxPASP struct {
|
|
box
|
|
hSpacing uint32
|
|
vSpacing uint32
|
|
}
|
|
|
|
func (b *boxPASP) Size() uint32 {
|
|
return b.box.Size() + 4 /*hSpacing*/ + 4 /*vSpacing*/
|
|
}
|
|
|
|
func (b *boxPASP) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypePASP
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = writeBE(w, b.hSpacing, b.vSpacing)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Pixel aspect ratio
|
|
type boxAV1C struct {
|
|
box
|
|
av1Config boxAV1CConfig
|
|
}
|
|
|
|
func (b *boxAV1C) Size() uint32 {
|
|
return b.box.Size() + 1 /*marker + version*/ + 1 /*seq_profile + seq_level_idx_0*/ +
|
|
// seq_tier_0 + high_bitdepth + twelve_bit + monochrome +
|
|
// chroma_subsampling_x + chroma_subsampling_y + chroma_sample_position
|
|
1 +
|
|
// reserved + initial_presentation_delay_present + initial_presentation_delay_minus_one/reserved
|
|
1 +
|
|
uint32(len(b.av1Config.configOBUs))
|
|
}
|
|
|
|
func (b *boxAV1C) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeAV1C
|
|
if _, err = b.box.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
err = b.av1Config.write(w)
|
|
return
|
|
}
|
|
|
|
type boxAV1CConfig struct {
|
|
marker bool
|
|
version uint8 // 7 bits
|
|
//---
|
|
seqProfile uint8 // 4 bits
|
|
seqLevelIdx0 uint8 // 4 bits
|
|
//---
|
|
seqTier0 bool
|
|
highBitdepth bool
|
|
twelveBit bool
|
|
monochrome bool
|
|
chromaSubsamplingX bool
|
|
chromaSubsamplingY bool
|
|
chromaSamplePosition uint8 // 2 bits
|
|
//---
|
|
reserved uint8 // 3 bits
|
|
initialPresentationDelayPresent bool
|
|
initialPresentationDelayMinusOne uint8 // 4 bits
|
|
reserved2 uint8 // 4 bits
|
|
//---
|
|
configOBUs []byte
|
|
}
|
|
|
|
func (c *boxAV1CConfig) write(w io.Writer) (err error) {
|
|
c.marker = true
|
|
c.version = 1
|
|
c.reserved = 0
|
|
c.reserved2 = 0
|
|
markerAndVersion := bflag(c.marker, 8) | (c.version & 0x7f)
|
|
seqProfileAndSeqLevelIdx0 := (c.seqProfile << 5) | (c.seqLevelIdx0 & 0x1f)
|
|
codecParams := bflag(c.seqTier0, 8) |
|
|
bflag(c.highBitdepth, 7) |
|
|
bflag(c.twelveBit, 6) |
|
|
bflag(c.monochrome, 5) |
|
|
bflag(c.chromaSubsamplingX, 4) |
|
|
bflag(c.chromaSubsamplingY, 3) |
|
|
(c.chromaSamplePosition & 3)
|
|
presentationParams := (c.reserved << 5) | bflag(c.initialPresentationDelayPresent, 4)
|
|
if c.initialPresentationDelayPresent {
|
|
presentationParams |= c.initialPresentationDelayMinusOne & 0xf
|
|
} else {
|
|
presentationParams |= c.reserved2 & 0xf
|
|
}
|
|
err = writeBE(w, markerAndVersion, seqProfileAndSeqLevelIdx0, codecParams,
|
|
presentationParams)
|
|
if err != nil {
|
|
return
|
|
}
|
|
_, err = w.Write(c.configOBUs)
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Pixel information
|
|
type boxPIXI struct {
|
|
fullBox
|
|
numChannels uint8
|
|
bitsPerChannel []uint8
|
|
}
|
|
|
|
func (b *boxPIXI) Size() uint32 {
|
|
return b.fullBox.Size() + 1 /*num_channels*/ + uint32(len(b.bitsPerChannel))
|
|
}
|
|
|
|
func (b *boxPIXI) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypePIXI
|
|
b.numChannels = uint8(len(b.bitsPerChannel))
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
if err = writeBE(w, b.numChannels); err != nil {
|
|
return
|
|
}
|
|
for _, bpc := range b.bitsPerChannel {
|
|
if err = writeBE(w, bpc); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Item Property Association
|
|
type boxIPMA struct {
|
|
fullBox
|
|
entryCount uint32
|
|
entries []boxIPMAAssociation
|
|
}
|
|
|
|
func (b *boxIPMA) Size() uint32 {
|
|
propSize := 1
|
|
if b.flags&1 == 1 {
|
|
propSize = 2
|
|
}
|
|
size := b.fullBox.Size() + 4 /*entry_count*/
|
|
for _, a := range b.entries {
|
|
size += 2 /*item_ID*/ + 1 /*association_count*/ +
|
|
uint32(len(a.props))*uint32(propSize)
|
|
}
|
|
return size
|
|
}
|
|
|
|
func (b *boxIPMA) WriteTo(w io.Writer) (n int64, err error) {
|
|
b.size = b.Size()
|
|
b.typ = boxTypeIPMA
|
|
b.entryCount = uint32(len(b.entries))
|
|
if _, err = b.fullBox.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
if err = writeBE(w, b.entryCount); err != nil {
|
|
return
|
|
}
|
|
for _, a := range b.entries {
|
|
if err = a.write(w, b.flags); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type boxIPMAAssociation struct {
|
|
itemID uint16
|
|
associationCount uint8
|
|
props []boxIPMAAssociationProperty
|
|
}
|
|
|
|
func (a *boxIPMAAssociation) write(w io.Writer, flags uint32) (err error) {
|
|
// TODO(Kagami): Make sure slice length isn't overflowed?
|
|
a.associationCount = uint8(len(a.props))
|
|
if err = writeBE(w, a.itemID, a.associationCount); err != nil {
|
|
return
|
|
}
|
|
for _, p := range a.props {
|
|
if err = p.write(w, flags); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
type boxIPMAAssociationProperty struct {
|
|
essential bool
|
|
propertyIndex uint16 // 7 or 15 bits
|
|
}
|
|
|
|
func (p *boxIPMAAssociationProperty) write(w io.Writer, flags uint32) (err error) {
|
|
essential := 0
|
|
if p.essential {
|
|
essential = 1
|
|
}
|
|
if flags&1 == 1 {
|
|
v := (p.propertyIndex & 0x7fff) | uint16(essential<<15)
|
|
err = writeBE(w, v)
|
|
} else {
|
|
v := uint8(p.propertyIndex&0x7f) | uint8(essential<<7)
|
|
err = writeBE(w, v)
|
|
}
|
|
return
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
func getSubsamplingXY(subsampling image.YCbCrSubsampleRatio) (x bool, y bool) {
|
|
switch subsampling {
|
|
case image.YCbCrSubsampleRatio420:
|
|
return true, true
|
|
case image.YCbCrSubsampleRatio422:
|
|
return true, false
|
|
case image.YCbCrSubsampleRatio444:
|
|
return false, false
|
|
}
|
|
return
|
|
}
|
|
|
|
func muxFrame(w io.Writer, m image.Image, subsampling image.YCbCrSubsampleRatio, obuData []byte) (err error) {
|
|
// TODO(Kagami): Parse params from Sequence Header OBU instead?
|
|
rec := m.Bounds()
|
|
width := uint32(rec.Max.X - rec.Min.X)
|
|
height := uint32(rec.Max.Y - rec.Min.Y)
|
|
sx, sy := getSubsamplingXY(subsampling)
|
|
|
|
fileData := boxMDAT{data: obuData}
|
|
fileType := boxFTYP{
|
|
majorBrand: itemTypeAVIF,
|
|
compatibleBrands: []fourCC{itemTypeMIF1, itemTypeAVIF, itemTypeMIAF},
|
|
}
|
|
metadata := boxMETA{
|
|
theHandler: boxHDLR{
|
|
handlerType: itemTypePICT,
|
|
name: "tulpa.dev/cadey/avif v0",
|
|
},
|
|
primaryResource: boxPITM{itemID: 1},
|
|
itemLocations: boxILOC{
|
|
// NOTE(Kagami): We predefine location item even while we don't
|
|
// know corrent offsets yet in order to fix them in place later.
|
|
// It's needed because meta box goes before mdat box therefore
|
|
// size of the metadata can't change. We only use baseOffset and
|
|
// extentLength so occupy 32-bit storage space for them. They're
|
|
// unlikely to overflow (>4GB image is not practical).
|
|
lengthSize: 4,
|
|
baseOffsetSize: 4,
|
|
items: []boxILOCItem{
|
|
boxILOCItem{
|
|
itemID: 1,
|
|
extents: []boxILOCItemExtent{{}},
|
|
},
|
|
},
|
|
},
|
|
itemInfos: boxIINF{
|
|
itemInfos: []boxINFEv2{
|
|
boxINFEv2{
|
|
itemID: 1,
|
|
itemType: itemTypeAV01,
|
|
itemName: "Image",
|
|
},
|
|
},
|
|
},
|
|
itemProps: boxIPRP{
|
|
propertyContainer: boxIPCO{
|
|
properties: []boxIPCOProperty{
|
|
&boxISPE{imageWidth: width, imageHeight: height},
|
|
&boxPASP{hSpacing: 1, vSpacing: 1},
|
|
&boxAV1C{
|
|
// Only 8-bit at the moment.
|
|
av1Config: boxAV1CConfig{
|
|
chromaSubsamplingX: sx,
|
|
chromaSubsamplingY: sy,
|
|
},
|
|
},
|
|
&boxPIXI{bitsPerChannel: []uint8{8, 8, 8}},
|
|
},
|
|
},
|
|
association: boxIPMA{
|
|
entries: []boxIPMAAssociation{
|
|
boxIPMAAssociation{
|
|
itemID: 1,
|
|
props: []boxIPMAAssociationProperty{
|
|
{false, 1}, // non-essential width/height
|
|
{false, 2}, // non-essential aspect ratio
|
|
{true, 3}, // essential AV1 config
|
|
{true, 4}, // essential bitdepth
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
// Can fix iloc offsets now.
|
|
locItem := &metadata.itemLocations.items[0]
|
|
locItem.baseOffset = uint64(fileType.Size() + metadata.Size() + fileData.box.Size())
|
|
locItem.extents[0].extentLength = uint64(len(fileData.data))
|
|
|
|
err = writeAll(w, &fileType, &metadata, &fileData)
|
|
return
|
|
}
|