Function avifDecoderApplySampleTransformForPlanesImpl

src/read.c:6873–6924

Composites hidden image items and/or the primary image item into the dstImage. Tiles are aggregated into temporary buffers (reconstructedInputImages) covering the whole dstImage dimensions in case of grids. Non-null elements of reconstructedInputImages must be destroyed after calling this function.

// covering the whole dstImage dimensions in case of grids.
// Non-null elements of reconstructedInputImages must be destroyed after calling this function.
static avifResult avifDecoderApplySampleTransformForPlanesImpl(const avifDecoder * decoder,
                                                               avifPlanesFlag planes,
                                                               avifImage * dstImage,
                                                               avifImage * reconstructedInputImages[AVIF_SAMPLE_TRANSFORM_MAX_NUM_INPUT_IMAGE_ITEMS])
{
    AVIF_ASSERT_OR_RETURN(decoder->data->sampleTransformNumInputImageItems != 0);
    AVIF_ASSERT_OR_RETURN(decoder->data->sampleTransformNumInputImageItems <= AVIF_SAMPLE_TRANSFORM_MAX_NUM_INPUT_IMAGE_ITEMS);
    const avifImage * inputImages[AVIF_SAMPLE_TRANSFORM_MAX_NUM_INPUT_IMAGE_ITEMS];
    for (uint32_t i = 0; i < decoder->data->sampleTransformNumInputImageItems; ++i) {
        avifItemCategory category = decoder->data->sampleTransformInputImageItems[i];
        if (category == AVIF_ITEM_COLOR) {
            // If the primary image item was a grid, it was already aggregated
            // into this single output buffer in avifDecoderDecodeTiles().
            inputImages[i] = decoder->image;
        } else {
            AVIF_ASSERT_OR_RETURN(category >= AVIF_ITEM_SAMPLE_TRANSFORM_INPUT_0_COLOR &&
                                  category < AVIF_ITEM_SAMPLE_TRANSFORM_INPUT_0_COLOR +
                                                 AVIF_SAMPLE_TRANSFORM_MAX_NUM_EXTRA_INPUT_IMAGE_ITEMS);
            if (planes == AVIF_PLANES_A) {
                category += AVIF_SAMPLE_TRANSFORM_MAX_NUM_EXTRA_INPUT_IMAGE_ITEMS;
            }
            const avifTileInfo * info = &decoder->data->tileInfos[category];
            AVIF_ASSERT_OR_RETURN(info != NULL);
            const avifTile * firstTile = &decoder->data->tiles.tile[info->firstTileIndex];
            AVIF_ASSERT_OR_RETURN(firstTile != NULL && firstTile->image != NULL);
            if (info->tileCount == 1) {
                inputImages[i] = firstTile->image;
            } else {
                // Combine the tiles into a single buffer used as one of the input images in avifImageApplyExpression().
                reconstructedInputImages[i] = avifImageCreateEmpty();
                AVIF_CHECKERR(reconstructedInputImages[i] != NULL, AVIF_RESULT_OUT_OF_MEMORY);
                avifImageCopyNoAlloc(reconstructedInputImages[i], firstTile->image);
                reconstructedInputImages[i]->width = decoder->image->width;
                reconstructedInputImages[i]->height = decoder->image->height;
                avifBool cicpSet = AVIF_TRUE;
                AVIF_CHECKRES(avifDecoderDataAllocateImagePlanes(decoder->data, info, reconstructedInputImages[i], &cicpSet));
                for (unsigned int tileIndex = 0; tileIndex < info->tileCount; ++tileIndex) {
                    const avifTile * tile = firstTile + tileIndex;
                    AVIF_CHECKRES(avifDecoderDataCopyTileToImage(decoder->data, info, reconstructedInputImages[i], tile, tileIndex));
                }
                inputImages[i] = reconstructedInputImages[i];
            }
        }
    }
    AVIF_CHECKRES(avifImageApplyExpression(dstImage,
                                           AVIF_SAMPLE_TRANSFORM_BIT_DEPTH_32,
                                           &decoder->data->meta->sampleTransformExpression,
                                           decoder->data->sampleTransformNumInputImageItems,
                                           inputImages,
                                           planes));
    return AVIF_RESULT_OK;
}

// Intermediate function used to safely destroy temporary buffers even in case of error.
static avifResult avifDecoderApplySampleTransformForPlanes(const avifDecoder * decoder, avifPlanesFlag planes, avifImage * dstImage)