// Copyright 2019 Joe Drago. All rights reserved. // SPDX-License-Identifier: BSD-2-Clause #include "avif/internal.h" #include #include #include #include #include #define AUXTYPE_SIZE 64 #define CONTENTTYPE_SIZE 64 // class VisualSampleEntry(codingname) extends SampleEntry(codingname) { // unsigned int(16) pre_defined = 0; // const unsigned int(16) reserved = 0; // unsigned int(32)[3] pre_defined = 0; // unsigned int(16) width; // unsigned int(16) height; // template unsigned int(32) horizresolution = 0x00480000; // 72 dpi // template unsigned int(32) vertresolution = 0x00480000; // 72 dpi // const unsigned int(32) reserved = 0; // template unsigned int(16) frame_count = 1; // string[32] compressorname; // template unsigned int(16) depth = 0x0018; // int(16) pre_defined = -1; // // other boxes from derived specifications // CleanApertureBox clap; // optional // PixelAspectRatioBox pasp; // optional // } static const size_t VISUALSAMPLEENTRY_SIZE = 78; static const char xmpContentType[] = AVIF_CONTENT_TYPE_XMP; static const size_t xmpContentTypeSize = sizeof(xmpContentType); // The only supported ipma box values for both version and flags are [0,1], so there technically // can't be more than 4 unique tuples right now. #define MAX_IPMA_VERSION_AND_FLAGS_SEEN 4 // --------------------------------------------------------------------------- // AVIF codec type (AV1 or AV2) static avifCodecType avifGetCodecType(const uint8_t * fourcc) { if (!memcmp(fourcc, "av01", 4)) { return AVIF_CODEC_TYPE_AV1; } #if defined(AVIF_CODEC_AVM) if (!memcmp(fourcc, "av02", 4)) { return AVIF_CODEC_TYPE_AV2; } #endif return AVIF_CODEC_TYPE_UNKNOWN; } static const char * avifGetConfigurationPropertyName(avifCodecType codecType) { switch (codecType) { case AVIF_CODEC_TYPE_AV1: return "av1C"; #if defined(AVIF_CODEC_AVM) case AVIF_CODEC_TYPE_AV2: return "av2C"; #endif default: assert(AVIF_FALSE); return NULL; } } // --------------------------------------------------------------------------- // Box data structures // ftyp typedef struct avifFileType { uint8_t majorBrand[4]; uint32_t minorVersion; // If not null, points to a memory block of 4 * compatibleBrandsCount bytes. const uint8_t * compatibleBrands; int compatibleBrandsCount; } avifFileType; // ispe typedef struct avifImageSpatialExtents { uint32_t width; uint32_t height; } avifImageSpatialExtents; // auxC typedef struct avifAuxiliaryType { char auxType[AUXTYPE_SIZE]; } avifAuxiliaryType; // infe mime content_type typedef struct avifContentType { char contentType[CONTENTTYPE_SIZE]; } avifContentType; // colr typedef struct avifColourInformationBox { avifBool hasICC; uint64_t iccOffset; size_t iccSize; avifBool hasNCLX; avifColorPrimaries colorPrimaries; avifTransferCharacteristics transferCharacteristics; avifMatrixCoefficients matrixCoefficients; avifRange range; } avifColourInformationBox; #define MAX_PIXI_PLANE_DEPTHS 4 typedef struct avifPixelInformationProperty { uint8_t planeDepths[MAX_PIXI_PLANE_DEPTHS]; uint8_t planeCount; } avifPixelInformationProperty; typedef struct avifOperatingPointSelectorProperty { uint8_t opIndex; } avifOperatingPointSelectorProperty; typedef struct avifLayerSelectorProperty { uint16_t layerID; } avifLayerSelectorProperty; typedef struct avifAV1LayeredImageIndexingProperty { uint32_t layerSize[3]; } avifAV1LayeredImageIndexingProperty; // --------------------------------------------------------------------------- // Top-level structures struct avifMeta; // Temporary storage for ipco/stsd contents until they can be associated and memcpy'd to an avifDecoderItem typedef struct avifProperty { uint8_t type[4]; union { avifImageSpatialExtents ispe; avifAuxiliaryType auxC; avifColourInformationBox colr; avifCodecConfigurationBox av1C; // TODO(yguyon): Rename or add av2C avifPixelAspectRatioBox pasp; avifCleanApertureBox clap; avifImageRotation irot; avifImageMirror imir; avifPixelInformationProperty pixi; avifOperatingPointSelectorProperty a1op; avifLayerSelectorProperty lsel; avifAV1LayeredImageIndexingProperty a1lx; avifContentLightLevelInformationBox clli; } u; } avifProperty; AVIF_ARRAY_DECLARE(avifPropertyArray, avifProperty, prop); static const avifProperty * avifPropertyArrayFind(const avifPropertyArray * properties, const char * type) { for (uint32_t propertyIndex = 0; propertyIndex < properties->count; ++propertyIndex) { avifProperty * prop = &properties->prop[propertyIndex]; if (!memcmp(prop->type, type, 4)) { return prop; } } return NULL; } AVIF_ARRAY_DECLARE(avifExtentArray, avifExtent, extent); // one "item" worth for decoding (all iref, iloc, iprp, etc refer to one of these) typedef struct avifDecoderItem { uint32_t id; struct avifMeta * meta; // Unowned; A back-pointer for convenience uint8_t type[4]; size_t size; avifBool idatStored; // If true, offset is relative to the associated meta box's idat box (iloc construction_method==1) uint32_t width; // Set from this item's ispe property, if present uint32_t height; // Set from this item's ispe property, if present avifContentType contentType; avifPropertyArray properties; avifExtentArray extents; // All extent offsets/sizes avifRWData mergedExtents; // if set, is a single contiguous block of this item's extents (unused when extents.count == 1) avifBool ownsMergedExtents; // if true, mergedExtents must be freed when this item is destroyed avifBool partialMergedExtents; // If true, mergedExtents doesn't have all of the item data yet uint32_t thumbnailForID; // if non-zero, this item is a thumbnail for Item #{thumbnailForID} uint32_t auxForID; // if non-zero, this item is an auxC plane for Item #{auxForID} uint32_t descForID; // if non-zero, this item is a content description for Item #{descForID} uint32_t dimgForID; // if non-zero, this item is a derived image for Item #{dimgForID} uint32_t premByID; // if non-zero, this item is premultiplied by Item #{premByID} avifBool hasUnsupportedEssentialProperty; // If true, this item cites a property flagged as 'essential' that libavif doesn't support (yet). Ignore the item, if so. avifBool ipmaSeen; // if true, this item already received a property association avifBool progressive; // if true, this item has progressive layers (a1lx), but does not select a specific layer (the layer_id value in lsel is set to 0xFFFF) } avifDecoderItem; AVIF_ARRAY_DECLARE(avifDecoderItemArray, avifDecoderItem, item); // grid storage typedef struct avifImageGrid { uint32_t rows; // Legal range: [1-256] uint32_t columns; // Legal range: [1-256] uint32_t outputWidth; uint32_t outputHeight; } avifImageGrid; // --------------------------------------------------------------------------- // avifTrack typedef struct avifSampleTableChunk { uint64_t offset; } avifSampleTableChunk; AVIF_ARRAY_DECLARE(avifSampleTableChunkArray, avifSampleTableChunk, chunk); typedef struct avifSampleTableSampleToChunk { uint32_t firstChunk; uint32_t samplesPerChunk; uint32_t sampleDescriptionIndex; } avifSampleTableSampleToChunk; AVIF_ARRAY_DECLARE(avifSampleTableSampleToChunkArray, avifSampleTableSampleToChunk, sampleToChunk); typedef struct avifSampleTableSampleSize { uint32_t size; } avifSampleTableSampleSize; AVIF_ARRAY_DECLARE(avifSampleTableSampleSizeArray, avifSampleTableSampleSize, sampleSize); typedef struct avifSampleTableTimeToSample { uint32_t sampleCount; uint32_t sampleDelta; } avifSampleTableTimeToSample; AVIF_ARRAY_DECLARE(avifSampleTableTimeToSampleArray, avifSampleTableTimeToSample, timeToSample); typedef struct avifSyncSample { uint32_t sampleNumber; } avifSyncSample; AVIF_ARRAY_DECLARE(avifSyncSampleArray, avifSyncSample, syncSample); typedef struct avifSampleDescription { uint8_t format[4]; avifPropertyArray properties; } avifSampleDescription; AVIF_ARRAY_DECLARE(avifSampleDescriptionArray, avifSampleDescription, description); typedef struct avifSampleTable { avifSampleTableChunkArray chunks; avifSampleDescriptionArray sampleDescriptions; avifSampleTableSampleToChunkArray sampleToChunks; avifSampleTableSampleSizeArray sampleSizes; avifSampleTableTimeToSampleArray timeToSamples; avifSyncSampleArray syncSamples; uint32_t allSamplesSize; // If this is non-zero, sampleSizes will be empty and all samples will be this size } avifSampleTable; static void avifSampleTableDestroy(avifSampleTable * sampleTable); static avifSampleTable * avifSampleTableCreate() { avifSampleTable * sampleTable = (avifSampleTable *)avifAlloc(sizeof(avifSampleTable)); memset(sampleTable, 0, sizeof(avifSampleTable)); if (!avifArrayCreate(&sampleTable->chunks, sizeof(avifSampleTableChunk), 16)) { goto error; } if (!avifArrayCreate(&sampleTable->sampleDescriptions, sizeof(avifSampleDescription), 2)) { goto error; } if (!avifArrayCreate(&sampleTable->sampleToChunks, sizeof(avifSampleTableSampleToChunk), 16)) { goto error; } if (!avifArrayCreate(&sampleTable->sampleSizes, sizeof(avifSampleTableSampleSize), 16)) { goto error; } if (!avifArrayCreate(&sampleTable->timeToSamples, sizeof(avifSampleTableTimeToSample), 16)) { goto error; } if (!avifArrayCreate(&sampleTable->syncSamples, sizeof(avifSyncSample), 16)) { goto error; } return sampleTable; error: avifSampleTableDestroy(sampleTable); return NULL; } static void avifSampleTableDestroy(avifSampleTable * sampleTable) { avifArrayDestroy(&sampleTable->chunks); for (uint32_t i = 0; i < sampleTable->sampleDescriptions.count; ++i) { avifSampleDescription * description = &sampleTable->sampleDescriptions.description[i]; avifArrayDestroy(&description->properties); } avifArrayDestroy(&sampleTable->sampleDescriptions); avifArrayDestroy(&sampleTable->sampleToChunks); avifArrayDestroy(&sampleTable->sampleSizes); avifArrayDestroy(&sampleTable->timeToSamples); avifArrayDestroy(&sampleTable->syncSamples); avifFree(sampleTable); } static uint32_t avifSampleTableGetImageDelta(const avifSampleTable * sampleTable, int imageIndex) { int maxSampleIndex = 0; for (uint32_t i = 0; i < sampleTable->timeToSamples.count; ++i) { const avifSampleTableTimeToSample * timeToSample = &sampleTable->timeToSamples.timeToSample[i]; maxSampleIndex += timeToSample->sampleCount; if ((imageIndex < maxSampleIndex) || (i == (sampleTable->timeToSamples.count - 1))) { return timeToSample->sampleDelta; } } // TODO: fail here? return 1; } static avifCodecType avifSampleTableGetCodecType(const avifSampleTable * sampleTable) { for (uint32_t i = 0; i < sampleTable->sampleDescriptions.count; ++i) { const avifCodecType codecType = avifGetCodecType(sampleTable->sampleDescriptions.description[i].format); if (codecType != AVIF_CODEC_TYPE_UNKNOWN) { return codecType; } } return AVIF_CODEC_TYPE_UNKNOWN; } static uint32_t avifCodecConfigurationBoxGetDepth(const avifCodecConfigurationBox * av1C) { if (av1C->twelveBit) { return 12; } else if (av1C->highBitdepth) { return 10; } return 8; } // This is used as a hint to validating the clap box in avifDecoderItemValidateProperties. static avifPixelFormat avifCodecConfigurationBoxGetFormat(const avifCodecConfigurationBox * av1C) { if (av1C->monochrome) { return AVIF_PIXEL_FORMAT_YUV400; } else if (av1C->chromaSubsamplingY == 1) { return AVIF_PIXEL_FORMAT_YUV420; } else if (av1C->chromaSubsamplingX == 1) { return AVIF_PIXEL_FORMAT_YUV422; } return AVIF_PIXEL_FORMAT_YUV444; } static const avifPropertyArray * avifSampleTableGetProperties(const avifSampleTable * sampleTable, avifCodecType codecType) { for (uint32_t i = 0; i < sampleTable->sampleDescriptions.count; ++i) { const avifSampleDescription * description = &sampleTable->sampleDescriptions.description[i]; if (avifGetCodecType(description->format) == codecType) { return &description->properties; } } return NULL; } // one video track ("trak" contents) typedef struct avifTrack { uint32_t id; uint32_t auxForID; // if non-zero, this track is an auxC plane for Track #{auxForID} uint32_t premByID; // if non-zero, this track is premultiplied by Track #{premByID} uint32_t mediaTimescale; uint64_t mediaDuration; uint64_t trackDuration; uint64_t segmentDuration; avifBool isRepeating; int repetitionCount; uint32_t width; uint32_t height; avifSampleTable * sampleTable; struct avifMeta * meta; } avifTrack; AVIF_ARRAY_DECLARE(avifTrackArray, avifTrack, track); // --------------------------------------------------------------------------- // avifCodecDecodeInput avifCodecDecodeInput * avifCodecDecodeInputCreate(void) { avifCodecDecodeInput * decodeInput = (avifCodecDecodeInput *)avifAlloc(sizeof(avifCodecDecodeInput)); memset(decodeInput, 0, sizeof(avifCodecDecodeInput)); if (!avifArrayCreate(&decodeInput->samples, sizeof(avifDecodeSample), 1)) { goto error; } return decodeInput; error: avifFree(decodeInput); return NULL; } void avifCodecDecodeInputDestroy(avifCodecDecodeInput * decodeInput) { for (uint32_t sampleIndex = 0; sampleIndex < decodeInput->samples.count; ++sampleIndex) { avifDecodeSample * sample = &decodeInput->samples.sample[sampleIndex]; if (sample->ownsData) { avifRWDataFree((avifRWData *)&sample->data); } } avifArrayDestroy(&decodeInput->samples); avifFree(decodeInput); } // Returns how many samples are in the chunk. static uint32_t avifGetSampleCountOfChunk(const avifSampleTableSampleToChunkArray * sampleToChunks, uint32_t chunkIndex) { uint32_t sampleCount = 0; for (int sampleToChunkIndex = sampleToChunks->count - 1; sampleToChunkIndex >= 0; --sampleToChunkIndex) { const avifSampleTableSampleToChunk * sampleToChunk = &sampleToChunks->sampleToChunk[sampleToChunkIndex]; if (sampleToChunk->firstChunk <= (chunkIndex + 1)) { sampleCount = sampleToChunk->samplesPerChunk; break; } } return sampleCount; } static avifBool avifCodecDecodeInputFillFromSampleTable(avifCodecDecodeInput * decodeInput, avifSampleTable * sampleTable, const uint32_t imageCountLimit, const uint64_t sizeHint, avifDiagnostics * diag) { if (imageCountLimit) { // Verify that the we're not about to exceed the frame count limit. uint32_t imageCountLeft = imageCountLimit; for (uint32_t chunkIndex = 0; chunkIndex < sampleTable->chunks.count; ++chunkIndex) { // First, figure out how many samples are in this chunk uint32_t sampleCount = avifGetSampleCountOfChunk(&sampleTable->sampleToChunks, chunkIndex); if (sampleCount == 0) { // chunks with 0 samples are invalid avifDiagnosticsPrintf(diag, "Sample table contains a chunk with 0 samples"); return AVIF_FALSE; } if (sampleCount > imageCountLeft) { // This file exceeds the imageCountLimit, bail out avifDiagnosticsPrintf(diag, "Exceeded avifDecoder's imageCountLimit"); return AVIF_FALSE; } imageCountLeft -= sampleCount; } } uint32_t sampleSizeIndex = 0; for (uint32_t chunkIndex = 0; chunkIndex < sampleTable->chunks.count; ++chunkIndex) { avifSampleTableChunk * chunk = &sampleTable->chunks.chunk[chunkIndex]; // First, figure out how many samples are in this chunk uint32_t sampleCount = avifGetSampleCountOfChunk(&sampleTable->sampleToChunks, chunkIndex); if (sampleCount == 0) { // chunks with 0 samples are invalid avifDiagnosticsPrintf(diag, "Sample table contains a chunk with 0 samples"); return AVIF_FALSE; } uint64_t sampleOffset = chunk->offset; for (uint32_t sampleIndex = 0; sampleIndex < sampleCount; ++sampleIndex) { uint32_t sampleSize = sampleTable->allSamplesSize; if (sampleSize == 0) { if (sampleSizeIndex >= sampleTable->sampleSizes.count) { // We've run out of samples to sum avifDiagnosticsPrintf(diag, "Truncated sample table"); return AVIF_FALSE; } avifSampleTableSampleSize * sampleSizePtr = &sampleTable->sampleSizes.sampleSize[sampleSizeIndex]; sampleSize = sampleSizePtr->size; } avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&decodeInput->samples); sample->offset = sampleOffset; sample->size = sampleSize; sample->spatialID = AVIF_SPATIAL_ID_UNSET; // Not filtering by spatial_id sample->sync = AVIF_FALSE; // to potentially be set to true following the outer loop if (sampleSize > UINT64_MAX - sampleOffset) { avifDiagnosticsPrintf(diag, "Sample table contains an offset/size pair which overflows: [%" PRIu64 " / %u]", sampleOffset, sampleSize); return AVIF_FALSE; } if (sizeHint && ((sampleOffset + sampleSize) > sizeHint)) { avifDiagnosticsPrintf(diag, "Exceeded avifIO's sizeHint, possibly truncated data"); return AVIF_FALSE; } sampleOffset += sampleSize; ++sampleSizeIndex; } } // Mark appropriate samples as sync for (uint32_t syncSampleIndex = 0; syncSampleIndex < sampleTable->syncSamples.count; ++syncSampleIndex) { uint32_t frameIndex = sampleTable->syncSamples.syncSample[syncSampleIndex].sampleNumber - 1; // sampleNumber is 1-based if (frameIndex < decodeInput->samples.count) { decodeInput->samples.sample[frameIndex].sync = AVIF_TRUE; } } // Assume frame 0 is sync, just in case the stss box is absent in the BMFF. (Unnecessary?) if (decodeInput->samples.count > 0) { decodeInput->samples.sample[0].sync = AVIF_TRUE; } return AVIF_TRUE; } static avifBool avifCodecDecodeInputFillFromDecoderItem(avifCodecDecodeInput * decodeInput, avifDecoderItem * item, avifBool allowProgressive, const uint32_t imageCountLimit, const uint64_t sizeHint, avifDiagnostics * diag) { if (sizeHint && (item->size > sizeHint)) { avifDiagnosticsPrintf(diag, "Exceeded avifIO's sizeHint, possibly truncated data"); return AVIF_FALSE; } uint8_t layerCount = 0; size_t layerSizes[4] = { 0 }; const avifProperty * a1lxProp = avifPropertyArrayFind(&item->properties, "a1lx"); if (a1lxProp) { // Calculate layer count and all layer sizes from the a1lx box, and then validate size_t remainingSize = item->size; for (int i = 0; i < 3; ++i) { ++layerCount; const size_t layerSize = (size_t)a1lxProp->u.a1lx.layerSize[i]; if (layerSize) { if (layerSize >= remainingSize) { // >= instead of > because there must be room for the last layer avifDiagnosticsPrintf(diag, "a1lx layer index [%d] does not fit in item size", i); return AVIF_FALSE; } layerSizes[i] = layerSize; remainingSize -= layerSize; } else { layerSizes[i] = remainingSize; remainingSize = 0; break; } } if (remainingSize > 0) { assert(layerCount == 3); ++layerCount; layerSizes[3] = remainingSize; } } const avifProperty * lselProp = avifPropertyArrayFind(&item->properties, "lsel"); // Progressive images offer layers via the a1lxProp, but don't specify a layer selection with lsel. // // For backward compatibility with earlier drafts of AVIF spec v1.1.0, treat an absent lsel as // equivalent to layer_id == 0xFFFF during the transitional period. Remove !lselProp when the test // images have been updated to the v1.1.0 spec. item->progressive = (a1lxProp && (!lselProp || (lselProp->u.lsel.layerID == 0xFFFF))); if (lselProp && (lselProp->u.lsel.layerID != 0xFFFF)) { // Layer selection. This requires that the underlying AV1 codec decodes all layers, // and then only returns the requested layer as a single frame. To the user of libavif, // this appears to be a single frame. decodeInput->allLayers = AVIF_TRUE; size_t sampleSize = 0; if (layerCount > 0) { // Optimization: If we're selecting a layer that doesn't require the entire image's payload (hinted via the a1lx box) if (lselProp->u.lsel.layerID >= layerCount) { avifDiagnosticsPrintf(diag, "lsel property requests layer index [%u] which isn't present in a1lx property ([%u] layers)", lselProp->u.lsel.layerID, layerCount); return AVIF_FALSE; } for (uint8_t i = 0; i <= lselProp->u.lsel.layerID; ++i) { sampleSize += layerSizes[i]; } } else { // This layer's payload subsection is unknown, just use the whole payload sampleSize = item->size; } avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&decodeInput->samples); sample->itemID = item->id; sample->offset = 0; sample->size = sampleSize; assert(lselProp->u.lsel.layerID < AVIF_MAX_AV1_LAYER_COUNT); sample->spatialID = (uint8_t)lselProp->u.lsel.layerID; sample->sync = AVIF_TRUE; } else if (allowProgressive && item->progressive) { // Progressive image. Decode all layers and expose them all to the user. if (imageCountLimit && (layerCount > imageCountLimit)) { avifDiagnosticsPrintf(diag, "Exceeded avifDecoder's imageCountLimit (progressive)"); return AVIF_FALSE; } decodeInput->allLayers = AVIF_TRUE; size_t offset = 0; for (int i = 0; i < layerCount; ++i) { avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&decodeInput->samples); sample->itemID = item->id; sample->offset = offset; sample->size = layerSizes[i]; sample->spatialID = AVIF_SPATIAL_ID_UNSET; sample->sync = (i == 0); // Assume all layers depend on the first layer offset += layerSizes[i]; } } else { // Typical case: Use the entire item's payload for a single frame output avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&decodeInput->samples); sample->itemID = item->id; sample->offset = 0; sample->size = item->size; sample->spatialID = AVIF_SPATIAL_ID_UNSET; sample->sync = AVIF_TRUE; } return AVIF_TRUE; } // --------------------------------------------------------------------------- // Helper macros / functions #define BEGIN_STREAM(VARNAME, PTR, SIZE, DIAG, CONTEXT) \ avifROStream VARNAME; \ avifROData VARNAME##_roData; \ VARNAME##_roData.data = PTR; \ VARNAME##_roData.size = SIZE; \ avifROStreamStart(&VARNAME, &VARNAME##_roData, DIAG, CONTEXT) // Use this to keep track of whether or not a child box that must be unique (0 or 1 present) has // been seen yet, when parsing a parent box. If the "seen" bit is already set for a given box when // it is encountered during parse, an error is thrown. Which bit corresponds to which box is // dictated entirely by the calling function. static avifBool uniqueBoxSeen(uint32_t * uniqueBoxFlags, uint32_t whichFlag, const char * parentBoxType, const char * boxType, avifDiagnostics * diagnostics) { const uint32_t flag = 1 << whichFlag; if (*uniqueBoxFlags & flag) { // This box has already been seen. Error! avifDiagnosticsPrintf(diagnostics, "Box[%s] contains a duplicate unique box of type '%s'", parentBoxType, boxType); return AVIF_FALSE; } // Mark this box as seen. *uniqueBoxFlags |= flag; return AVIF_TRUE; } // --------------------------------------------------------------------------- // avifDecoderData typedef struct avifTile { avifCodecDecodeInput * input; avifCodecType codecType; // This may point to a codec that it owns or point to a shared codec that it does not own. In the shared case, this will // point to one of avifDecoderData.codec or avifDecoderData.codecAlpha. struct avifCodec * codec; avifImage * image; uint32_t width; // Either avifTrack.width or avifDecoderItem.width uint32_t height; // Either avifTrack.height or avifDecoderItem.height uint8_t operatingPoint; } avifTile; AVIF_ARRAY_DECLARE(avifTileArray, avifTile, tile); // This holds one "meta" box (from the BMFF and HEIF standards) worth of relevant-to-AVIF information. // * If a meta box is parsed from the root level of the BMFF, it can contain the information about // "items" which might be color planes, alpha planes, or EXIF or XMP metadata. // * If a meta box is parsed from inside of a track ("trak") box, any metadata (EXIF/XMP) items inside // of that box are implicitly associated with that track. typedef struct avifMeta { // Items (from HEIF) are the generic storage for any data that does not require timed processing // (single image color planes, alpha planes, EXIF, XMP, etc). Each item has a unique integer ID >1, // and is defined by a series of child boxes in a meta box: // * iloc - location: byte offset to item data, item size in bytes // * iinf - information: type of item (color planes, alpha plane, EXIF, XMP) // * ipco - properties: dimensions, aspect ratio, image transformations, references to other items // * ipma - associations: Attaches an item in the properties list to a given item // // Items are lazily created in this array when any of the above boxes refer to one by a new (unseen) ID, // and are then further modified/updated as new information for an item's ID is parsed. avifDecoderItemArray items; // Any ipco boxes explained above are populated into this array as a staging area, which are // then duplicated into the appropriate items upon encountering an item property association // (ipma) box. avifPropertyArray properties; // Filled with the contents of this meta box's "idat" box, which is raw data that an item can // directly refer to in its item location box (iloc) instead of just giving an offset into the // overall file. If all items' iloc boxes simply point at an offset/length in the file itself, // this buffer will likely be empty. avifRWData idat; // Ever-incrementing ID for uniquely identifying which 'meta' box contains an idat (when // multiple meta boxes exist as BMFF siblings). Each time avifParseMetaBox() is called on an // avifMeta struct, this value is incremented. Any time an additional meta box is detected at // the same "level" (root level, trak level, etc), this ID helps distinguish which meta box's // "idat" is which, as items implicitly reference idat boxes that exist in the same meta // box. uint32_t idatID; // Contents of a pitm box, which signal which of the items in this file is the main image. For // AVIF, this should point at an image item containing color planes, and all other items // are ignored unless they refer to this item in some way (alpha plane, EXIF/XMP metadata). uint32_t primaryItemID; } avifMeta; static void avifMetaDestroy(avifMeta * meta); static avifMeta * avifMetaCreate() { avifMeta * meta = (avifMeta *)avifAlloc(sizeof(avifMeta)); memset(meta, 0, sizeof(avifMeta)); if (!avifArrayCreate(&meta->items, sizeof(avifDecoderItem), 8)) { goto error; } if (!avifArrayCreate(&meta->properties, sizeof(avifProperty), 16)) { goto error; } return meta; error: avifMetaDestroy(meta); return NULL; } static void avifMetaDestroy(avifMeta * meta) { for (uint32_t i = 0; i < meta->items.count; ++i) { avifDecoderItem * item = &meta->items.item[i]; avifArrayDestroy(&item->properties); avifArrayDestroy(&item->extents); if (item->ownsMergedExtents) { avifRWDataFree(&item->mergedExtents); } } avifArrayDestroy(&meta->items); avifArrayDestroy(&meta->properties); avifRWDataFree(&meta->idat); avifFree(meta); } static avifDecoderItem * avifMetaFindItem(avifMeta * meta, uint32_t itemID) { if (itemID == 0) { return NULL; } for (uint32_t i = 0; i < meta->items.count; ++i) { if (meta->items.item[i].id == itemID) { return &meta->items.item[i]; } } avifDecoderItem * item = (avifDecoderItem *)avifArrayPushPtr(&meta->items); if (!avifArrayCreate(&item->properties, sizeof(avifProperty), 16)) { goto error; } if (!avifArrayCreate(&item->extents, sizeof(avifExtent), 1)) { goto error; } item->id = itemID; item->meta = meta; return item; error: avifArrayDestroy(&item->extents); avifArrayDestroy(&item->properties); avifArrayPop(&meta->items); return NULL; } // A group of AVIF tiles in an image item, such as a single tile or a grid of multiple tiles. typedef struct avifTileInfo { unsigned int tileCount; unsigned int decodedTileCount; unsigned int firstTileIndex; // Within avifDecoderData.tiles. avifImageGrid grid; } avifTileInfo; typedef struct avifDecoderData { avifMeta * meta; // The root-level meta box avifTrackArray tracks; avifTileArray tiles; avifTileInfo color; avifTileInfo alpha; avifDecoderSource source; // When decoding AVIF images with grid, use a single decoder instance for all the tiles instead of creating a decoder instance // for each tile. If that is the case, |codec| will be used by all the tiles. // // There are some edge cases where we will still need multiple decoder instances: // * For animated AVIF with alpha, we will need two instances (one for the color planes and one for the alpha plane since they are both // encoded as separate video sequences). In this case, |codec| will be used for the color planes and |codecAlpha| will be // used for the alpha plane. // * For grid images with multiple layers. In this case, each tile will need its own decoder instance since there would be // multiple layers in each tile. In this case, |codec| and |codecAlpha| are not used and each tile will have its own // decoder instance. // * For grid images where the operating points of all the tiles are not the same. In this case, we each tile needs its own // decoder instance (same as above). avifCodec * codec; avifCodec * codecAlpha; uint8_t majorBrand[4]; // From the file's ftyp, used by AVIF_DECODER_SOURCE_AUTO avifDiagnostics * diag; // Shallow copy; owned by avifDecoder const avifSampleTable * sourceSampleTable; // NULL unless (source == AVIF_DECODER_SOURCE_TRACKS), owned by an avifTrack avifBool cicpSet; // True if avifDecoder's image has had its CICP set correctly yet. // This allows nclx colr boxes to override AV1 CICP, as specified in the MIAF // standard (ISO/IEC 23000-22:2019), section 7.3.6.4: // // "The colour information property takes precedence over any colour information in the image // bitstream, i.e. if the property is present, colour information in the bitstream shall be ignored." } avifDecoderData; static void avifDecoderDataDestroy(avifDecoderData * data); static avifDecoderData * avifDecoderDataCreate() { avifDecoderData * data = (avifDecoderData *)avifAlloc(sizeof(avifDecoderData)); memset(data, 0, sizeof(avifDecoderData)); data->meta = avifMetaCreate(); if (!avifArrayCreate(&data->tracks, sizeof(avifTrack), 2)) { goto error; } if (!avifArrayCreate(&data->tiles, sizeof(avifTile), 8)) { goto error; } return data; error: avifDecoderDataDestroy(data); return NULL; } static void avifDecoderDataResetCodec(avifDecoderData * data) { for (unsigned int i = 0; i < data->tiles.count; ++i) { avifTile * tile = &data->tiles.tile[i]; if (tile->image) { avifImageFreePlanes(tile->image, AVIF_PLANES_ALL); // forget any pointers into codec image buffers } if (tile->codec) { // Check if tile->codec was created separately and destroy it in that case. if (tile->codec != data->codec && tile->codec != data->codecAlpha) { avifCodecDestroy(tile->codec); } tile->codec = NULL; } } data->color.decodedTileCount = 0; data->alpha.decodedTileCount = 0; if (data->codec) { avifCodecDestroy(data->codec); data->codec = NULL; } if (data->codecAlpha) { avifCodecDestroy(data->codecAlpha); data->codecAlpha = NULL; } } static avifTile * avifDecoderDataCreateTile(avifDecoderData * data, avifCodecType codecType, uint32_t width, uint32_t height, uint8_t operatingPoint) { avifTile * tile = (avifTile *)avifArrayPushPtr(&data->tiles); tile->codecType = codecType; tile->image = avifImageCreateEmpty(); if (!tile->image) { goto error; } tile->input = avifCodecDecodeInputCreate(); if (!tile->input) { goto error; } tile->width = width; tile->height = height; tile->operatingPoint = operatingPoint; return tile; error: if (tile->input) { avifCodecDecodeInputDestroy(tile->input); } if (tile->image) { avifImageDestroy(tile->image); } avifArrayPop(&data->tiles); return NULL; } static avifTrack * avifDecoderDataCreateTrack(avifDecoderData * data) { avifTrack * track = (avifTrack *)avifArrayPushPtr(&data->tracks); track->meta = avifMetaCreate(); return track; } static void avifDecoderDataClearTiles(avifDecoderData * data) { for (unsigned int i = 0; i < data->tiles.count; ++i) { avifTile * tile = &data->tiles.tile[i]; if (tile->input) { avifCodecDecodeInputDestroy(tile->input); tile->input = NULL; } if (tile->codec) { // Check if tile->codec was created separately and destroy it in that case. if (tile->codec != data->codec && tile->codec != data->codecAlpha) { avifCodecDestroy(tile->codec); } tile->codec = NULL; } if (tile->image) { avifImageDestroy(tile->image); tile->image = NULL; } } data->tiles.count = 0; data->color.tileCount = 0; data->color.decodedTileCount = 0; data->alpha.tileCount = 0; data->alpha.decodedTileCount = 0; if (data->codec) { avifCodecDestroy(data->codec); data->codec = NULL; } if (data->codecAlpha) { avifCodecDestroy(data->codecAlpha); data->codecAlpha = NULL; } } static void avifDecoderDataDestroy(avifDecoderData * data) { avifMetaDestroy(data->meta); for (uint32_t i = 0; i < data->tracks.count; ++i) { avifTrack * track = &data->tracks.track[i]; if (track->sampleTable) { avifSampleTableDestroy(track->sampleTable); } if (track->meta) { avifMetaDestroy(track->meta); } } avifArrayDestroy(&data->tracks); avifDecoderDataClearTiles(data); avifArrayDestroy(&data->tiles); avifFree(data); } // This returns the max extent that has to be read in order to decode this item. If // the item is stored in an idat, the data has already been read during Parse() and // this function will return AVIF_RESULT_OK with a 0-byte extent. static avifResult avifDecoderItemMaxExtent(const avifDecoderItem * item, const avifDecodeSample * sample, avifExtent * outExtent) { if (item->extents.count == 0) { return AVIF_RESULT_TRUNCATED_DATA; } if (item->idatStored) { // construction_method: idat(1) if (item->meta->idat.size > 0) { // Already read from a meta box during Parse() memset(outExtent, 0, sizeof(avifExtent)); return AVIF_RESULT_OK; } // no associated idat box was found in the meta box, bail out return AVIF_RESULT_NO_CONTENT; } // construction_method: file(0) if (sample->size == 0) { return AVIF_RESULT_TRUNCATED_DATA; } uint64_t remainingOffset = sample->offset; size_t remainingBytes = sample->size; // This may be smaller than item->size if the item is progressive // Assert that the for loop below will execute at least one iteration. assert(item->extents.count != 0); uint64_t minOffset = UINT64_MAX; uint64_t maxOffset = 0; for (uint32_t extentIter = 0; extentIter < item->extents.count; ++extentIter) { avifExtent * extent = &item->extents.extent[extentIter]; // Make local copies of extent->offset and extent->size as they might need to be adjusted // due to the sample's offset. uint64_t startOffset = extent->offset; size_t extentSize = extent->size; if (remainingOffset) { if (remainingOffset >= extentSize) { remainingOffset -= extentSize; continue; } else { if (remainingOffset > UINT64_MAX - startOffset) { return AVIF_RESULT_BMFF_PARSE_FAILED; } startOffset += remainingOffset; extentSize -= (size_t)remainingOffset; remainingOffset = 0; } } const size_t usedExtentSize = (extentSize < remainingBytes) ? extentSize : remainingBytes; if (usedExtentSize > UINT64_MAX - startOffset) { return AVIF_RESULT_BMFF_PARSE_FAILED; } const uint64_t endOffset = startOffset + usedExtentSize; if (minOffset > startOffset) { minOffset = startOffset; } if (maxOffset < endOffset) { maxOffset = endOffset; } remainingBytes -= usedExtentSize; if (remainingBytes == 0) { // We've got enough bytes for this sample. break; } } if (remainingBytes != 0) { return AVIF_RESULT_TRUNCATED_DATA; } outExtent->offset = minOffset; const uint64_t extentLength = maxOffset - minOffset; if (extentLength > SIZE_MAX) { return AVIF_RESULT_BMFF_PARSE_FAILED; } outExtent->size = (size_t)extentLength; return AVIF_RESULT_OK; } static uint8_t avifDecoderItemOperatingPoint(const avifDecoderItem * item) { const avifProperty * a1opProp = avifPropertyArrayFind(&item->properties, "a1op"); if (a1opProp) { return a1opProp->u.a1op.opIndex; } return 0; // default } static avifResult avifDecoderItemValidateProperties(const avifDecoderItem * item, const char * configPropName, avifDiagnostics * diag, const avifStrictFlags strictFlags) { const avifProperty * configProp = avifPropertyArrayFind(&item->properties, configPropName); if (!configProp) { // An item configuration property box is mandatory in all valid AVIF configurations. Bail out. avifDiagnosticsPrintf(diag, "Item ID %u of type '%.4s' is missing mandatory %s property", item->id, (const char *)item->type, configPropName); return AVIF_RESULT_BMFF_PARSE_FAILED; } if (!memcmp(item->type, "grid", 4)) { for (uint32_t i = 0; i < item->meta->items.count; ++i) { avifDecoderItem * tile = &item->meta->items.item[i]; if (tile->dimgForID != item->id) { continue; } // Tile item types were checked in avifDecoderGenerateImageTiles(), no need to do it here. // MIAF (ISO 23000-22:2019), Section 7.3.11.4.1: // All input images of a grid image item shall use the same [...] chroma sampling format, // and the same decoder configuration (see 7.3.6.2). // The chroma sampling format is part of the decoder configuration. const avifProperty * tileConfigProp = avifPropertyArrayFind(&tile->properties, configPropName); if (!tileConfigProp) { avifDiagnosticsPrintf(diag, "Tile item ID %u of type '%.4s' is missing mandatory %s property", tile->id, (const char *)tile->type, configPropName); return AVIF_RESULT_BMFF_PARSE_FAILED; } // configProp was copied from a tile item to the grid item. Comparing tileConfigProp with it // is equivalent to comparing tileConfigProp with the configPropName from the first tile. if ((tileConfigProp->u.av1C.seqProfile != configProp->u.av1C.seqProfile) || (tileConfigProp->u.av1C.seqLevelIdx0 != configProp->u.av1C.seqLevelIdx0) || (tileConfigProp->u.av1C.seqTier0 != configProp->u.av1C.seqTier0) || (tileConfigProp->u.av1C.highBitdepth != configProp->u.av1C.highBitdepth) || (tileConfigProp->u.av1C.twelveBit != configProp->u.av1C.twelveBit) || (tileConfigProp->u.av1C.monochrome != configProp->u.av1C.monochrome) || (tileConfigProp->u.av1C.chromaSubsamplingX != configProp->u.av1C.chromaSubsamplingX) || (tileConfigProp->u.av1C.chromaSubsamplingY != configProp->u.av1C.chromaSubsamplingY) || (tileConfigProp->u.av1C.chromaSamplePosition != configProp->u.av1C.chromaSamplePosition)) { avifDiagnosticsPrintf(diag, "The fields of the %s property of tile item ID %u of type '%.4s' differs from other tiles", configPropName, tile->id, (const char *)tile->type); return AVIF_RESULT_BMFF_PARSE_FAILED; } } } const avifProperty * pixiProp = avifPropertyArrayFind(&item->properties, "pixi"); if (!pixiProp && (strictFlags & AVIF_STRICT_PIXI_REQUIRED)) { // A pixi box is mandatory in all valid AVIF configurations. Bail out. avifDiagnosticsPrintf(diag, "[Strict] Item ID %u of type '%.4s' is missing mandatory pixi property", item->id, (const char *)item->type); return AVIF_RESULT_BMFF_PARSE_FAILED; } if (pixiProp) { const uint32_t configDepth = avifCodecConfigurationBoxGetDepth(&configProp->u.av1C); for (uint8_t i = 0; i < pixiProp->u.pixi.planeCount; ++i) { if (pixiProp->u.pixi.planeDepths[i] != configDepth) { // pixi depth must match configuration property depth avifDiagnosticsPrintf(diag, "Item ID %u depth specified by pixi property [%u] does not match %s property depth [%u]", item->id, pixiProp->u.pixi.planeDepths[i], configPropName, configDepth); return AVIF_RESULT_BMFF_PARSE_FAILED; } } } if (strictFlags & AVIF_STRICT_CLAP_VALID) { const avifProperty * clapProp = avifPropertyArrayFind(&item->properties, "clap"); if (clapProp) { const avifProperty * ispeProp = avifPropertyArrayFind(&item->properties, "ispe"); if (!ispeProp) { avifDiagnosticsPrintf(diag, "[Strict] Item ID %u is missing an ispe property, so its clap property cannot be validated", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } avifCropRect cropRect; const uint32_t imageW = ispeProp->u.ispe.width; const uint32_t imageH = ispeProp->u.ispe.height; const avifPixelFormat configFormat = avifCodecConfigurationBoxGetFormat(&configProp->u.av1C); avifBool validClap = avifCropRectConvertCleanApertureBox(&cropRect, &clapProp->u.clap, imageW, imageH, configFormat, diag); if (!validClap) { return AVIF_RESULT_BMFF_PARSE_FAILED; } } } return AVIF_RESULT_OK; } static avifResult avifDecoderItemRead(avifDecoderItem * item, avifIO * io, avifROData * outData, size_t offset, size_t partialByteCount, avifDiagnostics * diag) { if (item->mergedExtents.data && !item->partialMergedExtents) { // Multiple extents have already been concatenated for this item, just return it if (offset >= item->mergedExtents.size) { avifDiagnosticsPrintf(diag, "Item ID %u read has overflowing offset", item->id); return AVIF_RESULT_TRUNCATED_DATA; } outData->data = item->mergedExtents.data + offset; outData->size = item->mergedExtents.size - offset; return AVIF_RESULT_OK; } if (item->extents.count == 0) { avifDiagnosticsPrintf(diag, "Item ID %u has zero extents", item->id); return AVIF_RESULT_TRUNCATED_DATA; } // Find this item's source of all extents' data, based on the construction method const avifRWData * idatBuffer = NULL; if (item->idatStored) { // construction_method: idat(1) if (item->meta->idat.size > 0) { idatBuffer = &item->meta->idat; } else { // no associated idat box was found in the meta box, bail out avifDiagnosticsPrintf(diag, "Item ID %u is stored in an idat, but no associated idat box was found", item->id); return AVIF_RESULT_NO_CONTENT; } } // Merge extents into a single contiguous buffer if ((io->sizeHint > 0) && (item->size > io->sizeHint)) { // Sanity check: somehow the sum of extents exceeds the entire file or idat size! avifDiagnosticsPrintf(diag, "Item ID %u reported size failed size hint sanity check. Truncated data?", item->id); return AVIF_RESULT_TRUNCATED_DATA; } if (offset >= item->size) { avifDiagnosticsPrintf(diag, "Item ID %u read has overflowing offset", item->id); return AVIF_RESULT_TRUNCATED_DATA; } const size_t maxOutputSize = item->size - offset; const size_t readOutputSize = (partialByteCount && (partialByteCount < maxOutputSize)) ? partialByteCount : maxOutputSize; const size_t totalBytesToRead = offset + readOutputSize; // If there is a single extent for this item and the source of the read buffer is going to be // persistent for the lifetime of the avifDecoder (whether it comes from its own internal // idatBuffer or from a known-persistent IO), we can avoid buffer duplication and just use the // preexisting buffer. avifBool singlePersistentBuffer = ((item->extents.count == 1) && (idatBuffer || io->persistent)); if (!singlePersistentBuffer) { // Always allocate the item's full size here, as progressive image decodes will do partial // reads into this buffer and begin feeding the buffer to the underlying AV1 decoder, but // will then write more into this buffer without flushing the AV1 decoder (which is still // holding the address of the previous allocation of this buffer). This strategy avoids // use-after-free issues in the AV1 decoder and unnecessary reallocs as a typical // progressive decode use case will eventually decode the final layer anyway. AVIF_CHECKRES(avifRWDataRealloc(&item->mergedExtents, item->size)); item->ownsMergedExtents = AVIF_TRUE; } // Set this until we manage to fill the entire mergedExtents buffer item->partialMergedExtents = AVIF_TRUE; uint8_t * front = item->mergedExtents.data; size_t remainingBytes = totalBytesToRead; for (uint32_t extentIter = 0; extentIter < item->extents.count; ++extentIter) { avifExtent * extent = &item->extents.extent[extentIter]; size_t bytesToRead = extent->size; if (bytesToRead > remainingBytes) { bytesToRead = remainingBytes; } avifROData offsetBuffer; if (idatBuffer) { if (extent->offset > idatBuffer->size) { avifDiagnosticsPrintf(diag, "Item ID %u has impossible extent offset in idat buffer", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } // Since extent->offset (a uint64_t) is not bigger than idatBuffer->size (a size_t), // it is safe to cast extent->offset to size_t. const size_t extentOffset = (size_t)extent->offset; if (extent->size > idatBuffer->size - extentOffset) { avifDiagnosticsPrintf(diag, "Item ID %u has impossible extent size in idat buffer", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } offsetBuffer.data = idatBuffer->data + extentOffset; offsetBuffer.size = idatBuffer->size - extentOffset; } else { // construction_method: file(0) if ((io->sizeHint > 0) && (extent->offset > io->sizeHint)) { avifDiagnosticsPrintf(diag, "Item ID %u extent offset failed size hint sanity check. Truncated data?", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } avifResult readResult = io->read(io, 0, extent->offset, bytesToRead, &offsetBuffer); if (readResult != AVIF_RESULT_OK) { return readResult; } if (bytesToRead != offsetBuffer.size) { avifDiagnosticsPrintf(diag, "Item ID %u tried to read %zu bytes, but only received %zu bytes", item->id, bytesToRead, offsetBuffer.size); return AVIF_RESULT_TRUNCATED_DATA; } } if (singlePersistentBuffer) { memcpy(&item->mergedExtents, &offsetBuffer, sizeof(avifRWData)); item->mergedExtents.size = bytesToRead; } else { assert(item->ownsMergedExtents); assert(front); memcpy(front, offsetBuffer.data, bytesToRead); front += bytesToRead; } remainingBytes -= bytesToRead; if (remainingBytes == 0) { // This happens when partialByteCount is set break; } } if (remainingBytes != 0) { // This should be impossible? avifDiagnosticsPrintf(diag, "Item ID %u has %zu unexpected trailing bytes", item->id, remainingBytes); return AVIF_RESULT_TRUNCATED_DATA; } outData->data = item->mergedExtents.data + offset; outData->size = readOutputSize; item->partialMergedExtents = (item->size != totalBytesToRead); return AVIF_RESULT_OK; } // Returns the avifCodecType of the first tile of the gridItem. static avifCodecType avifDecoderItemGetGridCodecType(const avifDecoderItem * gridItem) { for (uint32_t i = 0; i < gridItem->meta->items.count; ++i) { avifDecoderItem * item = &gridItem->meta->items.item[i]; const avifCodecType tileCodecType = avifGetCodecType(item->type); if ((item->dimgForID == gridItem->id) && (tileCodecType != AVIF_CODEC_TYPE_UNKNOWN)) { return tileCodecType; } } return AVIF_CODEC_TYPE_UNKNOWN; } static avifBool avifDecoderGenerateImageGridTiles(avifDecoder * decoder, avifImageGrid * grid, avifDecoderItem * gridItem, avifItemCategory itemCategory) { // Count number of dimg for this item, bail out if it doesn't match perfectly unsigned int tilesAvailable = 0; avifDecoderItem * firstTileItem = NULL; for (uint32_t i = 0; i < gridItem->meta->items.count; ++i) { avifDecoderItem * item = &gridItem->meta->items.item[i]; if (item->dimgForID != gridItem->id) { continue; } // According to HEIF (ISO 14496-12), Section 6.6.2.3.1, the SingleItemTypeReferenceBox of type 'dimg' // identifies the input images of the derived image item of type 'grid'. Since the reference_count // shall be equal to rows*columns, unknown tile item types cannot be skipped but must be considered // as errors. const avifCodecType tileCodecType = avifGetCodecType(item->type); if (tileCodecType == AVIF_CODEC_TYPE_UNKNOWN) { avifDiagnosticsPrintf(&decoder->diag, "Tile item ID %u has an unknown item type '%.4s'", item->id, (const char *)item->type); return AVIF_FALSE; } if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; can't // decode a grid image if any tile in the grid isn't supported. avifDiagnosticsPrintf(&decoder->diag, "Grid image contains tile with an unsupported property marked as essential"); return AVIF_FALSE; } const avifTile * tile = avifDecoderDataCreateTile(decoder->data, tileCodecType, item->width, item->height, avifDecoderItemOperatingPoint(item)); if (!tile) { return AVIF_FALSE; } if (!avifCodecDecodeInputFillFromDecoderItem(tile->input, item, decoder->allowProgressive, decoder->imageCountLimit, decoder->io->sizeHint, &decoder->diag)) { return AVIF_FALSE; } tile->input->itemCategory = itemCategory; if (firstTileItem == NULL) { firstTileItem = item; // Adopt the configuration property of the first image item tile, so that it can be queried from // the top-level color/alpha item during avifDecoderReset(). const char * configPropName = memcmp(item->type, "av02", 4) ? "av1C" : "av2C"; const avifProperty * srcProp = avifPropertyArrayFind(&item->properties, configPropName); if (!srcProp) { avifDiagnosticsPrintf(&decoder->diag, "Grid image's first tile is missing an %s property", configPropName); return AVIF_FALSE; } avifProperty * dstProp = (avifProperty *)avifArrayPushPtr(&gridItem->properties); *dstProp = *srcProp; if (itemCategory != AVIF_ITEM_ALPHA && item->progressive) { decoder->progressiveState = AVIF_PROGRESSIVE_STATE_AVAILABLE; if (tile->input->samples.count > 1) { decoder->progressiveState = AVIF_PROGRESSIVE_STATE_ACTIVE; decoder->imageCount = tile->input->samples.count; } } } else if (memcmp(item->type, firstTileItem->type, 4)) { // MIAF (ISO 23000-22:2019), Section 7.3.11.4.1: // All input images of a grid image item shall use the same coding format [...] // The coding format is defined by the item type. avifDiagnosticsPrintf(&decoder->diag, "Tile item ID %u of type '%.4s' differs from other tile type '%.4s'", item->id, (const char *)item->type, (const char *)firstTileItem->type); return AVIF_FALSE; } ++tilesAvailable; } if (tilesAvailable != grid->rows * grid->columns) { avifDiagnosticsPrintf(&decoder->diag, "Grid image of dimensions %ux%u requires %u tiles, and only %u were found", grid->columns, grid->rows, grid->rows * grid->columns, tilesAvailable); return AVIF_FALSE; } return AVIF_TRUE; } // Allocates the dstImage based on the grid image requirements. Also verifies some spec compliance rules for grids. static avifResult avifDecoderDataAllocateGridImagePlanes(avifDecoderData * data, const avifTileInfo * info, avifImage * dstImage) { const avifImageGrid * grid = &info->grid; const avifTile * tile = &data->tiles.tile[info->firstTileIndex]; // Validate grid image size and tile size. // // HEIF (ISO/IEC 23008-12:2017), Section 6.6.2.3.1: // The tiled input images shall completely "cover" the reconstructed image grid canvas, ... if (((tile->image->width * grid->columns) < grid->outputWidth) || ((tile->image->height * grid->rows) < grid->outputHeight)) { avifDiagnosticsPrintf(data->diag, "Grid image tiles do not completely cover the image (HEIF (ISO/IEC 23008-12:2017), Section 6.6.2.3.1)"); return AVIF_RESULT_INVALID_IMAGE_GRID; } // Tiles in the rightmost column and bottommost row must overlap the reconstructed image grid canvas. See MIAF (ISO/IEC 23000-22:2019), Section 7.3.11.4.2, Figure 2. if (((tile->image->width * (grid->columns - 1)) >= grid->outputWidth) || ((tile->image->height * (grid->rows - 1)) >= grid->outputHeight)) { avifDiagnosticsPrintf(data->diag, "Grid image tiles in the rightmost column and bottommost row do not overlap the reconstructed image grid canvas. See MIAF (ISO/IEC 23000-22:2019), Section 7.3.11.4.2, Figure 2"); return AVIF_RESULT_INVALID_IMAGE_GRID; } avifBool alpha = (tile->input->itemCategory == AVIF_ITEM_ALPHA); if (alpha) { // An alpha tile does not contain any YUV pixels. assert(tile->image->yuvFormat == AVIF_PIXEL_FORMAT_NONE); } if (!avifAreGridDimensionsValid(tile->image->yuvFormat, grid->outputWidth, grid->outputHeight, tile->image->width, tile->image->height, data->diag)) { return AVIF_RESULT_INVALID_IMAGE_GRID; } // Lazily populate dstImage with the new frame's properties. if ((dstImage->width != grid->outputWidth) || (dstImage->height != grid->outputHeight) || (dstImage->depth != tile->image->depth) || (!alpha && (dstImage->yuvFormat != tile->image->yuvFormat))) { if (alpha) { // Alpha doesn't match size, just bail out avifDiagnosticsPrintf(data->diag, "Alpha plane dimensions do not match color plane dimensions"); return AVIF_RESULT_INVALID_IMAGE_GRID; } avifImageFreePlanes(dstImage, AVIF_PLANES_ALL); dstImage->width = grid->outputWidth; dstImage->height = grid->outputHeight; dstImage->depth = tile->image->depth; dstImage->yuvFormat = tile->image->yuvFormat; dstImage->yuvRange = tile->image->yuvRange; if (!data->cicpSet) { data->cicpSet = AVIF_TRUE; dstImage->colorPrimaries = tile->image->colorPrimaries; dstImage->transferCharacteristics = tile->image->transferCharacteristics; dstImage->matrixCoefficients = tile->image->matrixCoefficients; } } if (avifImageAllocatePlanes(dstImage, alpha ? AVIF_PLANES_A : AVIF_PLANES_YUV) != AVIF_RESULT_OK) { avifDiagnosticsPrintf(data->diag, "Image allocation failure"); return AVIF_RESULT_OUT_OF_MEMORY; } return AVIF_RESULT_OK; } // After verifying that the relevant properties of the tile match those of the first tile, copies over the pixels from the tile // into dstImage. static avifBool avifDecoderDataCopyTileToImage(avifDecoderData * data, const avifTileInfo * info, avifImage * dstImage, const avifTile * tile, unsigned int tileIndex) { const avifImageGrid * grid = &info->grid; const avifTile * firstTile = &data->tiles.tile[info->firstTileIndex]; if (tile != firstTile) { // Check for tile consistency. All tiles in a grid image should match the first tile in the properties checked below. if ((tile->image->width != firstTile->image->width) || (tile->image->height != firstTile->image->height) || (tile->image->depth != firstTile->image->depth) || (tile->image->yuvFormat != firstTile->image->yuvFormat) || (tile->image->yuvRange != firstTile->image->yuvRange) || (tile->image->colorPrimaries != firstTile->image->colorPrimaries) || (tile->image->transferCharacteristics != firstTile->image->transferCharacteristics) || (tile->image->matrixCoefficients != firstTile->image->matrixCoefficients)) { avifDiagnosticsPrintf(data->diag, "Grid image contains mismatched tiles"); return AVIF_FALSE; } } unsigned int rowIndex = tileIndex / info->grid.columns; unsigned int colIndex = tileIndex % info->grid.columns; avifImage srcView; avifImageSetDefaults(&srcView); avifImage dstView; avifImageSetDefaults(&dstView); avifCropRect dstViewRect = { firstTile->image->width * colIndex, firstTile->image->height * rowIndex, firstTile->image->width, firstTile->image->height }; if (dstViewRect.x + dstViewRect.width > grid->outputWidth) { dstViewRect.width = grid->outputWidth - dstViewRect.x; } if (dstViewRect.y + dstViewRect.height > grid->outputHeight) { dstViewRect.height = grid->outputHeight - dstViewRect.y; } const avifCropRect srcViewRect = { 0, 0, dstViewRect.width, dstViewRect.height }; if ((avifImageSetViewRect(&dstView, dstImage, &dstViewRect) != AVIF_RESULT_OK) || (avifImageSetViewRect(&srcView, tile->image, &srcViewRect) != AVIF_RESULT_OK)) { assert(AVIF_FALSE); return AVIF_FALSE; } avifImageCopySamples(&dstView, &srcView, (tile->input->itemCategory == AVIF_ITEM_ALPHA) ? AVIF_PLANES_A : AVIF_PLANES_YUV); return AVIF_TRUE; } // If colorId == 0 (a sentinel value as item IDs must be nonzero), accept any found EXIF/XMP metadata. Passing in 0 // is used when finding metadata in a meta box embedded in a trak box, as any items inside of a meta box that is // inside of a trak box are implicitly associated to the track. static avifResult avifDecoderFindMetadata(avifDecoder * decoder, avifMeta * meta, avifImage * image, uint32_t colorId) { if (decoder->ignoreExif && decoder->ignoreXMP) { // Nothing to do! return AVIF_RESULT_OK; } for (uint32_t itemIndex = 0; itemIndex < meta->items.count; ++itemIndex) { avifDecoderItem * item = &meta->items.item[itemIndex]; if (!item->size) { continue; } if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; ignore the item. continue; } if ((colorId > 0) && (item->descForID != colorId)) { // Not a content description (metadata) for the colorOBU, skip it continue; } if (!decoder->ignoreExif && !memcmp(item->type, "Exif", 4)) { avifROData exifContents; avifResult readResult = avifDecoderItemRead(item, decoder->io, &exifContents, 0, 0, &decoder->diag); if (readResult != AVIF_RESULT_OK) { return readResult; } // Advance past Annex A.2.1's header BEGIN_STREAM(exifBoxStream, exifContents.data, exifContents.size, &decoder->diag, "Exif header"); uint32_t exifTiffHeaderOffset; AVIF_CHECKERR(avifROStreamReadU32(&exifBoxStream, &exifTiffHeaderOffset), AVIF_RESULT_BMFF_PARSE_FAILED); // unsigned int(32) exif_tiff_header_offset; AVIF_CHECKRES(avifRWDataSet(&image->exif, avifROStreamCurrent(&exifBoxStream), avifROStreamRemainingBytes(&exifBoxStream))); } else if (!decoder->ignoreXMP && !memcmp(item->type, "mime", 4) && !memcmp(item->contentType.contentType, xmpContentType, xmpContentTypeSize)) { avifROData xmpContents; avifResult readResult = avifDecoderItemRead(item, decoder->io, &xmpContents, 0, 0, &decoder->diag); if (readResult != AVIF_RESULT_OK) { return readResult; } AVIF_CHECKRES(avifImageSetMetadataXMP(image, xmpContents.data, xmpContents.size)); } } return AVIF_RESULT_OK; } // --------------------------------------------------------------------------- // URN static avifBool isAlphaURN(const char * urn) { return !strcmp(urn, AVIF_URN_ALPHA0) || !strcmp(urn, AVIF_URN_ALPHA1); } // --------------------------------------------------------------------------- // BMFF Parsing static avifBool avifParseHandlerBox(const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[hdlr]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t predefined; AVIF_CHECK(avifROStreamReadU32(&s, &predefined)); // unsigned int(32) pre_defined = 0; if (predefined != 0) { avifDiagnosticsPrintf(diag, "Box[hdlr] contains a pre_defined value that is nonzero"); return AVIF_FALSE; } uint8_t handlerType[4]; AVIF_CHECK(avifROStreamRead(&s, handlerType, 4)); // unsigned int(32) handler_type; if (memcmp(handlerType, "pict", 4) != 0) { avifDiagnosticsPrintf(diag, "Box[hdlr] handler_type is not 'pict'"); return AVIF_FALSE; } for (int i = 0; i < 3; ++i) { uint32_t reserved; AVIF_CHECK(avifROStreamReadU32(&s, &reserved)); // const unsigned int(32)[3] reserved = 0; } // Verify that a valid string is here, but don't bother to store it AVIF_CHECK(avifROStreamReadString(&s, NULL, 0)); // string name; return AVIF_TRUE; } static avifBool avifParseItemLocationBox(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[iloc]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); if (version > 2) { avifDiagnosticsPrintf(diag, "Box[iloc] has an unsupported version [%u]", version); return AVIF_FALSE; } uint8_t offsetSize, lengthSize, baseOffsetSize; AVIF_CHECK(avifROStreamReadBits8(&s, &offsetSize, /*bitCount=*/4)); // unsigned int(4) offset_size; AVIF_CHECK(avifROStreamReadBits8(&s, &lengthSize, /*bitCount=*/4)); // unsigned int(4) length_size; AVIF_CHECK(avifROStreamReadBits8(&s, &baseOffsetSize, /*bitCount=*/4)); // unsigned int(4) base_offset_size; if (((version == 1) || (version == 2)) && (baseOffsetSize != 0)) { avifDiagnosticsPrintf(diag, "Box[iloc] has an unsupported base_offset_size [%u]", baseOffsetSize); return AVIF_FALSE; } uint32_t reserved; AVIF_CHECK(avifROStreamReadBits(&s, &reserved, /*bitCount=*/4)); // unsigned int(4) reserved; uint16_t tmp16; uint32_t itemCount; if (version < 2) { AVIF_CHECK(avifROStreamReadU16(&s, &tmp16)); // unsigned int(16) item_count; itemCount = tmp16; } else { AVIF_CHECK(avifROStreamReadU32(&s, &itemCount)); // unsigned int(32) item_count; } for (uint32_t i = 0; i < itemCount; ++i) { uint32_t itemID; if (version < 2) { AVIF_CHECK(avifROStreamReadU16(&s, &tmp16)); // unsigned int(16) item_ID; itemID = tmp16; } else { AVIF_CHECK(avifROStreamReadU32(&s, &itemID)); // unsigned int(32) item_ID; } avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { avifDiagnosticsPrintf(diag, "Box[iloc] has an invalid item ID [%u]", itemID); return AVIF_FALSE; } if (item->extents.count > 0) { // This item has already been given extents via this iloc box. This is invalid. avifDiagnosticsPrintf(diag, "Item ID [%u] contains duplicate sets of extents", itemID); return AVIF_FALSE; } if ((version == 1) || (version == 2)) { AVIF_CHECK(avifROStreamReadBits(&s, &reserved, /*bitCount=*/12)); // unsigned int(12) reserved = 0; if (reserved) { avifDiagnosticsPrintf(diag, "Box[iloc] has a non null reserved field [%u]", reserved); return AVIF_FALSE; } uint8_t constructionMethod; AVIF_CHECK(avifROStreamReadBits8(&s, &constructionMethod, /*bitCount=*/4)); // unsigned int(4) construction_method; if ((constructionMethod != 0 /* file */) && (constructionMethod != 1 /* idat */)) { // construction method item(2) unsupported avifDiagnosticsPrintf(diag, "Box[iloc] has an unsupported construction method [%u]", constructionMethod); return AVIF_FALSE; } if (constructionMethod == 1) { item->idatStored = AVIF_TRUE; } } uint16_t dataReferenceIndex; // unsigned int(16) data_reference_index; AVIF_CHECK(avifROStreamReadU16(&s, &dataReferenceIndex)); // uint64_t baseOffset; // unsigned int(base_offset_size*8) base_offset; AVIF_CHECK(avifROStreamReadUX8(&s, &baseOffset, baseOffsetSize)); // uint16_t extentCount; // unsigned int(16) extent_count; AVIF_CHECK(avifROStreamReadU16(&s, &extentCount)); // for (int extentIter = 0; extentIter < extentCount; ++extentIter) { // If extent_index is ever supported, this spec must be implemented here: // :: if (((version == 1) || (version == 2)) && (index_size > 0)) { // :: unsigned int(index_size*8) extent_index; // :: } uint64_t extentOffset; // unsigned int(offset_size*8) extent_offset; AVIF_CHECK(avifROStreamReadUX8(&s, &extentOffset, offsetSize)); uint64_t extentLength; // unsigned int(offset_size*8) extent_length; AVIF_CHECK(avifROStreamReadUX8(&s, &extentLength, lengthSize)); avifExtent * extent = (avifExtent *)avifArrayPushPtr(&item->extents); if (extentOffset > UINT64_MAX - baseOffset) { avifDiagnosticsPrintf(diag, "Item ID [%u] contains an extent offset which overflows: [base: %" PRIu64 " offset:%" PRIu64 "]", itemID, baseOffset, extentOffset); return AVIF_FALSE; } uint64_t offset = baseOffset + extentOffset; extent->offset = offset; if (extentLength > SIZE_MAX) { avifDiagnosticsPrintf(diag, "Item ID [%u] contains an extent length which overflows: [%" PRIu64 "]", itemID, extentLength); return AVIF_FALSE; } extent->size = (size_t)extentLength; if (extent->size > SIZE_MAX - item->size) { avifDiagnosticsPrintf(diag, "Item ID [%u] contains an extent length which overflows the item size: [%zu, %zu]", itemID, extent->size, item->size); return AVIF_FALSE; } item->size += extent->size; } } return AVIF_TRUE; } static avifBool avifParseImageGridBox(avifImageGrid * grid, const uint8_t * raw, size_t rawLen, uint32_t imageSizeLimit, uint32_t imageDimensionLimit, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[grid]"); uint8_t version, flags; AVIF_CHECK(avifROStreamRead(&s, &version, 1)); // unsigned int(8) version = 0; if (version != 0) { avifDiagnosticsPrintf(diag, "Box[grid] has unsupported version [%u]", version); return AVIF_FALSE; } uint8_t rowsMinusOne, columnsMinusOne; AVIF_CHECK(avifROStreamRead(&s, &flags, 1)); // unsigned int(8) flags; AVIF_CHECK(avifROStreamRead(&s, &rowsMinusOne, 1)); // unsigned int(8) rows_minus_one; AVIF_CHECK(avifROStreamRead(&s, &columnsMinusOne, 1)); // unsigned int(8) columns_minus_one; grid->rows = (uint32_t)rowsMinusOne + 1; grid->columns = (uint32_t)columnsMinusOne + 1; uint32_t fieldLength = ((flags & 1) + 1) * 16; if (fieldLength == 16) { uint16_t outputWidth16, outputHeight16; AVIF_CHECK(avifROStreamReadU16(&s, &outputWidth16)); // unsigned int(FieldLength) output_width; AVIF_CHECK(avifROStreamReadU16(&s, &outputHeight16)); // unsigned int(FieldLength) output_height; grid->outputWidth = outputWidth16; grid->outputHeight = outputHeight16; } else { if (fieldLength != 32) { // This should be impossible avifDiagnosticsPrintf(diag, "Grid box contains illegal field length: [%u]", fieldLength); return AVIF_FALSE; } AVIF_CHECK(avifROStreamReadU32(&s, &grid->outputWidth)); // unsigned int(FieldLength) output_width; AVIF_CHECK(avifROStreamReadU32(&s, &grid->outputHeight)); // unsigned int(FieldLength) output_height; } if ((grid->outputWidth == 0) || (grid->outputHeight == 0)) { avifDiagnosticsPrintf(diag, "Grid box contains illegal dimensions: [%u x %u]", grid->outputWidth, grid->outputHeight); return AVIF_FALSE; } if (avifDimensionsTooLarge(grid->outputWidth, grid->outputHeight, imageSizeLimit, imageDimensionLimit)) { avifDiagnosticsPrintf(diag, "Grid box dimensions are too large: [%u x %u]", grid->outputWidth, grid->outputHeight); return AVIF_FALSE; } return avifROStreamRemainingBytes(&s) == 0; } static avifBool avifParseImageSpatialExtentsProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[ispe]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); avifImageSpatialExtents * ispe = &prop->u.ispe; AVIF_CHECK(avifROStreamReadU32(&s, &ispe->width)); AVIF_CHECK(avifROStreamReadU32(&s, &ispe->height)); return AVIF_TRUE; } static avifBool avifParseAuxiliaryTypeProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[auxC]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); AVIF_CHECK(avifROStreamReadString(&s, prop->u.auxC.auxType, AUXTYPE_SIZE)); return AVIF_TRUE; } static avifBool avifParseColourInformationBox(avifProperty * prop, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[colr]"); avifColourInformationBox * colr = &prop->u.colr; colr->hasICC = AVIF_FALSE; colr->hasNCLX = AVIF_FALSE; uint8_t colorType[4]; // unsigned int(32) colour_type; AVIF_CHECK(avifROStreamRead(&s, colorType, 4)); if (!memcmp(colorType, "rICC", 4) || !memcmp(colorType, "prof", 4)) { colr->hasICC = AVIF_TRUE; // Remember the offset of the ICC payload relative to the beginning of the stream. A direct pointer cannot be stored // because decoder->io->persistent could have been AVIF_FALSE when obtaining raw through decoder->io->read(). // The bytes could be copied now instead of remembering the offset, but it is as invasive as passing rawOffset everywhere. colr->iccOffset = rawOffset + avifROStreamOffset(&s); colr->iccSize = avifROStreamRemainingBytes(&s); } else if (!memcmp(colorType, "nclx", 4)) { AVIF_CHECK(avifROStreamReadU16(&s, &colr->colorPrimaries)); // unsigned int(16) colour_primaries; AVIF_CHECK(avifROStreamReadU16(&s, &colr->transferCharacteristics)); // unsigned int(16) transfer_characteristics; AVIF_CHECK(avifROStreamReadU16(&s, &colr->matrixCoefficients)); // unsigned int(16) matrix_coefficients; uint8_t full_range_flag; AVIF_CHECK(avifROStreamReadBits8(&s, &full_range_flag, /*bitCount=*/1)); // unsigned int(1) full_range_flag; colr->range = full_range_flag ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; uint8_t reserved; AVIF_CHECK(avifROStreamReadBits8(&s, &reserved, /*bitCount=*/7)); // unsigned int(7) reserved = 0; if (reserved) { avifDiagnosticsPrintf(diag, "Box[colr] contains nonzero reserved bits [%u]", reserved); return AVIF_FALSE; } colr->hasNCLX = AVIF_TRUE; } return AVIF_TRUE; } static avifBool avifParseContentLightLevelInformationBox(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[clli]"); avifContentLightLevelInformationBox * clli = &prop->u.clli; AVIF_CHECK(avifROStreamReadU16(&s, &clli->maxCLL)); // unsigned int(16) max_content_light_level AVIF_CHECK(avifROStreamReadU16(&s, &clli->maxPALL)); // unsigned int(16) max_pic_average_light_level return AVIF_TRUE; } // Implementation of section 2.3.3 of AV1 Codec ISO Media File Format Binding specification v1.2.0. // See https://aomediacodec.github.io/av1-isobmff/v1.2.0.html#av1codecconfigurationbox-syntax. static avifBool avifParseCodecConfiguration(avifROStream * s, avifCodecConfigurationBox * config, const char * configPropName, avifDiagnostics * diag) { uint32_t marker, version; AVIF_CHECK(avifROStreamReadBits(s, &marker, /*bitCount=*/1)); // unsigned int (1) marker = 1; if (!marker) { avifDiagnosticsPrintf(diag, "%s contains illegal marker: [%u]", configPropName, marker); return AVIF_FALSE; } AVIF_CHECK(avifROStreamReadBits(s, &version, /*bitCount=*/7)); // unsigned int (7) version = 1; if (version != 1) { avifDiagnosticsPrintf(diag, "%s contains illegal version: [%u]", configPropName, version); return AVIF_FALSE; } AVIF_CHECK(avifROStreamReadBits8(s, &config->seqProfile, /*bitCount=*/3)); // unsigned int (3) seq_profile; AVIF_CHECK(avifROStreamReadBits8(s, &config->seqLevelIdx0, /*bitCount=*/5)); // unsigned int (5) seq_level_idx_0; AVIF_CHECK(avifROStreamReadBits8(s, &config->seqTier0, /*bitCount=*/1)); // unsigned int (1) seq_tier_0; AVIF_CHECK(avifROStreamReadBits8(s, &config->highBitdepth, /*bitCount=*/1)); // unsigned int (1) high_bitdepth; AVIF_CHECK(avifROStreamReadBits8(s, &config->twelveBit, /*bitCount=*/1)); // unsigned int (1) twelve_bit; AVIF_CHECK(avifROStreamReadBits8(s, &config->monochrome, /*bitCount=*/1)); // unsigned int (1) monochrome; AVIF_CHECK(avifROStreamReadBits8(s, &config->chromaSubsamplingX, /*bitCount=*/1)); // unsigned int (1) chroma_subsampling_x; AVIF_CHECK(avifROStreamReadBits8(s, &config->chromaSubsamplingY, /*bitCount=*/1)); // unsigned int (1) chroma_subsampling_y; AVIF_CHECK(avifROStreamReadBits8(s, &config->chromaSamplePosition, /*bitCount=*/2)); // unsigned int (2) chroma_sample_position; // unsigned int (3) reserved = 0; // unsigned int (1) initial_presentation_delay_present; // if (initial_presentation_delay_present) { // unsigned int (4) initial_presentation_delay_minus_one; // } else { // unsigned int (4) reserved = 0; // } AVIF_CHECK(avifROStreamSkip(s, /*byteCount=*/1)); // According to section 2.2.1 of AV1 Image File Format specification v1.1.0: // - Sequence Header OBUs should not be present in the AV1CodecConfigurationBox. // - If a Sequence Header OBU is present in the AV1CodecConfigurationBox, // it shall match the Sequence Header OBU in the AV1 Image Item Data. // - Metadata OBUs, if present, shall match the values given in other item properties, // such as the PixelInformationProperty or ColourInformationBox. // See https://aomediacodec.github.io/av1-avif/v1.1.0.html#av1-configuration-item-property. // For simplicity, the constraints above are not enforced. // The following is skipped by avifParseItemPropertyContainerBox(). // unsigned int (8) configOBUs[]; return AVIF_TRUE; } static avifBool avifParseCodecConfigurationBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, const char * configPropName, avifDiagnostics * diag) { char diagContext[10]; snprintf(diagContext, sizeof(diagContext), "Box[%.4s]", configPropName); // "Box[av1C]" or "Box[av2C]" BEGIN_STREAM(s, raw, rawLen, diag, diagContext); return avifParseCodecConfiguration(&s, &prop->u.av1C, configPropName, diag); } static avifBool avifParsePixelAspectRatioBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[pasp]"); avifPixelAspectRatioBox * pasp = &prop->u.pasp; AVIF_CHECK(avifROStreamReadU32(&s, &pasp->hSpacing)); // unsigned int(32) hSpacing; AVIF_CHECK(avifROStreamReadU32(&s, &pasp->vSpacing)); // unsigned int(32) vSpacing; return AVIF_TRUE; } static avifBool avifParseCleanApertureBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[clap]"); avifCleanApertureBox * clap = &prop->u.clap; AVIF_CHECK(avifROStreamReadU32(&s, &clap->widthN)); // unsigned int(32) cleanApertureWidthN; AVIF_CHECK(avifROStreamReadU32(&s, &clap->widthD)); // unsigned int(32) cleanApertureWidthD; AVIF_CHECK(avifROStreamReadU32(&s, &clap->heightN)); // unsigned int(32) cleanApertureHeightN; AVIF_CHECK(avifROStreamReadU32(&s, &clap->heightD)); // unsigned int(32) cleanApertureHeightD; AVIF_CHECK(avifROStreamReadU32(&s, &clap->horizOffN)); // unsigned int(32) horizOffN; AVIF_CHECK(avifROStreamReadU32(&s, &clap->horizOffD)); // unsigned int(32) horizOffD; AVIF_CHECK(avifROStreamReadU32(&s, &clap->vertOffN)); // unsigned int(32) vertOffN; AVIF_CHECK(avifROStreamReadU32(&s, &clap->vertOffD)); // unsigned int(32) vertOffD; return AVIF_TRUE; } static avifBool avifParseImageRotationProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[irot]"); avifImageRotation * irot = &prop->u.irot; uint8_t reserved; AVIF_CHECK(avifROStreamReadBits8(&s, &reserved, /*bitCount=*/6)); // unsigned int (6) reserved = 0; if (reserved) { avifDiagnosticsPrintf(diag, "Box[irot] contains nonzero reserved bits [%u]", reserved); return AVIF_FALSE; } AVIF_CHECK(avifROStreamReadBits8(&s, &irot->angle, /*bitCount=*/2)); // unsigned int (2) angle; return AVIF_TRUE; } static avifBool avifParseImageMirrorProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[imir]"); avifImageMirror * imir = &prop->u.imir; uint8_t reserved; AVIF_CHECK(avifROStreamReadBits8(&s, &reserved, /*bitCount=*/7)); // unsigned int(7) reserved = 0; if (reserved) { avifDiagnosticsPrintf(diag, "Box[imir] contains nonzero reserved bits [%u]", reserved); return AVIF_FALSE; } AVIF_CHECK(avifROStreamReadBits8(&s, &imir->axis, /*bitCount=*/1)); // unsigned int(1) axis; return AVIF_TRUE; } static avifBool avifParsePixelInformationProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[pixi]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); avifPixelInformationProperty * pixi = &prop->u.pixi; AVIF_CHECK(avifROStreamRead(&s, &pixi->planeCount, 1)); // unsigned int (8) num_channels; if (pixi->planeCount > MAX_PIXI_PLANE_DEPTHS) { avifDiagnosticsPrintf(diag, "Box[pixi] contains unsupported plane count [%u]", pixi->planeCount); return AVIF_FALSE; } for (uint8_t i = 0; i < pixi->planeCount; ++i) { AVIF_CHECK(avifROStreamRead(&s, &pixi->planeDepths[i], 1)); // unsigned int (8) bits_per_channel; } return AVIF_TRUE; } static avifBool avifParseOperatingPointSelectorProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[a1op]"); avifOperatingPointSelectorProperty * a1op = &prop->u.a1op; AVIF_CHECK(avifROStreamRead(&s, &a1op->opIndex, 1)); if (a1op->opIndex > 31) { // 31 is AV1's max operating point value avifDiagnosticsPrintf(diag, "Box[a1op] contains an unsupported operating point [%u]", a1op->opIndex); return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseLayerSelectorProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[lsel]"); avifLayerSelectorProperty * lsel = &prop->u.lsel; AVIF_CHECK(avifROStreamReadU16(&s, &lsel->layerID)); if ((lsel->layerID != 0xFFFF) && (lsel->layerID >= AVIF_MAX_AV1_LAYER_COUNT)) { avifDiagnosticsPrintf(diag, "Box[lsel] contains an unsupported layer [%u]", lsel->layerID); return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseAV1LayeredImageIndexingProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[a1lx]"); avifAV1LayeredImageIndexingProperty * a1lx = &prop->u.a1lx; uint8_t largeSize = 0; AVIF_CHECK(avifROStreamRead(&s, &largeSize, 1)); if (largeSize & 0xFE) { avifDiagnosticsPrintf(diag, "Box[a1lx] has bits set in the reserved section [%u]", largeSize); return AVIF_FALSE; } for (int i = 0; i < 3; ++i) { if (largeSize) { AVIF_CHECK(avifROStreamReadU32(&s, &a1lx->layerSize[i])); } else { uint16_t layerSize16; AVIF_CHECK(avifROStreamReadU16(&s, &layerSize16)); a1lx->layerSize[i] = (uint32_t)layerSize16; } } // Layer sizes will be validated later (when the item's size is known) return AVIF_TRUE; } static avifBool avifParseItemPropertyContainerBox(avifPropertyArray * properties, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[ipco]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); int propertyIndex = avifArrayPushIndex(properties); avifProperty * prop = &properties->prop[propertyIndex]; memcpy(prop->type, header.type, 4); if (!memcmp(header.type, "ispe", 4)) { AVIF_CHECK(avifParseImageSpatialExtentsProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "auxC", 4)) { AVIF_CHECK(avifParseAuxiliaryTypeProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "colr", 4)) { AVIF_CHECK(avifParseColourInformationBox(prop, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "av1C", 4)) { AVIF_CHECK(avifParseCodecConfigurationBoxProperty(prop, avifROStreamCurrent(&s), header.size, "av1C", diag)); #if defined(AVIF_CODEC_AVM) } else if (!memcmp(header.type, "av2C", 4)) { AVIF_CHECK(avifParseCodecConfigurationBoxProperty(prop, avifROStreamCurrent(&s), header.size, "av2C", diag)); #endif } else if (!memcmp(header.type, "pasp", 4)) { AVIF_CHECK(avifParsePixelAspectRatioBoxProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "clap", 4)) { AVIF_CHECK(avifParseCleanApertureBoxProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "irot", 4)) { AVIF_CHECK(avifParseImageRotationProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "imir", 4)) { AVIF_CHECK(avifParseImageMirrorProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "pixi", 4)) { AVIF_CHECK(avifParsePixelInformationProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "a1op", 4)) { AVIF_CHECK(avifParseOperatingPointSelectorProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "lsel", 4)) { AVIF_CHECK(avifParseLayerSelectorProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "a1lx", 4)) { AVIF_CHECK(avifParseAV1LayeredImageIndexingProperty(prop, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "clli", 4)) { AVIF_CHECK(avifParseContentLightLevelInformationBox(prop, avifROStreamCurrent(&s), header.size, diag)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } return AVIF_TRUE; } static avifBool avifParseItemPropertyAssociation(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag, uint32_t * outVersionAndFlags) { // NOTE: If this function ever adds support for versions other than [0,1] or flags other than // [0,1], please increase the value of MAX_IPMA_VERSION_AND_FLAGS_SEEN accordingly. BEGIN_STREAM(s, raw, rawLen, diag, "Box[ipma]"); uint8_t version; uint32_t flags; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, &flags)); avifBool propertyIndexIsU15 = ((flags & 0x1) != 0); *outVersionAndFlags = ((uint32_t)version << 24) | flags; uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); unsigned int prevItemID = 0; for (uint32_t entryIndex = 0; entryIndex < entryCount; ++entryIndex) { // ISO/IEC 23008-12, First edition, 2017-12, Section 9.3.1: // Each ItemPropertyAssociation box shall be ordered by increasing item_ID, and there shall // be at most one association box for each item_ID, in any ItemPropertyAssociation box. unsigned int itemID; if (version < 1) { uint16_t tmp; AVIF_CHECK(avifROStreamReadU16(&s, &tmp)); itemID = tmp; } else { AVIF_CHECK(avifROStreamReadU32(&s, &itemID)); } if (itemID <= prevItemID) { avifDiagnosticsPrintf(diag, "Box[ipma] item IDs are not ordered by increasing ID"); return AVIF_FALSE; } prevItemID = itemID; avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { avifDiagnosticsPrintf(diag, "Box[ipma] has an invalid item ID [%u]", itemID); return AVIF_FALSE; } if (item->ipmaSeen) { avifDiagnosticsPrintf(diag, "Duplicate Box[ipma] for item ID [%u]", itemID); return AVIF_FALSE; } item->ipmaSeen = AVIF_TRUE; uint8_t associationCount; AVIF_CHECK(avifROStreamRead(&s, &associationCount, 1)); for (uint8_t associationIndex = 0; associationIndex < associationCount; ++associationIndex) { uint8_t essential; AVIF_CHECK(avifROStreamReadBits8(&s, &essential, /*bitCount=*/1)); // bit(1) essential; uint32_t propertyIndex; AVIF_CHECK(avifROStreamReadBits(&s, &propertyIndex, /*bitCount=*/propertyIndexIsU15 ? 15 : 7)); // unsigned int(7/15) property_index; if (propertyIndex == 0) { // Not associated with any item continue; } --propertyIndex; // 1-indexed if (propertyIndex >= meta->properties.count) { avifDiagnosticsPrintf(diag, "Box[ipma] for item ID [%u] contains an illegal property index [%u] (out of [%u] properties)", itemID, propertyIndex, meta->properties.count); return AVIF_FALSE; } // Copy property to item const avifProperty * srcProp = &meta->properties.prop[propertyIndex]; static const char * supportedTypes[] = { "ispe", "auxC", "colr", "av1C", #if defined(AVIF_CODEC_AVM) "av2C", #endif "pasp", "clap", "irot", "imir", "pixi", "a1op", "lsel", "a1lx", "clli" }; size_t supportedTypesCount = sizeof(supportedTypes) / sizeof(supportedTypes[0]); avifBool supportedType = AVIF_FALSE; for (size_t i = 0; i < supportedTypesCount; ++i) { if (!memcmp(srcProp->type, supportedTypes[i], 4)) { supportedType = AVIF_TRUE; break; } } if (supportedType) { if (essential) { // Verify that it is legal for this property to be flagged as essential. Any // types in this list are *required* in the spec to not be flagged as essential // when associated with an item. static const char * const nonessentialTypes[] = { // AVIF: Section 2.3.2.3.2: "If associated, it shall not be marked as essential." "a1lx" }; size_t nonessentialTypesCount = sizeof(nonessentialTypes) / sizeof(nonessentialTypes[0]); for (size_t i = 0; i < nonessentialTypesCount; ++i) { if (!memcmp(srcProp->type, nonessentialTypes[i], 4)) { avifDiagnosticsPrintf(diag, "Item ID [%u] has a %s property association which must not be marked essential, but is", itemID, nonessentialTypes[i]); return AVIF_FALSE; } } } else { // Verify that it is legal for this property to not be flagged as essential. Any // types in this list are *required* in the spec to be flagged as essential when // associated with an item. static const char * const essentialTypes[] = { // AVIF: Section 2.3.2.1.1: "If associated, it shall be marked as essential." "a1op", // HEIF: Section 6.5.11.1: "essential shall be equal to 1 for an 'lsel' item property." "lsel" }; size_t essentialTypesCount = sizeof(essentialTypes) / sizeof(essentialTypes[0]); for (size_t i = 0; i < essentialTypesCount; ++i) { if (!memcmp(srcProp->type, essentialTypes[i], 4)) { avifDiagnosticsPrintf(diag, "Item ID [%u] has a %s property association which must be marked essential, but is not", itemID, essentialTypes[i]); return AVIF_FALSE; } } } // Supported and valid; associate it with this item. avifProperty * dstProp = (avifProperty *)avifArrayPushPtr(&item->properties); *dstProp = *srcProp; } else { if (essential) { // Discovered an essential item property that libavif doesn't support! // Make a note to ignore this item later. item->hasUnsupportedEssentialProperty = AVIF_TRUE; } } } } return AVIF_TRUE; } static avifBool avifParsePrimaryItemBox(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { if (meta->primaryItemID > 0) { // Illegal to have multiple pitm boxes, bail out avifDiagnosticsPrintf(diag, "Multiple boxes of unique Box[pitm] found"); return AVIF_FALSE; } BEGIN_STREAM(s, raw, rawLen, diag, "Box[pitm]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); if (version == 0) { uint16_t tmp16; AVIF_CHECK(avifROStreamReadU16(&s, &tmp16)); // unsigned int(16) item_ID; meta->primaryItemID = tmp16; } else { AVIF_CHECK(avifROStreamReadU32(&s, &meta->primaryItemID)); // unsigned int(32) item_ID; } return AVIF_TRUE; } static avifBool avifParseItemDataBox(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { // Check to see if we've already seen an idat box for this meta box. If so, bail out if (meta->idat.size > 0) { avifDiagnosticsPrintf(diag, "Meta box contains multiple idat boxes"); return AVIF_FALSE; } if (rawLen == 0) { avifDiagnosticsPrintf(diag, "idat box has a length of 0"); return AVIF_FALSE; } if (avifRWDataSet(&meta->idat, raw, rawLen) != AVIF_RESULT_OK) { return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseItemPropertiesBox(avifMeta * meta, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[iprp]"); avifBoxHeader ipcoHeader; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &ipcoHeader)); if (memcmp(ipcoHeader.type, "ipco", 4)) { avifDiagnosticsPrintf(diag, "Failed to find Box[ipco] as the first box in Box[iprp]"); return AVIF_FALSE; } // Read all item properties inside of ItemPropertyContainerBox AVIF_CHECK(avifParseItemPropertyContainerBox(&meta->properties, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), ipcoHeader.size, diag)); AVIF_CHECK(avifROStreamSkip(&s, ipcoHeader.size)); uint32_t versionAndFlagsSeen[MAX_IPMA_VERSION_AND_FLAGS_SEEN]; uint32_t versionAndFlagsSeenCount = 0; // Now read all ItemPropertyAssociation until the end of the box, and make associations while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader ipmaHeader; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &ipmaHeader)); if (!memcmp(ipmaHeader.type, "ipma", 4)) { uint32_t versionAndFlags; AVIF_CHECK(avifParseItemPropertyAssociation(meta, avifROStreamCurrent(&s), ipmaHeader.size, diag, &versionAndFlags)); for (uint32_t i = 0; i < versionAndFlagsSeenCount; ++i) { if (versionAndFlagsSeen[i] == versionAndFlags) { // HEIF (ISO 23008-12:2017) 9.3.1 - There shall be at most one // ItemPropertyAssociation box with a given pair of values of version and // flags. avifDiagnosticsPrintf(diag, "Multiple Box[ipma] with a given pair of values of version and flags. See HEIF (ISO 23008-12:2017) 9.3.1"); return AVIF_FALSE; } } if (versionAndFlagsSeenCount == MAX_IPMA_VERSION_AND_FLAGS_SEEN) { avifDiagnosticsPrintf(diag, "Exceeded possible count of unique ipma version and flags tuples"); return AVIF_FALSE; } versionAndFlagsSeen[versionAndFlagsSeenCount] = versionAndFlags; ++versionAndFlagsSeenCount; } else { // These must all be type ipma avifDiagnosticsPrintf(diag, "Box[iprp] contains a box that isn't type 'ipma'"); return AVIF_FALSE; } AVIF_CHECK(avifROStreamSkip(&s, ipmaHeader.size)); } return AVIF_TRUE; } static avifBool avifParseItemInfoEntry(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[infe]"); uint8_t version; uint32_t flags; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, &flags)); // Version 2+ is required for item_type if (version != 2 && version != 3) { avifDiagnosticsPrintf(s.diag, "%s: Expecting box version 2 or 3, got version %u", s.diagContext, version); return AVIF_FALSE; } // TODO: check flags. ISO/IEC 23008-12:2017, Section 9.2 says: // The flags field of ItemInfoEntry with version greater than or equal to 2 is specified as // follows: // // (flags & 1) equal to 1 indicates that the item is not intended to be a part of the // presentation. For example, when (flags & 1) is equal to 1 for an image item, the image // item should not be displayed. // (flags & 1) equal to 0 indicates that the item is intended to be a part of the // presentation. // // See also Section 6.4.2. uint32_t itemID; if (version == 2) { uint16_t tmp; AVIF_CHECK(avifROStreamReadU16(&s, &tmp)); // unsigned int(16) item_ID; itemID = tmp; } else { assert(version == 3); AVIF_CHECK(avifROStreamReadU32(&s, &itemID)); // unsigned int(32) item_ID; } uint16_t itemProtectionIndex; // unsigned int(16) item_protection_index; AVIF_CHECK(avifROStreamReadU16(&s, &itemProtectionIndex)); // uint8_t itemType[4]; // unsigned int(32) item_type; AVIF_CHECK(avifROStreamRead(&s, itemType, 4)); // avifContentType contentType; if (!memcmp(itemType, "mime", 4)) { AVIF_CHECK(avifROStreamReadString(&s, NULL, 0)); // string item_name; (skipped) AVIF_CHECK(avifROStreamReadString(&s, contentType.contentType, CONTENTTYPE_SIZE)); // string content_type; } else { memset(&contentType, 0, sizeof(contentType)); } avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { avifDiagnosticsPrintf(diag, "%s: Box[infe] with item_type %.4s has an invalid item_ID [%u]", s.diagContext, itemType, itemID); return AVIF_FALSE; } memcpy(item->type, itemType, sizeof(itemType)); item->contentType = contentType; return AVIF_TRUE; } static avifBool avifParseItemInfoBox(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[iinf]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); uint32_t entryCount; if (version == 0) { uint16_t tmp; AVIF_CHECK(avifROStreamReadU16(&s, &tmp)); // unsigned int(16) entry_count; entryCount = tmp; } else if (version == 1) { AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; } else { avifDiagnosticsPrintf(diag, "Box[iinf] has an unsupported version %u", version); return AVIF_FALSE; } for (uint32_t entryIndex = 0; entryIndex < entryCount; ++entryIndex) { avifBoxHeader infeHeader; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &infeHeader)); if (!memcmp(infeHeader.type, "infe", 4)) { AVIF_CHECK(avifParseItemInfoEntry(meta, avifROStreamCurrent(&s), infeHeader.size, diag)); } else { // These must all be type infe avifDiagnosticsPrintf(diag, "Box[iinf] contains a box that isn't type 'infe'"); return AVIF_FALSE; } AVIF_CHECK(avifROStreamSkip(&s, infeHeader.size)); } return AVIF_TRUE; } static avifBool avifParseItemReferenceBox(avifMeta * meta, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[iref]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader irefHeader; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &irefHeader)); uint32_t fromID = 0; if (version == 0) { uint16_t tmp; AVIF_CHECK(avifROStreamReadU16(&s, &tmp)); // unsigned int(16) from_item_ID; fromID = tmp; } else if (version == 1) { AVIF_CHECK(avifROStreamReadU32(&s, &fromID)); // unsigned int(32) from_item_ID; } else { // unsupported iref version, skip it break; } uint16_t referenceCount = 0; AVIF_CHECK(avifROStreamReadU16(&s, &referenceCount)); // unsigned int(16) reference_count; for (uint16_t refIndex = 0; refIndex < referenceCount; ++refIndex) { uint32_t toID = 0; if (version == 0) { uint16_t tmp; AVIF_CHECK(avifROStreamReadU16(&s, &tmp)); // unsigned int(16) to_item_ID; toID = tmp; } else if (version == 1) { AVIF_CHECK(avifROStreamReadU32(&s, &toID)); // unsigned int(32) to_item_ID; } else { // unsupported iref version, skip it break; } // Read this reference as "{fromID} is a {irefType} for {toID}" if (fromID && toID) { avifDecoderItem * item = avifMetaFindItem(meta, fromID); if (!item) { avifDiagnosticsPrintf(diag, "Box[iref] has an invalid item ID [%u]", fromID); return AVIF_FALSE; } if (!memcmp(irefHeader.type, "thmb", 4)) { item->thumbnailForID = toID; } else if (!memcmp(irefHeader.type, "auxl", 4)) { item->auxForID = toID; } else if (!memcmp(irefHeader.type, "cdsc", 4)) { item->descForID = toID; } else if (!memcmp(irefHeader.type, "dimg", 4)) { // derived images refer in the opposite direction avifDecoderItem * dimg = avifMetaFindItem(meta, toID); if (!dimg) { avifDiagnosticsPrintf(diag, "Box[iref] has an invalid item ID dimg ref [%u]", toID); return AVIF_FALSE; } dimg->dimgForID = fromID; } else if (!memcmp(irefHeader.type, "prem", 4)) { item->premByID = toID; } } } } return AVIF_TRUE; } static avifBool avifParseMetaBox(avifMeta * meta, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[meta]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); ++meta->idatID; // for tracking idat avifBool firstBox = AVIF_TRUE; uint32_t uniqueBoxFlags = 0; while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (firstBox) { if (!memcmp(header.type, "hdlr", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 0, "meta", "hdlr", diag)); AVIF_CHECK(avifParseHandlerBox(avifROStreamCurrent(&s), header.size, diag)); firstBox = AVIF_FALSE; } else { // hdlr must be the first box! avifDiagnosticsPrintf(diag, "Box[meta] does not have a Box[hdlr] as its first child box"); return AVIF_FALSE; } } else if (!memcmp(header.type, "iloc", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 1, "meta", "iloc", diag)); AVIF_CHECK(avifParseItemLocationBox(meta, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "pitm", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 2, "meta", "pitm", diag)); AVIF_CHECK(avifParsePrimaryItemBox(meta, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "idat", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 3, "meta", "idat", diag)); AVIF_CHECK(avifParseItemDataBox(meta, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "iprp", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 4, "meta", "iprp", diag)); AVIF_CHECK(avifParseItemPropertiesBox(meta, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "iinf", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 5, "meta", "iinf", diag)); AVIF_CHECK(avifParseItemInfoBox(meta, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "iref", 4)) { AVIF_CHECK(uniqueBoxSeen(&uniqueBoxFlags, 6, "meta", "iref", diag)); AVIF_CHECK(avifParseItemReferenceBox(meta, avifROStreamCurrent(&s), header.size, diag)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } if (firstBox) { // The meta box must not be empty (it must contain at least a hdlr box) avifDiagnosticsPrintf(diag, "Box[meta] has no child boxes"); return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseTrackHeaderBox(avifTrack * track, const uint8_t * raw, size_t rawLen, uint32_t imageSizeLimit, uint32_t imageDimensionLimit, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[tkhd]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); uint32_t ignored32, trackID; uint64_t ignored64; if (version == 1) { AVIF_CHECK(avifROStreamReadU64(&s, &ignored64)); // unsigned int(64) creation_time; AVIF_CHECK(avifROStreamReadU64(&s, &ignored64)); // unsigned int(64) modification_time; AVIF_CHECK(avifROStreamReadU32(&s, &trackID)); // unsigned int(32) track_ID; AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // const unsigned int(32) reserved = 0; AVIF_CHECK(avifROStreamReadU64(&s, &track->trackDuration)); // unsigned int(64) duration; } else if (version == 0) { uint32_t trackDuration; AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // unsigned int(32) creation_time; AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // unsigned int(32) modification_time; AVIF_CHECK(avifROStreamReadU32(&s, &trackID)); // unsigned int(32) track_ID; AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // const unsigned int(32) reserved = 0; AVIF_CHECK(avifROStreamReadU32(&s, &trackDuration)); // unsigned int(32) duration; track->trackDuration = (trackDuration == AVIF_INDEFINITE_DURATION32) ? AVIF_INDEFINITE_DURATION64 : trackDuration; } else { // Unsupported version avifDiagnosticsPrintf(diag, "Box[tkhd] has an unsupported version [%u]", version); return AVIF_FALSE; } // Skipping the following 52 bytes here: // ------------------------------------ // const unsigned int(32)[2] reserved = 0; // template int(16) layer = 0; // template int(16) alternate_group = 0; // template int(16) volume = {if track_is_audio 0x0100 else 0}; // const unsigned int(16) reserved = 0; // template int(32)[9] matrix= { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }; // unity matrix AVIF_CHECK(avifROStreamSkip(&s, 52)); uint32_t width, height; AVIF_CHECK(avifROStreamReadU32(&s, &width)); // unsigned int(32) width; AVIF_CHECK(avifROStreamReadU32(&s, &height)); // unsigned int(32) height; track->width = width >> 16; track->height = height >> 16; if ((track->width == 0) || (track->height == 0)) { avifDiagnosticsPrintf(diag, "Track ID [%u] has an invalid size [%ux%u]", track->id, track->width, track->height); return AVIF_FALSE; } if (avifDimensionsTooLarge(track->width, track->height, imageSizeLimit, imageDimensionLimit)) { avifDiagnosticsPrintf(diag, "Track ID [%u] dimensions are too large [%ux%u]", track->id, track->width, track->height); return AVIF_FALSE; } // TODO: support scaling based on width/height track header info? track->id = trackID; return AVIF_TRUE; } static avifBool avifParseMediaHeaderBox(avifTrack * track, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[mdhd]"); uint8_t version; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); uint32_t ignored32, mediaTimescale, mediaDuration32; uint64_t ignored64, mediaDuration64; if (version == 1) { AVIF_CHECK(avifROStreamReadU64(&s, &ignored64)); // unsigned int(64) creation_time; AVIF_CHECK(avifROStreamReadU64(&s, &ignored64)); // unsigned int(64) modification_time; AVIF_CHECK(avifROStreamReadU32(&s, &mediaTimescale)); // unsigned int(32) timescale; AVIF_CHECK(avifROStreamReadU64(&s, &mediaDuration64)); // unsigned int(64) duration; track->mediaDuration = mediaDuration64; } else if (version == 0) { AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // unsigned int(32) creation_time; AVIF_CHECK(avifROStreamReadU32(&s, &ignored32)); // unsigned int(32) modification_time; AVIF_CHECK(avifROStreamReadU32(&s, &mediaTimescale)); // unsigned int(32) timescale; AVIF_CHECK(avifROStreamReadU32(&s, &mediaDuration32)); // unsigned int(32) duration; track->mediaDuration = (uint64_t)mediaDuration32; } else { // Unsupported version avifDiagnosticsPrintf(diag, "Box[mdhd] has an unsupported version [%u]", version); return AVIF_FALSE; } track->mediaTimescale = mediaTimescale; return AVIF_TRUE; } static avifBool avifParseChunkOffsetBox(avifSampleTable * sampleTable, avifBool largeOffsets, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, largeOffsets ? "Box[co64]" : "Box[stco]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; for (uint32_t i = 0; i < entryCount; ++i) { uint64_t offset; if (largeOffsets) { AVIF_CHECK(avifROStreamReadU64(&s, &offset)); // unsigned int(32) chunk_offset; } else { uint32_t offset32; AVIF_CHECK(avifROStreamReadU32(&s, &offset32)); // unsigned int(32) chunk_offset; offset = (uint64_t)offset32; } avifSampleTableChunk * chunk = (avifSampleTableChunk *)avifArrayPushPtr(&sampleTable->chunks); chunk->offset = offset; } return AVIF_TRUE; } static avifBool avifParseSampleToChunkBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[stsc]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; uint32_t prevFirstChunk = 0; for (uint32_t i = 0; i < entryCount; ++i) { avifSampleTableSampleToChunk * sampleToChunk = (avifSampleTableSampleToChunk *)avifArrayPushPtr(&sampleTable->sampleToChunks); AVIF_CHECK(avifROStreamReadU32(&s, &sampleToChunk->firstChunk)); // unsigned int(32) first_chunk; AVIF_CHECK(avifROStreamReadU32(&s, &sampleToChunk->samplesPerChunk)); // unsigned int(32) samples_per_chunk; AVIF_CHECK(avifROStreamReadU32(&s, &sampleToChunk->sampleDescriptionIndex)); // unsigned int(32) sample_description_index; // The first_chunk fields should start with 1 and be strictly increasing. if (i == 0) { if (sampleToChunk->firstChunk != 1) { avifDiagnosticsPrintf(diag, "Box[stsc] does not begin with chunk 1 [%u]", sampleToChunk->firstChunk); return AVIF_FALSE; } } else { if (sampleToChunk->firstChunk <= prevFirstChunk) { avifDiagnosticsPrintf(diag, "Box[stsc] chunks are not strictly increasing"); return AVIF_FALSE; } } prevFirstChunk = sampleToChunk->firstChunk; } return AVIF_TRUE; } static avifBool avifParseSampleSizeBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[stsz]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t allSamplesSize, sampleCount; AVIF_CHECK(avifROStreamReadU32(&s, &allSamplesSize)); // unsigned int(32) sample_size; AVIF_CHECK(avifROStreamReadU32(&s, &sampleCount)); // unsigned int(32) sample_count; if (allSamplesSize > 0) { sampleTable->allSamplesSize = allSamplesSize; } else { for (uint32_t i = 0; i < sampleCount; ++i) { avifSampleTableSampleSize * sampleSize = (avifSampleTableSampleSize *)avifArrayPushPtr(&sampleTable->sampleSizes); AVIF_CHECK(avifROStreamReadU32(&s, &sampleSize->size)); // unsigned int(32) entry_size; } } return AVIF_TRUE; } static avifBool avifParseSyncSampleBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[stss]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; for (uint32_t i = 0; i < entryCount; ++i) { uint32_t sampleNumber = 0; AVIF_CHECK(avifROStreamReadU32(&s, &sampleNumber)); // unsigned int(32) sample_number; avifSyncSample * syncSample = (avifSyncSample *)avifArrayPushPtr(&sampleTable->syncSamples); syncSample->sampleNumber = sampleNumber; } return AVIF_TRUE; } static avifBool avifParseTimeToSampleBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[stts]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; for (uint32_t i = 0; i < entryCount; ++i) { avifSampleTableTimeToSample * timeToSample = (avifSampleTableTimeToSample *)avifArrayPushPtr(&sampleTable->timeToSamples); AVIF_CHECK(avifROStreamReadU32(&s, &timeToSample->sampleCount)); // unsigned int(32) sample_count; AVIF_CHECK(avifROStreamReadU32(&s, &timeToSample->sampleDelta)); // unsigned int(32) sample_delta; } return AVIF_TRUE; } static avifBool avifParseSampleDescriptionBox(avifSampleTable * sampleTable, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[stsd]"); AVIF_CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; for (uint32_t i = 0; i < entryCount; ++i) { avifBoxHeader sampleEntryHeader; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &sampleEntryHeader)); avifSampleDescription * description = (avifSampleDescription *)avifArrayPushPtr(&sampleTable->sampleDescriptions); if (!avifArrayCreate(&description->properties, sizeof(avifProperty), 16)) { avifArrayPop(&sampleTable->sampleDescriptions); return AVIF_FALSE; } memcpy(description->format, sampleEntryHeader.type, sizeof(description->format)); size_t remainingBytes = avifROStreamRemainingBytes(&s); if ((avifGetCodecType(description->format) != AVIF_CODEC_TYPE_UNKNOWN) && (remainingBytes > VISUALSAMPLEENTRY_SIZE)) { AVIF_CHECK(avifParseItemPropertyContainerBox(&description->properties, rawOffset + avifROStreamOffset(&s) + VISUALSAMPLEENTRY_SIZE, avifROStreamCurrent(&s) + VISUALSAMPLEENTRY_SIZE, remainingBytes - VISUALSAMPLEENTRY_SIZE, diag)); } AVIF_CHECK(avifROStreamSkip(&s, sampleEntryHeader.size)); } return AVIF_TRUE; } static avifBool avifParseSampleTableBox(avifTrack * track, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { if (track->sampleTable) { // A TrackBox may only have one SampleTable avifDiagnosticsPrintf(diag, "Duplicate Box[stbl] for a single track detected"); return AVIF_FALSE; } track->sampleTable = avifSampleTableCreate(); BEGIN_STREAM(s, raw, rawLen, diag, "Box[stbl]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "stco", 4)) { AVIF_CHECK(avifParseChunkOffsetBox(track->sampleTable, AVIF_FALSE, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "co64", 4)) { AVIF_CHECK(avifParseChunkOffsetBox(track->sampleTable, AVIF_TRUE, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "stsc", 4)) { AVIF_CHECK(avifParseSampleToChunkBox(track->sampleTable, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "stsz", 4)) { AVIF_CHECK(avifParseSampleSizeBox(track->sampleTable, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "stss", 4)) { AVIF_CHECK(avifParseSyncSampleBox(track->sampleTable, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "stts", 4)) { AVIF_CHECK(avifParseTimeToSampleBox(track->sampleTable, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "stsd", 4)) { AVIF_CHECK(avifParseSampleDescriptionBox(track->sampleTable, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, diag)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } return AVIF_TRUE; } static avifBool avifParseMediaInformationBox(avifTrack * track, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[minf]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "stbl", 4)) { AVIF_CHECK(avifParseSampleTableBox(track, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, diag)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } return AVIF_TRUE; } static avifBool avifParseMediaBox(avifTrack * track, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[mdia]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "mdhd", 4)) { AVIF_CHECK(avifParseMediaHeaderBox(track, avifROStreamCurrent(&s), header.size, diag)); } else if (!memcmp(header.type, "minf", 4)) { AVIF_CHECK(avifParseMediaInformationBox(track, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, diag)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } return AVIF_TRUE; } static avifBool avifTrackReferenceBox(avifTrack * track, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[tref]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "auxl", 4)) { uint32_t toID; AVIF_CHECK(avifROStreamReadU32(&s, &toID)); // unsigned int(32) track_IDs[]; AVIF_CHECK(avifROStreamSkip(&s, header.size - sizeof(uint32_t))); // just take the first one track->auxForID = toID; } else if (!memcmp(header.type, "prem", 4)) { uint32_t byID; AVIF_CHECK(avifROStreamReadU32(&s, &byID)); // unsigned int(32) track_IDs[]; AVIF_CHECK(avifROStreamSkip(&s, header.size - sizeof(uint32_t))); // just take the first one track->premByID = byID; } else { AVIF_CHECK(avifROStreamSkip(&s, header.size)); } } return AVIF_TRUE; } static avifBool avifParseEditListBox(avifTrack * track, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[elst]"); uint8_t version; uint32_t flags; AVIF_CHECK(avifROStreamReadVersionAndFlags(&s, &version, &flags)); if ((flags & 1) == 0) { track->isRepeating = AVIF_FALSE; return AVIF_TRUE; } track->isRepeating = AVIF_TRUE; uint32_t entryCount; AVIF_CHECK(avifROStreamReadU32(&s, &entryCount)); // unsigned int(32) entry_count; if (entryCount != 1) { avifDiagnosticsPrintf(diag, "Box[elst] contains an entry_count != 1 [%d]", entryCount); return AVIF_FALSE; } if (version == 1) { AVIF_CHECK(avifROStreamReadU64(&s, &track->segmentDuration)); // unsigned int(64) segment_duration; } else if (version == 0) { uint32_t segmentDuration; AVIF_CHECK(avifROStreamReadU32(&s, &segmentDuration)); // unsigned int(32) segment_duration; track->segmentDuration = segmentDuration; } else { // Unsupported version avifDiagnosticsPrintf(diag, "Box[elst] has an unsupported version [%u]", version); return AVIF_FALSE; } if (track->segmentDuration == 0) { avifDiagnosticsPrintf(diag, "Box[elst] Invalid value for segment_duration (0)."); return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseEditBox(avifTrack * track, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[edts]"); avifBool elstBoxSeen = AVIF_FALSE; while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "elst", 4)) { if (elstBoxSeen) { avifDiagnosticsPrintf(diag, "More than one [elst] Box was found."); return AVIF_FALSE; } AVIF_CHECK(avifParseEditListBox(track, avifROStreamCurrent(&s), header.size, diag)); elstBoxSeen = AVIF_TRUE; } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } if (!elstBoxSeen) { avifDiagnosticsPrintf(diag, "Box[edts] contains no [elst] Box."); return AVIF_FALSE; } return AVIF_TRUE; } static avifBool avifParseTrackBox(avifDecoderData * data, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, uint32_t imageSizeLimit, uint32_t imageDimensionLimit) { BEGIN_STREAM(s, raw, rawLen, data->diag, "Box[trak]"); avifTrack * track = avifDecoderDataCreateTrack(data); avifBool edtsBoxSeen = AVIF_FALSE; while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "tkhd", 4)) { AVIF_CHECK(avifParseTrackHeaderBox(track, avifROStreamCurrent(&s), header.size, imageSizeLimit, imageDimensionLimit, data->diag)); } else if (!memcmp(header.type, "meta", 4)) { AVIF_CHECK(avifParseMetaBox(track->meta, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, data->diag)); } else if (!memcmp(header.type, "mdia", 4)) { AVIF_CHECK(avifParseMediaBox(track, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, data->diag)); } else if (!memcmp(header.type, "tref", 4)) { AVIF_CHECK(avifTrackReferenceBox(track, avifROStreamCurrent(&s), header.size, data->diag)); } else if (!memcmp(header.type, "edts", 4)) { if (edtsBoxSeen) { avifDiagnosticsPrintf(data->diag, "More than one [edts] Box was found."); return AVIF_FALSE; } AVIF_CHECK(avifParseEditBox(track, avifROStreamCurrent(&s), header.size, data->diag)); edtsBoxSeen = AVIF_TRUE; } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } if (!edtsBoxSeen) { track->repetitionCount = AVIF_REPETITION_COUNT_UNKNOWN; } else if (track->isRepeating) { if (track->trackDuration == AVIF_INDEFINITE_DURATION64) { // If isRepeating is true and the track duration is unknown/indefinite, then set the repetition count to infinite // (Section 9.6.1 of ISO/IEC 23008-12 Part 12). track->repetitionCount = AVIF_REPETITION_COUNT_INFINITE; } else { // Section 9.6.1. of ISO/IEC 23008-12 Part 12: 1, the entire edit list is repeated a sufficient number of times to // equal the track duration. // // Since libavif uses repetitionCount (which is 0-based), we subtract the value by 1 to derive the number of // repetitions. assert(track->segmentDuration != 0); // We specifically check for trackDuration == 0 here and not when it is actually read in order to accept files which // inadvertently has a trackDuration of 0 without any edit lists. if (track->trackDuration == 0) { avifDiagnosticsPrintf(data->diag, "Invalid track duration 0."); return AVIF_FALSE; } const uint64_t repetitionCount = (track->trackDuration / track->segmentDuration) + (track->trackDuration % track->segmentDuration != 0) - 1; if (repetitionCount > INT_MAX) { // repetitionCount does not fit in an integer and hence it is // likely to be a very large value. So, we just set it to // infinite. track->repetitionCount = AVIF_REPETITION_COUNT_INFINITE; } else { track->repetitionCount = (int)repetitionCount; } } } else { track->repetitionCount = 0; } return AVIF_TRUE; } static avifBool avifParseMovieBox(avifDecoderData * data, uint64_t rawOffset, const uint8_t * raw, size_t rawLen, uint32_t imageSizeLimit, uint32_t imageDimensionLimit) { BEGIN_STREAM(s, raw, rawLen, data->diag, "Box[moov]"); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "trak", 4)) { AVIF_CHECK( avifParseTrackBox(data, rawOffset + avifROStreamOffset(&s), avifROStreamCurrent(&s), header.size, imageSizeLimit, imageDimensionLimit)); } AVIF_CHECK(avifROStreamSkip(&s, header.size)); } return AVIF_TRUE; } static avifBool avifParseFileTypeBox(avifFileType * ftyp, const uint8_t * raw, size_t rawLen, avifDiagnostics * diag) { BEGIN_STREAM(s, raw, rawLen, diag, "Box[ftyp]"); AVIF_CHECK(avifROStreamRead(&s, ftyp->majorBrand, 4)); AVIF_CHECK(avifROStreamReadU32(&s, &ftyp->minorVersion)); size_t compatibleBrandsBytes = avifROStreamRemainingBytes(&s); if ((compatibleBrandsBytes % 4) != 0) { avifDiagnosticsPrintf(diag, "Box[ftyp] contains a compatible brands section that isn't divisible by 4 [%zu]", compatibleBrandsBytes); return AVIF_FALSE; } ftyp->compatibleBrands = avifROStreamCurrent(&s); AVIF_CHECK(avifROStreamSkip(&s, compatibleBrandsBytes)); ftyp->compatibleBrandsCount = (int)compatibleBrandsBytes / 4; return AVIF_TRUE; } static avifBool avifFileTypeHasBrand(avifFileType * ftyp, const char * brand); static avifBool avifFileTypeIsCompatible(avifFileType * ftyp); static avifResult avifParse(avifDecoder * decoder) { // Note: this top-level function is the only avifParse*() function that returns avifResult instead of avifBool. // Be sure to use AVIF_CHECKERR() in this function with an explicit error result instead of simply using AVIF_CHECK(). avifResult readResult; uint64_t parseOffset = 0; avifDecoderData * data = decoder->data; avifBool ftypSeen = AVIF_FALSE; avifBool metaSeen = AVIF_FALSE; avifBool moovSeen = AVIF_FALSE; avifBool needsMeta = AVIF_FALSE; avifBool needsMoov = AVIF_FALSE; for (;;) { // Read just enough to get the next box header (a max of 32 bytes) avifROData headerContents; if ((decoder->io->sizeHint > 0) && (parseOffset > decoder->io->sizeHint)) { return AVIF_RESULT_BMFF_PARSE_FAILED; } readResult = decoder->io->read(decoder->io, 0, parseOffset, 32, &headerContents); if (readResult != AVIF_RESULT_OK) { return readResult; } if (!headerContents.size) { // If we got AVIF_RESULT_OK from the reader but received 0 bytes, // we've reached the end of the file with no errors. Hooray! break; } // Parse the header, and find out how many bytes it actually was BEGIN_STREAM(headerStream, headerContents.data, headerContents.size, &decoder->diag, "File-level box header"); avifBoxHeader header; AVIF_CHECKERR(avifROStreamReadBoxHeaderPartial(&headerStream, &header), AVIF_RESULT_BMFF_PARSE_FAILED); parseOffset += headerStream.offset; assert((decoder->io->sizeHint == 0) || (parseOffset <= decoder->io->sizeHint)); // Try to get the remainder of the box, if necessary uint64_t boxOffset = 0; avifROData boxContents = AVIF_DATA_EMPTY; // TODO: reorg this code to only do these memcmps once each if (!memcmp(header.type, "ftyp", 4) || !memcmp(header.type, "meta", 4) || !memcmp(header.type, "moov", 4)) { boxOffset = parseOffset; readResult = decoder->io->read(decoder->io, 0, parseOffset, header.size, &boxContents); if (readResult != AVIF_RESULT_OK) { return readResult; } if (boxContents.size != header.size) { // A truncated box, bail out return AVIF_RESULT_TRUNCATED_DATA; } } else if (header.size > (UINT64_MAX - parseOffset)) { return AVIF_RESULT_BMFF_PARSE_FAILED; } parseOffset += header.size; if (!memcmp(header.type, "ftyp", 4)) { AVIF_CHECKERR(!ftypSeen, AVIF_RESULT_BMFF_PARSE_FAILED); avifFileType ftyp; AVIF_CHECKERR(avifParseFileTypeBox(&ftyp, boxContents.data, boxContents.size, data->diag), AVIF_RESULT_BMFF_PARSE_FAILED); if (!avifFileTypeIsCompatible(&ftyp)) { return AVIF_RESULT_INVALID_FTYP; } ftypSeen = AVIF_TRUE; memcpy(data->majorBrand, ftyp.majorBrand, 4); // Remember the major brand for future AVIF_DECODER_SOURCE_AUTO decisions needsMeta = avifFileTypeHasBrand(&ftyp, "avif"); needsMoov = avifFileTypeHasBrand(&ftyp, "avis"); } else if (!memcmp(header.type, "meta", 4)) { AVIF_CHECKERR(!metaSeen, AVIF_RESULT_BMFF_PARSE_FAILED); AVIF_CHECKERR(avifParseMetaBox(data->meta, boxOffset, boxContents.data, boxContents.size, data->diag), AVIF_RESULT_BMFF_PARSE_FAILED); metaSeen = AVIF_TRUE; } else if (!memcmp(header.type, "moov", 4)) { AVIF_CHECKERR(!moovSeen, AVIF_RESULT_BMFF_PARSE_FAILED); AVIF_CHECKERR(avifParseMovieBox(data, boxOffset, boxContents.data, boxContents.size, decoder->imageSizeLimit, decoder->imageDimensionLimit), AVIF_RESULT_BMFF_PARSE_FAILED); moovSeen = AVIF_TRUE; } // See if there is enough information to consider Parse() a success and early-out: // * If the brand 'avif' is present, require a meta box // * If the brand 'avis' is present, require a moov box if (ftypSeen && (!needsMeta || metaSeen) && (!needsMoov || moovSeen)) { return AVIF_RESULT_OK; } } if (!ftypSeen) { return AVIF_RESULT_INVALID_FTYP; } if ((needsMeta && !metaSeen) || (needsMoov && !moovSeen)) { return AVIF_RESULT_TRUNCATED_DATA; } return AVIF_RESULT_OK; } // --------------------------------------------------------------------------- static avifBool avifFileTypeHasBrand(avifFileType * ftyp, const char * brand) { if (!memcmp(ftyp->majorBrand, brand, 4)) { return AVIF_TRUE; } for (int compatibleBrandIndex = 0; compatibleBrandIndex < ftyp->compatibleBrandsCount; ++compatibleBrandIndex) { const uint8_t * compatibleBrand = &ftyp->compatibleBrands[4 * compatibleBrandIndex]; if (!memcmp(compatibleBrand, brand, 4)) { return AVIF_TRUE; } } return AVIF_FALSE; } static avifBool avifFileTypeIsCompatible(avifFileType * ftyp) { return avifFileTypeHasBrand(ftyp, "avif") || avifFileTypeHasBrand(ftyp, "avis"); } avifBool avifPeekCompatibleFileType(const avifROData * input) { BEGIN_STREAM(s, input->data, input->size, NULL, NULL); avifBoxHeader header; AVIF_CHECK(avifROStreamReadBoxHeader(&s, &header)); if (memcmp(header.type, "ftyp", 4)) { return AVIF_FALSE; } avifFileType ftyp; memset(&ftyp, 0, sizeof(avifFileType)); avifBool parsed = avifParseFileTypeBox(&ftyp, avifROStreamCurrent(&s), header.size, NULL); if (!parsed) { return AVIF_FALSE; } return avifFileTypeIsCompatible(&ftyp); } // --------------------------------------------------------------------------- avifDecoder * avifDecoderCreate(void) { avifDecoder * decoder = (avifDecoder *)avifAlloc(sizeof(avifDecoder)); memset(decoder, 0, sizeof(avifDecoder)); decoder->maxThreads = 1; decoder->imageSizeLimit = AVIF_DEFAULT_IMAGE_SIZE_LIMIT; decoder->imageDimensionLimit = AVIF_DEFAULT_IMAGE_DIMENSION_LIMIT; decoder->imageCountLimit = AVIF_DEFAULT_IMAGE_COUNT_LIMIT; decoder->strictFlags = AVIF_STRICT_ENABLED; return decoder; } static void avifDecoderCleanup(avifDecoder * decoder) { if (decoder->data) { avifDecoderDataDestroy(decoder->data); decoder->data = NULL; } if (decoder->image) { avifImageDestroy(decoder->image); decoder->image = NULL; } avifDiagnosticsClearError(&decoder->diag); } void avifDecoderDestroy(avifDecoder * decoder) { avifDecoderCleanup(decoder); avifIODestroy(decoder->io); avifFree(decoder); } avifResult avifDecoderSetSource(avifDecoder * decoder, avifDecoderSource source) { decoder->requestedSource = source; return avifDecoderReset(decoder); } void avifDecoderSetIO(avifDecoder * decoder, avifIO * io) { avifIODestroy(decoder->io); decoder->io = io; } avifResult avifDecoderSetIOMemory(avifDecoder * decoder, const uint8_t * data, size_t size) { avifIO * io = avifIOCreateMemoryReader(data, size); assert(io); avifDecoderSetIO(decoder, io); return AVIF_RESULT_OK; } avifResult avifDecoderSetIOFile(avifDecoder * decoder, const char * filename) { avifIO * io = avifIOCreateFileReader(filename); if (!io) { return AVIF_RESULT_IO_ERROR; } avifDecoderSetIO(decoder, io); return AVIF_RESULT_OK; } // 0-byte extents are ignored/overwritten during the merge, as they are the signal from helper // functions that no extent was necessary for this given sample. If both provided extents are // >0 bytes, this will set dst to be an extent that bounds both supplied extents. static avifResult avifExtentMerge(avifExtent * dst, const avifExtent * src) { if (!dst->size) { *dst = *src; return AVIF_RESULT_OK; } if (!src->size) { return AVIF_RESULT_OK; } const uint64_t minExtent1 = dst->offset; const uint64_t maxExtent1 = dst->offset + dst->size; const uint64_t minExtent2 = src->offset; const uint64_t maxExtent2 = src->offset + src->size; dst->offset = AVIF_MIN(minExtent1, minExtent2); const uint64_t extentLength = AVIF_MAX(maxExtent1, maxExtent2) - dst->offset; if (extentLength > SIZE_MAX) { return AVIF_RESULT_BMFF_PARSE_FAILED; } dst->size = (size_t)extentLength; return AVIF_RESULT_OK; } avifResult avifDecoderNthImageMaxExtent(const avifDecoder * decoder, uint32_t frameIndex, avifExtent * outExtent) { if (!decoder->data) { // Nothing has been parsed yet return AVIF_RESULT_NO_CONTENT; } memset(outExtent, 0, sizeof(avifExtent)); uint32_t startFrameIndex = avifDecoderNearestKeyframe(decoder, frameIndex); uint32_t endFrameIndex = frameIndex; for (uint32_t currentFrameIndex = startFrameIndex; currentFrameIndex <= endFrameIndex; ++currentFrameIndex) { for (unsigned int tileIndex = 0; tileIndex < decoder->data->tiles.count; ++tileIndex) { avifTile * tile = &decoder->data->tiles.tile[tileIndex]; if (currentFrameIndex >= tile->input->samples.count) { return AVIF_RESULT_NO_IMAGES_REMAINING; } avifDecodeSample * sample = &tile->input->samples.sample[currentFrameIndex]; avifExtent sampleExtent; if (sample->itemID) { // The data comes from an item. Let avifDecoderItemMaxExtent() do the heavy lifting. avifDecoderItem * item = avifMetaFindItem(decoder->data->meta, sample->itemID); avifResult maxExtentResult = avifDecoderItemMaxExtent(item, sample, &sampleExtent); if (maxExtentResult != AVIF_RESULT_OK) { return maxExtentResult; } } else { // The data likely comes from a sample table. Use the sample position directly. sampleExtent.offset = sample->offset; sampleExtent.size = sample->size; } if (sampleExtent.size > UINT64_MAX - sampleExtent.offset) { return AVIF_RESULT_BMFF_PARSE_FAILED; } avifResult extentMergeResult = avifExtentMerge(outExtent, &sampleExtent); if (extentMergeResult != AVIF_RESULT_OK) { return extentMergeResult; } } } return AVIF_RESULT_OK; } static avifResult avifDecoderPrepareSample(avifDecoder * decoder, avifDecodeSample * sample, size_t partialByteCount) { if (!sample->data.size || sample->partialData) { // This sample hasn't been read from IO or had its extents fully merged yet. size_t bytesToRead = sample->size; if (partialByteCount && (bytesToRead > partialByteCount)) { bytesToRead = partialByteCount; } if (sample->itemID) { // The data comes from an item. Let avifDecoderItemRead() do the heavy lifting. avifDecoderItem * item = avifMetaFindItem(decoder->data->meta, sample->itemID); avifROData itemContents; if (sample->offset > SIZE_MAX) { return AVIF_RESULT_BMFF_PARSE_FAILED; } size_t offset = (size_t)sample->offset; avifResult readResult = avifDecoderItemRead(item, decoder->io, &itemContents, offset, bytesToRead, &decoder->diag); if (readResult != AVIF_RESULT_OK) { return readResult; } // avifDecoderItemRead is guaranteed to already be persisted by either the underlying IO // or by mergedExtents; just reuse the buffer here. sample->data = itemContents; sample->ownsData = AVIF_FALSE; sample->partialData = item->partialMergedExtents; } else { // The data likely comes from a sample table. Pull the sample and make a copy if necessary. avifROData sampleContents; if ((decoder->io->sizeHint > 0) && (sample->offset > decoder->io->sizeHint)) { return AVIF_RESULT_BMFF_PARSE_FAILED; } avifResult readResult = decoder->io->read(decoder->io, 0, sample->offset, bytesToRead, &sampleContents); if (readResult != AVIF_RESULT_OK) { return readResult; } if (sampleContents.size != bytesToRead) { return AVIF_RESULT_TRUNCATED_DATA; } sample->ownsData = !decoder->io->persistent; sample->partialData = (bytesToRead != sample->size); if (decoder->io->persistent) { sample->data = sampleContents; } else { AVIF_CHECKRES(avifRWDataSet((avifRWData *)&sample->data, sampleContents.data, sampleContents.size)); } } } return AVIF_RESULT_OK; } avifResult avifDecoderParse(avifDecoder * decoder) { avifDiagnosticsClearError(&decoder->diag); // An imageSizeLimit greater than AVIF_DEFAULT_IMAGE_SIZE_LIMIT and the special value of 0 to // disable the limit are not yet implemented. if ((decoder->imageSizeLimit > AVIF_DEFAULT_IMAGE_SIZE_LIMIT) || (decoder->imageSizeLimit == 0)) { return AVIF_RESULT_NOT_IMPLEMENTED; } if (!decoder->io || !decoder->io->read) { return AVIF_RESULT_IO_NOT_SET; } // Cleanup anything lingering in the decoder avifDecoderCleanup(decoder); // ----------------------------------------------------------------------- // Parse BMFF boxes decoder->data = avifDecoderDataCreate(); decoder->data->diag = &decoder->diag; avifResult parseResult = avifParse(decoder); if (parseResult != AVIF_RESULT_OK) { return parseResult; } // Walk the decoded items (if any) and harvest ispe avifDecoderData * data = decoder->data; for (uint32_t itemIndex = 0; itemIndex < data->meta->items.count; ++itemIndex) { avifDecoderItem * item = &data->meta->items.item[itemIndex]; if (!item->size) { continue; } if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; ignore the item. continue; } avifBool isGrid = (memcmp(item->type, "grid", 4) == 0); if ((avifGetCodecType(item->type) == AVIF_CODEC_TYPE_UNKNOWN) && !isGrid) { // probably exif or some other data continue; } const avifProperty * ispeProp = avifPropertyArrayFind(&item->properties, "ispe"); if (ispeProp) { item->width = ispeProp->u.ispe.width; item->height = ispeProp->u.ispe.height; if ((item->width == 0) || (item->height == 0)) { avifDiagnosticsPrintf(data->diag, "Item ID [%u] has an invalid size [%ux%u]", item->id, item->width, item->height); return AVIF_RESULT_BMFF_PARSE_FAILED; } if (avifDimensionsTooLarge(item->width, item->height, decoder->imageSizeLimit, decoder->imageDimensionLimit)) { avifDiagnosticsPrintf(data->diag, "Item ID [%u] dimensions are too large [%ux%u]", item->id, item->width, item->height); return AVIF_RESULT_BMFF_PARSE_FAILED; } } else { const avifProperty * auxCProp = avifPropertyArrayFind(&item->properties, "auxC"); if (auxCProp && isAlphaURN(auxCProp->u.auxC.auxType)) { if (decoder->strictFlags & AVIF_STRICT_ALPHA_ISPE_REQUIRED) { avifDiagnosticsPrintf(data->diag, "[Strict] Alpha auxiliary image item ID [%u] is missing a mandatory ispe property", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } } else { avifDiagnosticsPrintf(data->diag, "Item ID [%u] is missing a mandatory ispe property", item->id); return AVIF_RESULT_BMFF_PARSE_FAILED; } } } return avifDecoderReset(decoder); } static avifResult avifCodecCreateInternal(avifCodecChoice choice, const avifTile * tile, avifDiagnostics * diag, avifCodec ** codec) { #if defined(AVIF_CODEC_AVM) // AVIF_CODEC_CHOICE_AUTO leads to AVIF_CODEC_TYPE_AV1 by default. Reroute correctly. if (choice == AVIF_CODEC_CHOICE_AUTO && tile->codecType == AVIF_CODEC_TYPE_AV2) { choice = AVIF_CODEC_CHOICE_AVM; } #endif AVIF_CHECKERR(tile->codecType == avifCodecTypeFromChoice(choice, AVIF_CODEC_FLAG_CAN_DECODE), AVIF_RESULT_NO_CODEC_AVAILABLE); *codec = avifCodecCreate(choice, AVIF_CODEC_FLAG_CAN_DECODE); AVIF_CHECKERR(*codec, AVIF_RESULT_OUT_OF_MEMORY); (*codec)->diag = diag; (*codec)->operatingPoint = tile->operatingPoint; (*codec)->allLayers = tile->input->allLayers; return AVIF_RESULT_OK; } static avifBool avifTilesCanBeDecodedWithSameCodecInstance(avifDecoderData * data) { if (data->color.tileCount == 1 && data->alpha.tileCount == 1) { // Single tile image with single tile alpha plane. In this case each tile needs its own decoder since the planes will be // "stolen". Stealing either the color or the alpha plane will invalidate the other one when decode is called the second // time. return AVIF_FALSE; } const uint8_t firstTileOperatingPoint = data->tiles.tile[0].operatingPoint; const avifBool firstTileAllLayers = data->tiles.tile[0].input->allLayers; for (unsigned int i = 1; i < data->tiles.count; ++i) { const avifTile * tile = &data->tiles.tile[i]; if (tile->operatingPoint != firstTileOperatingPoint || tile->input->allLayers != firstTileAllLayers) { return AVIF_FALSE; } // avifDecoderItemValidateProperties() verified during avifDecoderParse() that all tiles // share the same coding format so no need to check for codecType equality here. } return AVIF_TRUE; } static avifResult avifDecoderCreateCodecs(avifDecoder * decoder) { avifDecoderData * data = decoder->data; avifDecoderDataResetCodec(data); if (data->source == AVIF_DECODER_SOURCE_TRACKS) { // In this case, we will use at most two codec instances (one for the color planes and one for the alpha plane). AVIF_CHECKRES(avifCodecCreateInternal(decoder->codecChoice, &decoder->data->tiles.tile[0], &decoder->diag, &data->codec)); data->tiles.tile[0].codec = data->codec; if (data->tiles.count > 1) { AVIF_CHECKRES(avifCodecCreateInternal(decoder->codecChoice, &decoder->data->tiles.tile[1], &decoder->diag, &data->codecAlpha)); data->tiles.tile[1].codec = data->codecAlpha; } } else { // In this case, we will use one codec instance when there is only one tile or when all of the following conditions are // met: // - The image must have exactly one layer (i.e.) decoder->imageCount == 1. // - All the tiles must have the same operating point (because the codecs take operating point once at initialization // and do not allow it to be changed later). // - All the tiles must have the same value for allLayers (because the codecs take allLayers once at initialization // and do not allow it to be changed later). // - If the image has a single tile, it must not have a single tile alpha plane (in this case we will steal the planes // from the decoder, so we cannot use the same decoder for both the color and the alpha planes). // - All tiles have the same type (AV1 or AV2). // Otherwise, we will use |tiles.count| decoder instances (one instance for each tile). avifBool canUseSingleCodecInstance = (data->tiles.count == 1) || (decoder->imageCount == 1 && avifTilesCanBeDecodedWithSameCodecInstance(data)); if (canUseSingleCodecInstance) { AVIF_CHECKRES(avifCodecCreateInternal(decoder->codecChoice, &decoder->data->tiles.tile[0], &decoder->diag, &data->codec)); for (unsigned int i = 0; i < decoder->data->tiles.count; ++i) { decoder->data->tiles.tile[i].codec = data->codec; } } else { for (unsigned int i = 0; i < decoder->data->tiles.count; ++i) { avifTile * tile = &decoder->data->tiles.tile[i]; AVIF_CHECKRES(avifCodecCreateInternal(decoder->codecChoice, tile, &decoder->diag, &tile->codec)); } } } return AVIF_RESULT_OK; } // Returns AVIF_TRUE if the item should be skipped. Items should be skipped for one of the following reasons: // * Size is 0. // * Has an essential property that isn't supported by libavif. // * Item is Exif or similar metadata. // * Item is a thumbnail. static avifBool avifDecoderItemShouldBeSkipped(const avifDecoderItem * item) { return !item->size || item->hasUnsupportedEssentialProperty || (avifGetCodecType(item->type) == AVIF_CODEC_TYPE_UNKNOWN && memcmp(item->type, "grid", 4)) || item->thumbnailForID != 0; } // Returns the primary color item if found, or NULL. static avifDecoderItem * avifDecoderDataFindColorItem(avifDecoderData * data) { for (uint32_t itemIndex = 0; itemIndex < data->meta->items.count; ++itemIndex) { avifDecoderItem * item = &data->meta->items.item[itemIndex]; if (avifDecoderItemShouldBeSkipped(item)) { continue; } if (item->id == data->meta->primaryItemID) { return item; } } return NULL; } // Returns AVIF_TRUE if item is an alpha auxiliary item of the parent color // item. static avifBool avifDecoderItemIsAlphaAux(avifDecoderItem * item, uint32_t colorItemId) { if (item->auxForID != colorItemId) return AVIF_FALSE; const avifProperty * auxCProp = avifPropertyArrayFind(&item->properties, "auxC"); return auxCProp && isAlphaURN(auxCProp->u.auxC.auxType); } // Finds the alpha item whose parent item is colorItem and sets it in the alphaItem output parameter. Returns AVIF_RESULT_OK on // success. Note that *alphaItem can be NULL even if the return value is AVIF_RESULT_OK. If the colorItem is a grid and the alpha // item is represented as a set of auxl items to each color tile, then a fake item will be created and *isAlphaItemInInput will be // set to AVIF_FALSE. In this case, the alpha item merely exists to hold the locations of the alpha tile items. The data of this // item need not be read and the pixi property cannot be validated. Otherwise, *isAlphaItemInInput will be set to AVIF_TRUE when // *alphaItem is not NULL. static avifResult avifDecoderDataFindAlphaItem(avifDecoderData * data, avifDecoderItem * colorItem, avifDecoderItem ** alphaItem, avifBool * isAlphaItemInInput) { for (uint32_t itemIndex = 0; itemIndex < data->meta->items.count; ++itemIndex) { avifDecoderItem * item = &data->meta->items.item[itemIndex]; if (avifDecoderItemShouldBeSkipped(item)) { continue; } if (avifDecoderItemIsAlphaAux(item, colorItem->id)) { *alphaItem = item; *isAlphaItemInInput = AVIF_TRUE; return AVIF_RESULT_OK; } } if (memcmp(colorItem->type, "grid", 4)) { *alphaItem = NULL; *isAlphaItemInInput = AVIF_FALSE; return AVIF_RESULT_OK; } // If color item is a grid, check if there is an alpha channel which is represented as an auxl item to each color tile // item. uint32_t colorItemCount = data->color.grid.rows * data->color.grid.columns; if (colorItemCount == 0) { *alphaItem = NULL; *isAlphaItemInInput = AVIF_FALSE; return AVIF_RESULT_OK; } uint32_t * alphaItemIndices = avifAlloc(colorItemCount * sizeof(uint32_t)); AVIF_CHECKERR(alphaItemIndices, AVIF_RESULT_OUT_OF_MEMORY); uint32_t alphaItemCount = 0; uint32_t maxItemID = 0; for (uint32_t i = 0; i < colorItem->meta->items.count; ++i) { avifDecoderItem * item = &colorItem->meta->items.item[i]; if (item->id > maxItemID) { maxItemID = item->id; } if (item->dimgForID == colorItem->id) { for (uint32_t j = 0; j < colorItem->meta->items.count; ++j) { avifDecoderItem * auxlItem = &colorItem->meta->items.item[j]; if (avifDecoderItemIsAlphaAux(auxlItem, item->id)) { alphaItemIndices[alphaItemCount++] = j; } } } } if (alphaItemCount != colorItemCount) { // Not all the color items had an alpha auxiliary attached to it. Report this case as an image without alpha channel. avifFree(alphaItemIndices); *alphaItem = NULL; *isAlphaItemInInput = AVIF_FALSE; return AVIF_RESULT_OK; } *alphaItem = avifMetaFindItem(colorItem->meta, maxItemID + 1); if (*alphaItem == NULL) { avifFree(alphaItemIndices); *isAlphaItemInInput = AVIF_FALSE; return AVIF_RESULT_OUT_OF_MEMORY; } memcpy((*alphaItem)->type, "grid", 4); (*alphaItem)->width = colorItem->width; (*alphaItem)->height = colorItem->height; for (uint32_t i = 0; i < alphaItemCount; ++i) { avifDecoderItem * item = &colorItem->meta->items.item[alphaItemIndices[i]]; item->dimgForID = (*alphaItem)->id; } avifFree(alphaItemIndices); *isAlphaItemInInput = AVIF_FALSE; data->alpha.grid = data->color.grid; return AVIF_RESULT_OK; } static avifResult avifDecoderGenerateImageTiles(avifDecoder * decoder, avifTileInfo * info, avifDecoderItem * item, avifItemCategory itemCategory) { const uint32_t previousTileCount = decoder->data->tiles.count; if ((info->grid.rows > 0) && (info->grid.columns > 0)) { AVIF_CHECKERR(avifDecoderGenerateImageGridTiles(decoder, &info->grid, item, itemCategory), AVIF_RESULT_INVALID_IMAGE_GRID); } else { AVIF_CHECKERR(item->size != 0, AVIF_RESULT_MISSING_IMAGE_ITEM); const avifCodecType codecType = avifGetCodecType(item->type); assert(codecType != AVIF_CODEC_TYPE_UNKNOWN); avifTile * tile = avifDecoderDataCreateTile(decoder->data, codecType, item->width, item->height, avifDecoderItemOperatingPoint(item)); AVIF_CHECKERR(tile, AVIF_RESULT_OUT_OF_MEMORY); AVIF_CHECKERR(avifCodecDecodeInputFillFromDecoderItem(tile->input, item, decoder->allowProgressive, decoder->imageCountLimit, decoder->io->sizeHint, &decoder->diag), AVIF_RESULT_BMFF_PARSE_FAILED); tile->input->itemCategory = itemCategory; } info->tileCount = decoder->data->tiles.count - previousTileCount; return AVIF_RESULT_OK; } avifResult avifDecoderReset(avifDecoder * decoder) { avifDiagnosticsClearError(&decoder->diag); avifDecoderData * data = decoder->data; if (!data) { // Nothing to reset. return AVIF_RESULT_OK; } memset(&data->color.grid, 0, sizeof(data->color.grid)); memset(&data->alpha.grid, 0, sizeof(data->alpha.grid)); avifDecoderDataClearTiles(data); // Prepare / cleanup decoded image state if (decoder->image) { avifImageDestroy(decoder->image); } decoder->image = avifImageCreateEmpty(); AVIF_CHECKERR(decoder->image, AVIF_RESULT_OUT_OF_MEMORY); decoder->progressiveState = AVIF_PROGRESSIVE_STATE_UNAVAILABLE; data->cicpSet = AVIF_FALSE; memset(&decoder->ioStats, 0, sizeof(decoder->ioStats)); // ----------------------------------------------------------------------- // Build decode input data->sourceSampleTable = NULL; // Reset if (decoder->requestedSource == AVIF_DECODER_SOURCE_AUTO) { // Honor the major brand (avif or avis) if present, otherwise prefer avis (tracks) if possible. if (!memcmp(data->majorBrand, "avis", 4)) { data->source = AVIF_DECODER_SOURCE_TRACKS; } else if (!memcmp(data->majorBrand, "avif", 4)) { data->source = AVIF_DECODER_SOURCE_PRIMARY_ITEM; } else if (data->tracks.count > 0) { data->source = AVIF_DECODER_SOURCE_TRACKS; } else { data->source = AVIF_DECODER_SOURCE_PRIMARY_ITEM; } } else { data->source = decoder->requestedSource; } avifCodecType colorCodecType = AVIF_CODEC_TYPE_UNKNOWN; const avifPropertyArray * colorProperties = NULL; if (data->source == AVIF_DECODER_SOURCE_TRACKS) { avifTrack * colorTrack = NULL; avifTrack * alphaTrack = NULL; // Find primary track - this probably needs some better detection uint32_t colorTrackIndex = 0; for (; colorTrackIndex < data->tracks.count; ++colorTrackIndex) { avifTrack * track = &data->tracks.track[colorTrackIndex]; if (!track->sampleTable) { continue; } if (!track->id) { // trak box might be missing a tkhd box inside, skip it continue; } if (!track->sampleTable->chunks.count) { continue; } colorCodecType = avifSampleTableGetCodecType(track->sampleTable); if (colorCodecType == AVIF_CODEC_TYPE_UNKNOWN) { continue; } if (track->auxForID != 0) { continue; } // Found one! break; } if (colorTrackIndex == data->tracks.count) { avifDiagnosticsPrintf(&decoder->diag, "Failed to find AV1 color track"); return AVIF_RESULT_NO_CONTENT; } colorTrack = &data->tracks.track[colorTrackIndex]; colorProperties = avifSampleTableGetProperties(colorTrack->sampleTable, colorCodecType); if (!colorProperties) { avifDiagnosticsPrintf(&decoder->diag, "Failed to find AV1 color track's color properties"); return AVIF_RESULT_BMFF_PARSE_FAILED; } // Find Exif and/or XMP metadata, if any if (colorTrack->meta) { // See the comment above avifDecoderFindMetadata() for the explanation of using 0 here avifResult findResult = avifDecoderFindMetadata(decoder, colorTrack->meta, decoder->image, 0); if (findResult != AVIF_RESULT_OK) { return findResult; } } uint32_t alphaTrackIndex = 0; avifCodecType alphaCodecType = AVIF_CODEC_TYPE_UNKNOWN; for (; alphaTrackIndex < data->tracks.count; ++alphaTrackIndex) { avifTrack * track = &data->tracks.track[alphaTrackIndex]; if (!track->sampleTable) { continue; } if (!track->id) { continue; } if (!track->sampleTable->chunks.count) { continue; } alphaCodecType = avifSampleTableGetCodecType(track->sampleTable); if (alphaCodecType == AVIF_CODEC_TYPE_UNKNOWN) { continue; } if (track->auxForID == colorTrack->id) { // Found it! break; } } if (alphaTrackIndex != data->tracks.count) { alphaTrack = &data->tracks.track[alphaTrackIndex]; } const uint8_t operatingPoint = 0; // No way to set operating point via tracks avifTile * colorTile = avifDecoderDataCreateTile(data, colorCodecType, colorTrack->width, colorTrack->height, operatingPoint); if (!colorTile) { return AVIF_RESULT_OUT_OF_MEMORY; } if (!avifCodecDecodeInputFillFromSampleTable(colorTile->input, colorTrack->sampleTable, decoder->imageCountLimit, decoder->io->sizeHint, data->diag)) { return AVIF_RESULT_BMFF_PARSE_FAILED; } data->color.tileCount = 1; if (alphaTrack) { avifTile * alphaTile = avifDecoderDataCreateTile(data, alphaCodecType, alphaTrack->width, alphaTrack->height, operatingPoint); if (!alphaTile) { return AVIF_RESULT_OUT_OF_MEMORY; } if (!avifCodecDecodeInputFillFromSampleTable(alphaTile->input, alphaTrack->sampleTable, decoder->imageCountLimit, decoder->io->sizeHint, data->diag)) { return AVIF_RESULT_BMFF_PARSE_FAILED; } alphaTile->input->itemCategory = AVIF_ITEM_ALPHA; data->alpha.tileCount = 1; } // Stash off sample table for future timing information data->sourceSampleTable = colorTrack->sampleTable; // Image sequence timing decoder->imageIndex = -1; decoder->imageCount = (int)colorTile->input->samples.count; decoder->timescale = colorTrack->mediaTimescale; decoder->durationInTimescales = colorTrack->mediaDuration; if (colorTrack->mediaTimescale) { decoder->duration = (double)decoder->durationInTimescales / (double)colorTrack->mediaTimescale; } else { decoder->duration = 0; } // If the alphaTrack->repetitionCount and colorTrack->repetitionCount are different, we will simply use the // colorTrack's repetitionCount. decoder->repetitionCount = colorTrack->repetitionCount; memset(&decoder->imageTiming, 0, sizeof(decoder->imageTiming)); // to be set in avifDecoderNextImage() decoder->image->width = colorTrack->width; decoder->image->height = colorTrack->height; decoder->alphaPresent = (alphaTrack != NULL); decoder->image->alphaPremultiplied = decoder->alphaPresent && (colorTrack->premByID == alphaTrack->id); } else { // Create from items if (data->meta->primaryItemID == 0) { // A primary item is required avifDiagnosticsPrintf(&decoder->diag, "Primary item not specified"); return AVIF_RESULT_MISSING_IMAGE_ITEM; } avifDecoderItem * colorItem = avifDecoderDataFindColorItem(data); if (!colorItem) { avifDiagnosticsPrintf(&decoder->diag, "Primary item not found"); return AVIF_RESULT_MISSING_IMAGE_ITEM; } colorProperties = &colorItem->properties; if (!memcmp(colorItem->type, "grid", 4)) { avifROData readData; AVIF_CHECKRES(avifDecoderItemRead(colorItem, decoder->io, &readData, 0, 0, data->diag)); AVIF_CHECKERR(avifParseImageGridBox(&data->color.grid, readData.data, readData.size, decoder->imageSizeLimit, decoder->imageDimensionLimit, data->diag), AVIF_RESULT_INVALID_IMAGE_GRID); colorCodecType = avifDecoderItemGetGridCodecType(colorItem); if (colorCodecType == AVIF_CODEC_TYPE_UNKNOWN) { return AVIF_RESULT_INVALID_IMAGE_GRID; } } else { colorCodecType = avifGetCodecType(colorItem->type); assert(colorCodecType != AVIF_CODEC_TYPE_UNKNOWN); } avifBool isAlphaItemInInput; avifDecoderItem * alphaItem; AVIF_CHECKRES(avifDecoderDataFindAlphaItem(data, colorItem, &alphaItem, &isAlphaItemInInput)); avifCodecType alphaCodecType = AVIF_CODEC_TYPE_UNKNOWN; if (alphaItem) { if (!memcmp(alphaItem->type, "grid", 4)) { if (isAlphaItemInInput) { avifROData readData; AVIF_CHECKRES(avifDecoderItemRead(alphaItem, decoder->io, &readData, 0, 0, data->diag)); AVIF_CHECKERR(avifParseImageGridBox(&data->alpha.grid, readData.data, readData.size, decoder->imageSizeLimit, decoder->imageDimensionLimit, data->diag), AVIF_RESULT_INVALID_IMAGE_GRID); } alphaCodecType = avifDecoderItemGetGridCodecType(alphaItem); if (alphaCodecType == AVIF_CODEC_TYPE_UNKNOWN) { return AVIF_RESULT_INVALID_IMAGE_GRID; } } else { alphaCodecType = avifGetCodecType(alphaItem->type); assert(alphaCodecType != AVIF_CODEC_TYPE_UNKNOWN); } } // Find Exif and/or XMP metadata, if any AVIF_CHECKRES(avifDecoderFindMetadata(decoder, data->meta, decoder->image, colorItem->id)); // Set all counts and timing to safe-but-uninteresting values decoder->imageIndex = -1; decoder->imageCount = 1; decoder->imageTiming.timescale = 1; decoder->imageTiming.pts = 0; decoder->imageTiming.ptsInTimescales = 0; decoder->imageTiming.duration = 1; decoder->imageTiming.durationInTimescales = 1; decoder->timescale = 1; decoder->duration = 1; decoder->durationInTimescales = 1; AVIF_CHECKRES(avifDecoderGenerateImageTiles(decoder, &data->color, colorItem, AVIF_ITEM_COLOR)); if ((data->color.grid.rows == 0) || (data->color.grid.columns == 0)) { if (colorItem->progressive) { decoder->progressiveState = AVIF_PROGRESSIVE_STATE_AVAILABLE; const avifTile * colorTile = &data->tiles.tile[0]; if (colorTile->input->samples.count > 1) { decoder->progressiveState = AVIF_PROGRESSIVE_STATE_ACTIVE; decoder->imageCount = (int)colorTile->input->samples.count; } } } if (alphaItem) { if (!alphaItem->width && !alphaItem->height) { // NON-STANDARD: Alpha subimage does not have an ispe property; adopt width/height from color item assert(!(decoder->strictFlags & AVIF_STRICT_ALPHA_ISPE_REQUIRED)); alphaItem->width = colorItem->width; alphaItem->height = colorItem->height; } AVIF_CHECKRES(avifDecoderGenerateImageTiles(decoder, &data->alpha, alphaItem, AVIF_ITEM_ALPHA)); } decoder->image->width = colorItem->width; decoder->image->height = colorItem->height; decoder->alphaPresent = (alphaItem != NULL); decoder->image->alphaPremultiplied = decoder->alphaPresent && (colorItem->premByID == alphaItem->id); AVIF_CHECKRES( avifDecoderItemValidateProperties(colorItem, avifGetConfigurationPropertyName(colorCodecType), &decoder->diag, decoder->strictFlags)); if (alphaItem) { avifStrictFlags strictFlags = decoder->strictFlags; if (!isAlphaItemInInput) { // In this case, the made up grid item will not have an associated pixi property. So validate everything else // but the pixi property. strictFlags &= ~AVIF_STRICT_PIXI_REQUIRED; } AVIF_CHECKRES( avifDecoderItemValidateProperties(alphaItem, avifGetConfigurationPropertyName(alphaCodecType), &decoder->diag, strictFlags)); } } decoder->data->color.firstTileIndex = 0; decoder->data->alpha.firstTileIndex = decoder->data->color.tileCount; // Sanity check tiles for (uint32_t tileIndex = 0; tileIndex < data->tiles.count; ++tileIndex) { avifTile * tile = &data->tiles.tile[tileIndex]; for (uint32_t sampleIndex = 0; sampleIndex < tile->input->samples.count; ++sampleIndex) { avifDecodeSample * sample = &tile->input->samples.sample[sampleIndex]; if (!sample->size) { // Every sample must have some data return AVIF_RESULT_BMFF_PARSE_FAILED; } if (tile->input->itemCategory == AVIF_ITEM_ALPHA) { decoder->ioStats.alphaOBUSize += sample->size; } else { decoder->ioStats.colorOBUSize += sample->size; } } } // Find and adopt all colr boxes "at most one for a given value of colour type" (HEIF 6.5.5.1, from Amendment 3) // Accept one of each type, and bail out if more than one of a given type is provided. avifBool colrICCSeen = AVIF_FALSE; avifBool colrNCLXSeen = AVIF_FALSE; for (uint32_t propertyIndex = 0; propertyIndex < colorProperties->count; ++propertyIndex) { avifProperty * prop = &colorProperties->prop[propertyIndex]; if (!memcmp(prop->type, "colr", 4)) { if (prop->u.colr.hasICC) { if (colrICCSeen) { return AVIF_RESULT_BMFF_PARSE_FAILED; } avifROData icc; const avifResult readResult = decoder->io->read(decoder->io, 0, prop->u.colr.iccOffset, prop->u.colr.iccSize, &icc); if (readResult != AVIF_RESULT_OK) { return readResult; } colrICCSeen = AVIF_TRUE; AVIF_CHECKRES(avifImageSetProfileICC(decoder->image, icc.data, icc.size)); } if (prop->u.colr.hasNCLX) { if (colrNCLXSeen) { return AVIF_RESULT_BMFF_PARSE_FAILED; } colrNCLXSeen = AVIF_TRUE; data->cicpSet = AVIF_TRUE; decoder->image->colorPrimaries = prop->u.colr.colorPrimaries; decoder->image->transferCharacteristics = prop->u.colr.transferCharacteristics; decoder->image->matrixCoefficients = prop->u.colr.matrixCoefficients; decoder->image->yuvRange = prop->u.colr.range; } } } const avifProperty * clliProp = avifPropertyArrayFind(colorProperties, "clli"); if (clliProp) { decoder->image->clli = clliProp->u.clli; } // Transformations const avifProperty * paspProp = avifPropertyArrayFind(colorProperties, "pasp"); if (paspProp) { decoder->image->transformFlags |= AVIF_TRANSFORM_PASP; decoder->image->pasp = paspProp->u.pasp; } const avifProperty * clapProp = avifPropertyArrayFind(colorProperties, "clap"); if (clapProp) { decoder->image->transformFlags |= AVIF_TRANSFORM_CLAP; decoder->image->clap = clapProp->u.clap; } const avifProperty * irotProp = avifPropertyArrayFind(colorProperties, "irot"); if (irotProp) { decoder->image->transformFlags |= AVIF_TRANSFORM_IROT; decoder->image->irot = irotProp->u.irot; } const avifProperty * imirProp = avifPropertyArrayFind(colorProperties, "imir"); if (imirProp) { decoder->image->transformFlags |= AVIF_TRANSFORM_IMIR; decoder->image->imir = imirProp->u.imir; } if (!data->cicpSet && (data->tiles.count > 0)) { avifTile * firstTile = &data->tiles.tile[0]; if (firstTile->input->samples.count > 0) { avifDecodeSample * sample = &firstTile->input->samples.sample[0]; // Harvest CICP from the AV1's sequence header, which should be very close to the front // of the first sample. Read in successively larger chunks until we successfully parse the sequence. static const size_t searchSampleChunkIncrement = 64; static const size_t searchSampleSizeMax = 4096; size_t searchSampleSize = 0; do { searchSampleSize += searchSampleChunkIncrement; if (searchSampleSize > sample->size) { searchSampleSize = sample->size; } avifResult prepareResult = avifDecoderPrepareSample(decoder, sample, searchSampleSize); if (prepareResult != AVIF_RESULT_OK) { return prepareResult; } avifSequenceHeader sequenceHeader; if (avifSequenceHeaderParse(&sequenceHeader, &sample->data, firstTile->codecType)) { data->cicpSet = AVIF_TRUE; decoder->image->colorPrimaries = sequenceHeader.colorPrimaries; decoder->image->transferCharacteristics = sequenceHeader.transferCharacteristics; decoder->image->matrixCoefficients = sequenceHeader.matrixCoefficients; decoder->image->yuvRange = sequenceHeader.range; break; } } while (searchSampleSize != sample->size && searchSampleSize < searchSampleSizeMax); } } const avifProperty * configProp = avifPropertyArrayFind(colorProperties, avifGetConfigurationPropertyName(colorCodecType)); if (configProp) { decoder->image->depth = avifCodecConfigurationBoxGetDepth(&configProp->u.av1C); if (configProp->u.av1C.monochrome) { decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV400; } else { if (configProp->u.av1C.chromaSubsamplingX && configProp->u.av1C.chromaSubsamplingY) { decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV420; } else if (configProp->u.av1C.chromaSubsamplingX) { decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV422; } else { decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; } } decoder->image->yuvChromaSamplePosition = (avifChromaSamplePosition)configProp->u.av1C.chromaSamplePosition; } else { // A configuration property box is mandatory in all valid AVIF configurations. Bail out. return AVIF_RESULT_BMFF_PARSE_FAILED; } return AVIF_RESULT_OK; } static avifResult avifDecoderPrepareTiles(avifDecoder * decoder, uint32_t nextImageIndex, const avifTileInfo * info) { for (unsigned int tileIndex = info->decodedTileCount; tileIndex < info->tileCount; ++tileIndex) { avifTile * tile = &decoder->data->tiles.tile[info->firstTileIndex + tileIndex]; if (nextImageIndex >= tile->input->samples.count) { return AVIF_RESULT_NO_IMAGES_REMAINING; } avifDecodeSample * sample = &tile->input->samples.sample[nextImageIndex]; avifResult prepareResult = avifDecoderPrepareSample(decoder, sample, 0); if (prepareResult != AVIF_RESULT_OK) { return prepareResult; } } return AVIF_RESULT_OK; } static avifResult avifImageLimitedToFullAlpha(avifImage * image) { if (image->imageOwnsAlphaPlane) { return AVIF_RESULT_NOT_IMPLEMENTED; } const uint8_t * alphaPlane = image->alphaPlane; const uint32_t alphaRowBytes = image->alphaRowBytes; // We cannot do the range conversion in place since it will modify the // codec's internal frame buffers. Allocate memory for the conversion. image->alphaPlane = NULL; image->alphaRowBytes = 0; const avifResult allocationResult = avifImageAllocatePlanes(image, AVIF_PLANES_A); if (allocationResult != AVIF_RESULT_OK) { return allocationResult; } if (image->depth > 8) { for (uint32_t j = 0; j < image->height; ++j) { const uint8_t * srcRow = &alphaPlane[j * alphaRowBytes]; uint8_t * dstRow = &image->alphaPlane[j * image->alphaRowBytes]; for (uint32_t i = 0; i < image->width; ++i) { int srcAlpha = *((const uint16_t *)&srcRow[i * 2]); int dstAlpha = avifLimitedToFullY(image->depth, srcAlpha); *((uint16_t *)&dstRow[i * 2]) = (uint16_t)dstAlpha; } } } else { for (uint32_t j = 0; j < image->height; ++j) { const uint8_t * srcRow = &alphaPlane[j * alphaRowBytes]; uint8_t * dstRow = &image->alphaPlane[j * image->alphaRowBytes]; for (uint32_t i = 0; i < image->width; ++i) { int srcAlpha = srcRow[i]; int dstAlpha = avifLimitedToFullY(image->depth, srcAlpha); dstRow[i] = (uint8_t)dstAlpha; } } } return AVIF_RESULT_OK; } static avifResult avifGetErrorForItemCategory(avifItemCategory itemCategory) { return (itemCategory == AVIF_ITEM_ALPHA) ? AVIF_RESULT_DECODE_ALPHA_FAILED : AVIF_RESULT_DECODE_COLOR_FAILED; } static avifResult avifDecoderDecodeTiles(avifDecoder * decoder, uint32_t nextImageIndex, avifTileInfo * info) { const unsigned int oldDecodedTileCount = info->decodedTileCount; for (unsigned int tileIndex = oldDecodedTileCount; tileIndex < info->tileCount; ++tileIndex) { avifTile * tile = &decoder->data->tiles.tile[info->firstTileIndex + tileIndex]; const avifDecodeSample * sample = &tile->input->samples.sample[nextImageIndex]; if (sample->data.size < sample->size) { assert(decoder->allowIncremental); // Data is missing but there is no error yet. Output available pixel rows. return AVIF_RESULT_OK; } avifBool isLimitedRangeAlpha = AVIF_FALSE; if (!tile->codec->getNextImage(tile->codec, decoder, sample, tile->input->itemCategory == AVIF_ITEM_ALPHA, &isLimitedRangeAlpha, tile->image)) { avifDiagnosticsPrintf(&decoder->diag, "tile->codec->getNextImage() failed"); return avifGetErrorForItemCategory(tile->input->itemCategory); } // Alpha plane with limited range is not allowed by the latest revision // of the specification. However, it was allowed in version 1.0.0 of the // specification. To allow such files, simply convert the alpha plane to // full range. if ((tile->input->itemCategory == AVIF_ITEM_ALPHA) && isLimitedRangeAlpha) { avifResult result = avifImageLimitedToFullAlpha(tile->image); if (result != AVIF_RESULT_OK) { avifDiagnosticsPrintf(&decoder->diag, "avifImageLimitedToFullAlpha failed"); return result; } } // Scale the decoded image so that it corresponds to this tile's output dimensions if ((tile->width != tile->image->width) || (tile->height != tile->image->height)) { if (!avifImageScale(tile->image, tile->width, tile->height, decoder->imageSizeLimit, decoder->imageDimensionLimit, &decoder->diag)) { avifDiagnosticsPrintf(&decoder->diag, "avifImageScale() failed"); return avifGetErrorForItemCategory(tile->input->itemCategory); } } ++info->decodedTileCount; if ((info->grid.rows > 0) && (info->grid.columns > 0)) { if (tileIndex == 0) { AVIF_CHECKRES(avifDecoderDataAllocateGridImagePlanes(decoder->data, info, decoder->image)); } if (!avifDecoderDataCopyTileToImage(decoder->data, info, decoder->image, tile, tileIndex)) { return AVIF_RESULT_INVALID_IMAGE_GRID; } } else { // Non-grid path. Just steal the planes from the only "tile". assert(info->tileCount == 1); assert(tileIndex == 0); avifImage * src = tile->image; if ((decoder->image->width != src->width) || (decoder->image->height != src->height) || (decoder->image->depth != src->depth)) { if (tile->input->itemCategory == AVIF_ITEM_ALPHA) { avifDiagnosticsPrintf(&decoder->diag, "The color image item does not match the alpha image item in width, height, or bit depth"); return AVIF_RESULT_DECODE_ALPHA_FAILED; } avifImageFreePlanes(decoder->image, AVIF_PLANES_ALL); decoder->image->width = src->width; decoder->image->height = src->height; decoder->image->depth = src->depth; } avifImageStealPlanes(decoder->image, src, tile->input->itemCategory == AVIF_ITEM_ALPHA ? AVIF_PLANES_A : AVIF_PLANES_YUV); } } return AVIF_RESULT_OK; } avifResult avifDecoderNextImage(avifDecoder * decoder) { avifDiagnosticsClearError(&decoder->diag); if (!decoder->data || decoder->data->tiles.count == 0) { // Nothing has been parsed yet return AVIF_RESULT_NO_CONTENT; } if (!decoder->io || !decoder->io->read) { return AVIF_RESULT_IO_NOT_SET; } if ((decoder->data->color.decodedTileCount == decoder->data->color.tileCount) && (decoder->data->alpha.decodedTileCount == decoder->data->alpha.tileCount)) { // A frame was decoded during the last avifDecoderNextImage() call. decoder->data->color.decodedTileCount = 0; decoder->data->alpha.decodedTileCount = 0; } assert(decoder->data->tiles.count == (decoder->data->color.tileCount + decoder->data->alpha.tileCount)); const uint32_t nextImageIndex = (uint32_t)(decoder->imageIndex + 1); // Ensure that we have created the codecs before proceeding with the decoding. if (!decoder->data->tiles.tile[0].codec) { AVIF_CHECKRES(avifDecoderCreateCodecs(decoder)); } // Acquire all sample data for the current image first, allowing for any read call to bail out // with AVIF_RESULT_WAITING_ON_IO harmlessly / idempotently, unless decoder->allowIncremental. // Start with color tiles. const avifResult prepareColorTileResult = avifDecoderPrepareTiles(decoder, nextImageIndex, &decoder->data->color); if (!decoder->allowIncremental || (prepareColorTileResult != AVIF_RESULT_WAITING_ON_IO)) { AVIF_CHECKRES(prepareColorTileResult); } // Do the same with alpha tiles. They are handled separately because their // order of appearance relative to the color tiles in the bitstream is left // to the encoder's choice, and decoding as many as possible of each // category in parallel is beneficial for incremental decoding, as pixel // rows need all channels to be decoded before being accessible to the user. const avifResult prepareAlphaTileResult = avifDecoderPrepareTiles(decoder, nextImageIndex, &decoder->data->alpha); if (!decoder->allowIncremental || (prepareAlphaTileResult != AVIF_RESULT_WAITING_ON_IO)) { AVIF_CHECKRES(prepareAlphaTileResult); } // Decode all available color tiles now, then all available alpha tiles. AVIF_CHECKRES(avifDecoderDecodeTiles(decoder, nextImageIndex, &decoder->data->color)); AVIF_CHECKRES(avifDecoderDecodeTiles(decoder, nextImageIndex, &decoder->data->alpha)); if ((decoder->data->color.decodedTileCount != decoder->data->color.tileCount) || (decoder->data->alpha.decodedTileCount != decoder->data->alpha.tileCount)) { assert(decoder->allowIncremental); // The image is not completely decoded. There should be no error unrelated to missing bytes, // and at least some missing bytes. assert((prepareColorTileResult == AVIF_RESULT_WAITING_ON_IO) || (prepareAlphaTileResult == AVIF_RESULT_WAITING_ON_IO)); // Return the "not enough bytes" status now instead of moving on to the next frame. return AVIF_RESULT_WAITING_ON_IO; } assert((prepareColorTileResult == AVIF_RESULT_OK) && (prepareAlphaTileResult == AVIF_RESULT_OK)); // Only advance decoder->imageIndex once the image is completely decoded, so that // avifDecoderNthImage(decoder, decoder->imageIndex + 1) is equivalent to avifDecoderNextImage(decoder) // if the previous call to avifDecoderNextImage() returned AVIF_RESULT_WAITING_ON_IO. decoder->imageIndex = (int)nextImageIndex; // The decoded tile counts will be reset to 0 the next time avifDecoderNextImage() is called, // for avifDecoderDecodedRowCount() to work until then. if (decoder->data->sourceSampleTable) { // Decoding from a track! Provide timing information. avifResult timingResult = avifDecoderNthImageTiming(decoder, decoder->imageIndex, &decoder->imageTiming); if (timingResult != AVIF_RESULT_OK) { return timingResult; } } return AVIF_RESULT_OK; } avifResult avifDecoderNthImageTiming(const avifDecoder * decoder, uint32_t frameIndex, avifImageTiming * outTiming) { if (!decoder->data) { // Nothing has been parsed yet return AVIF_RESULT_NO_CONTENT; } if ((frameIndex > INT_MAX) || ((int)frameIndex >= decoder->imageCount)) { // Impossible index return AVIF_RESULT_NO_IMAGES_REMAINING; } if (!decoder->data->sourceSampleTable) { // There isn't any real timing associated with this decode, so // just hand back the defaults chosen in avifDecoderReset(). *outTiming = decoder->imageTiming; return AVIF_RESULT_OK; } outTiming->timescale = decoder->timescale; outTiming->ptsInTimescales = 0; for (int imageIndex = 0; imageIndex < (int)frameIndex; ++imageIndex) { outTiming->ptsInTimescales += avifSampleTableGetImageDelta(decoder->data->sourceSampleTable, imageIndex); } outTiming->durationInTimescales = avifSampleTableGetImageDelta(decoder->data->sourceSampleTable, frameIndex); if (outTiming->timescale > 0) { outTiming->pts = (double)outTiming->ptsInTimescales / (double)outTiming->timescale; outTiming->duration = (double)outTiming->durationInTimescales / (double)outTiming->timescale; } else { outTiming->pts = 0.0; outTiming->duration = 0.0; } return AVIF_RESULT_OK; } avifResult avifDecoderNthImage(avifDecoder * decoder, uint32_t frameIndex) { avifDiagnosticsClearError(&decoder->diag); if (!decoder->data) { // Nothing has been parsed yet return AVIF_RESULT_NO_CONTENT; } if ((frameIndex > INT_MAX) || ((int)frameIndex >= decoder->imageCount)) { // Impossible index return AVIF_RESULT_NO_IMAGES_REMAINING; } int requestedIndex = (int)frameIndex; if (requestedIndex == (decoder->imageIndex + 1)) { // It's just the next image (already partially decoded or not at all), nothing special here return avifDecoderNextImage(decoder); } if (requestedIndex == decoder->imageIndex) { if ((decoder->data->color.decodedTileCount == decoder->data->color.tileCount) && (decoder->data->alpha.decodedTileCount == decoder->data->alpha.tileCount)) { // The current fully decoded image (decoder->imageIndex) is requested, nothing to do return AVIF_RESULT_OK; } // The next image (decoder->imageIndex + 1) is partially decoded but // the previous image (decoder->imageIndex) is requested. // Fall through to resetting the decoder data and start decoding from // the nearest key frame. } int nearestKeyFrame = (int)avifDecoderNearestKeyframe(decoder, frameIndex); if ((nearestKeyFrame > (decoder->imageIndex + 1)) || (requestedIndex <= decoder->imageIndex)) { // If we get here, we need to start decoding from the nearest key frame. // So discard the unused decoder state and its previous frames. This // will force the setup of new AV1 decoder (avifCodec) instances in // avifDecoderNextImage(). decoder->imageIndex = nearestKeyFrame - 1; // prepare to read nearest keyframe avifDecoderDataResetCodec(decoder->data); } for (;;) { avifResult result = avifDecoderNextImage(decoder); if (result != AVIF_RESULT_OK) { return result; } if (requestedIndex == decoder->imageIndex) { break; } } return AVIF_RESULT_OK; } avifBool avifDecoderIsKeyframe(const avifDecoder * decoder, uint32_t frameIndex) { if (!decoder->data || (decoder->data->tiles.count == 0)) { // Nothing has been parsed yet return AVIF_FALSE; } // *All* tiles for the requested frameIndex must be keyframes in order for // avifDecoderIsKeyframe() to return true, otherwise we may seek to a frame in which the color // planes are a keyframe but the alpha plane isn't a keyframe, which will cause an alpha plane // decode failure. for (unsigned int i = 0; i < decoder->data->tiles.count; ++i) { const avifTile * tile = &decoder->data->tiles.tile[i]; if ((frameIndex >= tile->input->samples.count) || !tile->input->samples.sample[frameIndex].sync) { return AVIF_FALSE; } } return AVIF_TRUE; } uint32_t avifDecoderNearestKeyframe(const avifDecoder * decoder, uint32_t frameIndex) { if (!decoder->data) { // Nothing has been parsed yet return 0; } for (; frameIndex != 0; --frameIndex) { if (avifDecoderIsKeyframe(decoder, frameIndex)) { break; } } return frameIndex; } // Returns the number of available rows in decoder->image given a color or alpha subimage. static uint32_t avifGetDecodedRowCount(const avifDecoder * decoder, const avifTileInfo * info) { if (info->decodedTileCount == info->tileCount) { return decoder->image->height; } if (info->decodedTileCount == 0) { return 0; } if ((info->grid.rows > 0) && (info->grid.columns > 0)) { // Grid of AVIF tiles (not to be confused with AV1 tiles). const uint32_t tileHeight = decoder->data->tiles.tile[info->firstTileIndex].height; return AVIF_MIN((info->decodedTileCount / info->grid.columns) * tileHeight, decoder->image->height); } else { // Non-grid image. return decoder->image->height; } } uint32_t avifDecoderDecodedRowCount(const avifDecoder * decoder) { const uint32_t colorRowCount = avifGetDecodedRowCount(decoder, &decoder->data->color); if (colorRowCount == 0) { return 0; } const uint32_t alphaRowCount = avifGetDecodedRowCount(decoder, &decoder->data->alpha); return AVIF_MIN(colorRowCount, alphaRowCount); } avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image) { avifResult result = avifDecoderParse(decoder); if (result != AVIF_RESULT_OK) { return result; } result = avifDecoderNextImage(decoder); if (result != AVIF_RESULT_OK) { return result; } return avifImageCopy(image, decoder->image, AVIF_PLANES_ALL); } avifResult avifDecoderReadMemory(avifDecoder * decoder, avifImage * image, const uint8_t * data, size_t size) { avifDiagnosticsClearError(&decoder->diag); avifResult result = avifDecoderSetIOMemory(decoder, data, size); if (result != AVIF_RESULT_OK) { return result; } return avifDecoderRead(decoder, image); } avifResult avifDecoderReadFile(avifDecoder * decoder, avifImage * image, const char * filename) { avifDiagnosticsClearError(&decoder->diag); avifResult result = avifDecoderSetIOFile(decoder, filename); if (result != AVIF_RESULT_OK) { return result; } return avifDecoderRead(decoder, image); }