blob: 0e178b17b8ce4ea75fb29f0d944d8c6dbccd6030 [file] [log] [blame]
// Copyright 2021 Joe Drago. All rights reserved.
// SPDX-License-Identifier: BSD-2-Clause
#include "avif/internal.h"
#if !defined(AVIF_LIBYUV_ENABLED)
avifBool avifImageScale(avifImage * image,
uint32_t dstWidth,
uint32_t dstHeight,
uint32_t imageSizeLimit,
uint32_t imageDimensionLimit,
avifDiagnostics * diag)
{
(void)image;
(void)dstWidth;
(void)dstHeight;
(void)imageSizeLimit;
(void)imageDimensionLimit;
avifDiagnosticsPrintf(diag, "avifImageScale() called, but is unimplemented without libyuv!");
return AVIF_FALSE;
}
#else
#include <limits.h>
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wstrict-prototypes" // "this function declaration is not a prototype"
// The newline at the end of libyuv/version.h was accidentally deleted in version 1792 and restored
// in version 1813:
// https://chromium-review.googlesource.com/c/libyuv/libyuv/+/3183182
// https://chromium-review.googlesource.com/c/libyuv/libyuv/+/3527834
#pragma clang diagnostic ignored "-Wnewline-eof" // "no newline at end of file"
#endif
#include <libyuv.h>
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
// This should be configurable and/or smarter. kFilterBox has the highest quality but is the slowest.
#define AVIF_LIBYUV_FILTER_MODE kFilterBox
avifBool avifImageScale(avifImage * image,
uint32_t dstWidth,
uint32_t dstHeight,
uint32_t imageSizeLimit,
uint32_t imageDimensionLimit,
avifDiagnostics * diag)
{
if ((image->width == dstWidth) && (image->height == dstHeight)) {
// Nothing to do
return AVIF_TRUE;
}
if ((dstWidth == 0) || (dstHeight == 0)) {
avifDiagnosticsPrintf(diag, "avifImageScale requested invalid dst dimensions [%ux%u]", dstWidth, dstHeight);
return AVIF_FALSE;
}
if (avifDimensionsTooLarge(dstWidth, dstHeight, imageSizeLimit, imageDimensionLimit)) {
avifDiagnosticsPrintf(diag, "avifImageScale requested dst dimensions that are too large [%ux%u]", dstWidth, dstHeight);
return AVIF_FALSE;
}
uint8_t * srcYUVPlanes[AVIF_PLANE_COUNT_YUV];
uint32_t srcYUVRowBytes[AVIF_PLANE_COUNT_YUV];
for (int i = 0; i < AVIF_PLANE_COUNT_YUV; ++i) {
srcYUVPlanes[i] = image->yuvPlanes[i];
image->yuvPlanes[i] = NULL;
srcYUVRowBytes[i] = image->yuvRowBytes[i];
image->yuvRowBytes[i] = 0;
}
const avifBool srcImageOwnsYUVPlanes = image->imageOwnsYUVPlanes;
image->imageOwnsYUVPlanes = AVIF_FALSE;
uint8_t * srcAlphaPlane = image->alphaPlane;
image->alphaPlane = NULL;
uint32_t srcAlphaRowBytes = image->alphaRowBytes;
image->alphaRowBytes = 0;
const avifBool srcImageOwnsAlphaPlane = image->imageOwnsAlphaPlane;
image->imageOwnsAlphaPlane = AVIF_FALSE;
const uint32_t srcWidth = image->width;
const uint32_t srcHeight = image->height;
const uint32_t srcUVWidth = avifImagePlaneWidth(image, AVIF_CHAN_U);
const uint32_t srcUVHeight = avifImagePlaneHeight(image, AVIF_CHAN_U);
image->width = dstWidth;
image->height = dstHeight;
if (srcYUVPlanes[0] || srcAlphaPlane) {
// A simple conservative check to avoid integer overflows in libyuv's ScalePlane() and
// ScalePlane_12() functions.
if (srcWidth > 16384) {
avifDiagnosticsPrintf(diag, "avifImageScale requested invalid width scale for libyuv [%u -> %u]", srcWidth, dstWidth);
return AVIF_FALSE;
}
if (srcHeight > 16384) {
avifDiagnosticsPrintf(diag, "avifImageScale requested invalid height scale for libyuv [%u -> %u]", srcHeight, dstHeight);
return AVIF_FALSE;
}
}
if (srcYUVPlanes[0]) {
const avifResult allocationResult = avifImageAllocatePlanes(image, AVIF_PLANES_YUV);
if (allocationResult != AVIF_RESULT_OK) {
avifDiagnosticsPrintf(diag, "Allocation of YUV planes failed: %s", avifResultToString(allocationResult));
return AVIF_FALSE;
}
for (int i = 0; i < AVIF_PLANE_COUNT_YUV; ++i) {
if (!srcYUVPlanes[i]) {
continue;
}
const uint32_t srcW = (i == AVIF_CHAN_Y) ? srcWidth : srcUVWidth;
const uint32_t srcH = (i == AVIF_CHAN_Y) ? srcHeight : srcUVHeight;
const uint32_t dstW = avifImagePlaneWidth(image, i);
const uint32_t dstH = avifImagePlaneHeight(image, i);
if (image->depth > 8) {
uint16_t * const srcPlane = (uint16_t *)srcYUVPlanes[i];
const uint32_t srcStride = srcYUVRowBytes[i] / 2;
uint16_t * const dstPlane = (uint16_t *)image->yuvPlanes[i];
const uint32_t dstStride = image->yuvRowBytes[i] / 2;
#if LIBYUV_VERSION >= 1774
ScalePlane_12(srcPlane, srcStride, srcW, srcH, dstPlane, dstStride, dstW, dstH, AVIF_LIBYUV_FILTER_MODE);
#else
ScalePlane_16(srcPlane, srcStride, srcW, srcH, dstPlane, dstStride, dstW, dstH, AVIF_LIBYUV_FILTER_MODE);
#endif
} else {
uint8_t * const srcPlane = srcYUVPlanes[i];
const uint32_t srcStride = srcYUVRowBytes[i];
uint8_t * const dstPlane = image->yuvPlanes[i];
const uint32_t dstStride = image->yuvRowBytes[i];
ScalePlane(srcPlane, srcStride, srcW, srcH, dstPlane, dstStride, dstW, dstH, AVIF_LIBYUV_FILTER_MODE);
}
if (srcImageOwnsYUVPlanes) {
avifFree(srcYUVPlanes[i]);
}
}
}
if (srcAlphaPlane) {
const avifResult allocationResult = avifImageAllocatePlanes(image, AVIF_PLANES_A);
if (allocationResult != AVIF_RESULT_OK) {
avifDiagnosticsPrintf(diag, "Allocation of alpha plane failed: %s", avifResultToString(allocationResult));
return AVIF_FALSE;
}
if (image->depth > 8) {
uint16_t * const srcPlane = (uint16_t *)srcAlphaPlane;
const uint32_t srcStride = srcAlphaRowBytes / 2;
uint16_t * const dstPlane = (uint16_t *)image->alphaPlane;
const uint32_t dstStride = image->alphaRowBytes / 2;
#if LIBYUV_VERSION >= 1774
ScalePlane_12(srcPlane, srcStride, srcWidth, srcHeight, dstPlane, dstStride, dstWidth, dstHeight, AVIF_LIBYUV_FILTER_MODE);
#else
ScalePlane_16(srcPlane, srcStride, srcWidth, srcHeight, dstPlane, dstStride, dstWidth, dstHeight, AVIF_LIBYUV_FILTER_MODE);
#endif
} else {
uint8_t * const srcPlane = srcAlphaPlane;
const uint32_t srcStride = srcAlphaRowBytes;
uint8_t * const dstPlane = image->alphaPlane;
const uint32_t dstStride = image->alphaRowBytes;
ScalePlane(srcPlane, srcStride, srcWidth, srcHeight, dstPlane, dstStride, dstWidth, dstHeight, AVIF_LIBYUV_FILTER_MODE);
}
if (srcImageOwnsAlphaPlane) {
avifFree(srcAlphaPlane);
}
}
return AVIF_TRUE;
}
#endif