blob: 72edbcab8814b1319dee3448432aeed5b5a269b9 [file] [log] [blame]
// Copyright 2019 Joe Drago. All rights reserved.
// SPDX-License-Identifier: BSD-2-Clause
#include "avifutil.h"
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include "avifjpeg.h"
#include "avifpng.h"
#include "y4m.h"
// |a| and |b| hold int32_t values. The int64_t type is used so that we can negate INT32_MIN without
// overflowing int32_t.
static int64_t calcGCD(int64_t a, int64_t b)
{
if (a < 0) {
a *= -1;
}
if (b < 0) {
b *= -1;
}
while (b != 0) {
int64_t r = a % b;
a = b;
b = r;
}
return a;
}
static void printClapFraction(const char * name, int32_t n, int32_t d)
{
printf("%s: %d/%d", name, n, d);
if (d != 0) {
int64_t gcd = calcGCD(n, d);
if (gcd > 1) {
int32_t rn = (int32_t)(n / gcd);
int32_t rd = (int32_t)(d / gcd);
printf(" (%d/%d)", rn, rd);
}
}
}
static void avifImageDumpInternal(const avifImage * avif,
uint32_t gridCols,
uint32_t gridRows,
avifBool alphaPresent,
avifBool gainMapPresent,
avifProgressiveState progressiveState)
{
uint32_t width = avif->width;
uint32_t height = avif->height;
if (gridCols && gridRows) {
width *= gridCols;
height *= gridRows;
}
printf(" * Resolution : %ux%u\n", width, height);
printf(" * Bit Depth : %u\n", avif->depth);
printf(" * Format : %s\n", avifPixelFormatToString(avif->yuvFormat));
if (avif->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) {
printf(" * Chroma Sam. Pos: %u\n", avif->yuvChromaSamplePosition);
}
printf(" * Alpha : %s\n", alphaPresent ? (avif->alphaPremultiplied ? "Premultiplied" : "Not premultiplied") : "Absent");
printf(" * Range : %s\n", (avif->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited");
printf(" * Color Primaries: %u\n", avif->colorPrimaries);
printf(" * Transfer Char. : %u\n", avif->transferCharacteristics);
printf(" * Matrix Coeffs. : %u\n", avif->matrixCoefficients);
if (avif->icc.size != 0) {
printf(" * ICC Profile : Present (%" AVIF_FMT_ZU " bytes)\n", avif->icc.size);
} else {
printf(" * ICC Profile : Absent\n");
}
if (avif->xmp.size != 0) {
printf(" * XMP Metadata : Present (%" AVIF_FMT_ZU " bytes)\n", avif->xmp.size);
} else {
printf(" * XMP Metadata : Absent\n");
}
if (avif->exif.size != 0) {
printf(" * Exif Metadata : Present (%" AVIF_FMT_ZU " bytes)\n", avif->exif.size);
} else {
printf(" * Exif Metadata : Absent\n");
}
if (avif->transformFlags == AVIF_TRANSFORM_NONE) {
printf(" * Transformations: None\n");
} else {
printf(" * Transformations:\n");
if (avif->transformFlags & AVIF_TRANSFORM_PASP) {
printf(" * pasp (Aspect Ratio) : %d/%d\n", (int)avif->pasp.hSpacing, (int)avif->pasp.vSpacing);
}
if (avif->transformFlags & AVIF_TRANSFORM_CLAP) {
printf(" * clap (Clean Aperture): ");
printClapFraction("W", (int32_t)avif->clap.widthN, (int32_t)avif->clap.widthD);
printf(", ");
printClapFraction("H", (int32_t)avif->clap.heightN, (int32_t)avif->clap.heightD);
printf(", ");
printClapFraction("hOff", (int32_t)avif->clap.horizOffN, (int32_t)avif->clap.horizOffD);
printf(", ");
printClapFraction("vOff", (int32_t)avif->clap.vertOffN, (int32_t)avif->clap.vertOffD);
printf("\n");
avifCropRect cropRect;
avifDiagnostics diag;
avifDiagnosticsClearError(&diag);
avifBool validClap =
avifCropRectConvertCleanApertureBox(&cropRect, &avif->clap, avif->width, avif->height, avif->yuvFormat, &diag);
if (validClap) {
printf(" * Valid, derived crop rect: X: %d, Y: %d, W: %d, H: %d\n",
cropRect.x,
cropRect.y,
cropRect.width,
cropRect.height);
} else {
printf(" * Invalid: %s\n", diag.error);
}
}
if (avif->transformFlags & AVIF_TRANSFORM_IROT) {
printf(" * irot (Rotation) : %u\n", avif->irot.angle);
}
if (avif->transformFlags & AVIF_TRANSFORM_IMIR) {
printf(" * imir (Mirror) : %u (%s)\n", avif->imir.axis, (avif->imir.axis == 0) ? "top-to-bottom" : "left-to-right");
}
}
printf(" * Progressive : %s\n", avifProgressiveStateToString(progressiveState));
if (avif->clli.maxCLL > 0 || avif->clli.maxPALL > 0) {
printf(" * CLLI : %hu, %hu\n", avif->clli.maxCLL, avif->clli.maxPALL);
}
#if defined(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP)
printf(" * Gain map : ");
avifImage * gainMapImage = avif->gainMap ? avif->gainMap->image : NULL;
if (gainMapImage != NULL) {
printf("%ux%u pixels, %u bit, %s, %s Range, Matrix Coeffs. %u, Base Image is %s\n",
gainMapImage->width,
gainMapImage->height,
gainMapImage->depth,
avifPixelFormatToString(gainMapImage->yuvFormat),
(gainMapImage->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited",
gainMapImage->matrixCoefficients,
(avif->gainMap->metadata.baseHdrHeadroomN == 0) ? "SDR" : "HDR");
printf(" * Alternate image:\n");
printf(" * Color Primaries: %u\n", avif->gainMap->altColorPrimaries);
printf(" * Transfer Char. : %u\n", avif->gainMap->altTransferCharacteristics);
printf(" * Matrix Coeffs. : %u\n", avif->gainMap->altMatrixCoefficients);
if (avif->gainMap->altICC.size != 0) {
printf(" * ICC Profile : Present (%" AVIF_FMT_ZU " bytes)\n", avif->gainMap->altICC.size);
} else {
printf(" * ICC Profile : Absent\n");
}
if (avif->gainMap->altDepth) {
printf(" * Bit Depth : %u\n", avif->gainMap->altDepth);
}
if (avif->gainMap->altPlaneCount) {
printf(" * Planes : %u\n", avif->gainMap->altPlaneCount);
}
if (gainMapImage->clli.maxCLL > 0 || gainMapImage->clli.maxPALL > 0) {
printf(" * CLLI : %hu, %hu\n", gainMapImage->clli.maxCLL, gainMapImage->clli.maxPALL);
}
printf("\n");
} else if (gainMapPresent) {
printf("Present (but ignored)\n");
} else {
printf("Absent\n");
}
#else
(void)gainMapPresent;
#endif // AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP
}
void avifImageDump(const avifImage * avif, uint32_t gridCols, uint32_t gridRows, avifBool gainMapPresent, avifProgressiveState progressiveState)
{
const avifBool alphaPresent = avif->alphaPlane && (avif->alphaRowBytes > 0);
avifImageDumpInternal(avif, gridCols, gridRows, alphaPresent, gainMapPresent, progressiveState);
}
void avifContainerDump(const avifDecoder * decoder)
{
avifBool gainMapPresent = AVIF_FALSE;
#if defined(AVIF_ENABLE_EXPERIMENTAL_GAIN_MAP)
gainMapPresent = decoder->gainMapPresent;
#endif
avifImageDumpInternal(decoder->image, 0, 0, decoder->alphaPresent, gainMapPresent, decoder->progressiveState);
if (decoder->imageSequenceTrackPresent) {
if (decoder->repetitionCount == AVIF_REPETITION_COUNT_INFINITE) {
printf(" * Repeat Count : Infinite\n");
} else if (decoder->repetitionCount == AVIF_REPETITION_COUNT_UNKNOWN) {
printf(" * Repeat Count : Unknown\n");
} else {
printf(" * Repeat Count : %d\n", decoder->repetitionCount);
}
}
}
void avifPrintVersions(void)
{
char codecVersions[256];
avifCodecVersions(codecVersions);
printf("Version: %s (%s)\n", avifVersion(), codecVersions);
unsigned int libyuvVersion = avifLibYUVVersion();
if (libyuvVersion == 0) {
printf("libyuv : unavailable\n");
} else {
printf("libyuv : available (%u)\n", libyuvVersion);
}
printf("\n");
}
avifAppFileFormat avifGuessFileFormat(const char * filename)
{
// Guess from the file header
FILE * f = fopen(filename, "rb");
if (f) {
uint8_t headerBuffer[144];
size_t bytesRead = fread(headerBuffer, 1, sizeof(headerBuffer), f);
fclose(f);
if (bytesRead > 0) {
// If the file could be read, use the first bytes to guess the file format.
return avifGuessBufferFileFormat(headerBuffer, bytesRead);
}
}
// If we get here, the file header couldn't be read for some reason. Guess from the extension.
const char * fileExt = strrchr(filename, '.');
if (!fileExt) {
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
++fileExt; // skip past the dot
char lowercaseExt[8]; // This only needs to fit up to "jpeg", so this is plenty
const size_t fileExtLen = strlen(fileExt);
if (fileExtLen >= sizeof(lowercaseExt)) { // >= accounts for NULL terminator
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
for (size_t i = 0; i < fileExtLen; ++i) {
lowercaseExt[i] = (char)tolower((unsigned char)fileExt[i]);
}
lowercaseExt[fileExtLen] = 0;
if (!strcmp(lowercaseExt, "avif")) {
return AVIF_APP_FILE_FORMAT_AVIF;
} else if (!strcmp(lowercaseExt, "y4m")) {
return AVIF_APP_FILE_FORMAT_Y4M;
} else if (!strcmp(lowercaseExt, "jpg") || !strcmp(lowercaseExt, "jpeg")) {
return AVIF_APP_FILE_FORMAT_JPEG;
} else if (!strcmp(lowercaseExt, "png")) {
return AVIF_APP_FILE_FORMAT_PNG;
}
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
avifAppFileFormat avifGuessBufferFileFormat(const uint8_t * data, size_t size)
{
if (size == 0) {
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
avifROData header;
header.data = data;
header.size = size;
if (avifPeekCompatibleFileType(&header)) {
return AVIF_APP_FILE_FORMAT_AVIF;
}
static const uint8_t signatureJPEG[2] = { 0xFF, 0xD8 };
static const uint8_t signaturePNG[8] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
static const uint8_t signatureY4M[9] = { 0x59, 0x55, 0x56, 0x34, 0x4D, 0x50, 0x45, 0x47, 0x32 }; // "YUV4MPEG2"
struct avifHeaderSignature
{
avifAppFileFormat format;
const uint8_t * magic;
size_t magicSize;
} signatures[] = { { AVIF_APP_FILE_FORMAT_JPEG, signatureJPEG, sizeof(signatureJPEG) },
{ AVIF_APP_FILE_FORMAT_PNG, signaturePNG, sizeof(signaturePNG) },
{ AVIF_APP_FILE_FORMAT_Y4M, signatureY4M, sizeof(signatureY4M) } };
const size_t signaturesCount = sizeof(signatures) / sizeof(signatures[0]);
for (size_t signatureIndex = 0; signatureIndex < signaturesCount; ++signatureIndex) {
const struct avifHeaderSignature * const signature = &signatures[signatureIndex];
if (header.size < signature->magicSize) {
continue;
}
if (!memcmp(header.data, signature->magic, signature->magicSize)) {
return signature->format;
}
}
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
avifAppFileFormat avifReadImage(const char * filename,
avifPixelFormat requestedFormat,
int requestedDepth,
avifChromaDownsampling chromaDownsampling,
avifBool ignoreColorProfile,
avifBool ignoreExif,
avifBool ignoreXMP,
avifBool allowChangingCicp,
avifBool ignoreGainMap,
uint32_t imageSizeLimit,
avifImage * image,
uint32_t * outDepth,
avifAppSourceTiming * sourceTiming,
struct y4mFrameIterator ** frameIter)
{
const avifAppFileFormat format = avifGuessFileFormat(filename);
if (format == AVIF_APP_FILE_FORMAT_Y4M) {
if (!y4mRead(filename, imageSizeLimit, image, sourceTiming, frameIter)) {
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
if (outDepth) {
*outDepth = image->depth;
}
} else if (format == AVIF_APP_FILE_FORMAT_JPEG) {
// imageSizeLimit is also used to limit Exif and XMP metadata here.
if (!avifJPEGRead(filename, image, requestedFormat, requestedDepth, chromaDownsampling, ignoreColorProfile, ignoreExif, ignoreXMP, ignoreGainMap, imageSizeLimit)) {
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
if (outDepth) {
*outDepth = 8;
}
} else if (format == AVIF_APP_FILE_FORMAT_PNG) {
if (!avifPNGRead(filename,
image,
requestedFormat,
requestedDepth,
chromaDownsampling,
ignoreColorProfile,
ignoreExif,
ignoreXMP,
allowChangingCicp,
imageSizeLimit,
outDepth)) {
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
} else {
fprintf(stderr, "Unrecognized file format for input file: %s\n", filename);
return AVIF_APP_FILE_FORMAT_UNKNOWN;
}
return format;
}
avifBool avifReadEntireFile(const char * filename, avifRWData * raw)
{
FILE * f = fopen(filename, "rb");
if (!f) {
return AVIF_FALSE;
}
fseek(f, 0, SEEK_END);
long pos = ftell(f);
if (pos <= 0) {
fclose(f);
return AVIF_FALSE;
}
size_t fileSize = (size_t)pos;
fseek(f, 0, SEEK_SET);
if (avifRWDataRealloc(raw, fileSize) != AVIF_RESULT_OK) {
fclose(f);
return AVIF_FALSE;
}
size_t bytesRead = fread(raw->data, 1, fileSize, f);
fclose(f);
if (bytesRead != fileSize) {
avifRWDataFree(raw);
return AVIF_FALSE;
}
return AVIF_TRUE;
}
void avifImageFixXMP(avifImage * image)
{
// Zero bytes are forbidden in UTF-8 XML: https://en.wikipedia.org/wiki/Valid_characters_in_XML
// Keeping zero bytes in XMP may lead to issues at encoding or decoding.
// For example, the PNG specification forbids null characters in XMP. See avifPNGWrite().
// The XMP Specification Part 3 says "When XMP is encoded as UTF-8,
// there are no zero bytes in the XMP packet" for GIF.
// Consider a single trailing null character following a non-null character
// as a programming error. Leave other null characters as is.
// See the discussion at https://github.com/AOMediaCodec/libavif/issues/1333.
if (image->xmp.size >= 2 && image->xmp.data[image->xmp.size - 1] == '\0' && image->xmp.data[image->xmp.size - 2] != '\0') {
--image->xmp.size;
}
}
void avifDumpDiagnostics(const avifDiagnostics * diag)
{
if (!*diag->error) {
return;
}
printf("Diagnostics:\n");
printf(" * %s\n", diag->error);
}
// ---------------------------------------------------------------------------
// avifQueryCPUCount (separated into OS implementations)
#if defined(_WIN32)
// Windows
#include <windows.h>
int avifQueryCPUCount(void)
{
int numCPU;
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
numCPU = sysinfo.dwNumberOfProcessors;
return numCPU;
}
#elif defined(__APPLE__)
// Apple
#include <sys/sysctl.h>
int avifQueryCPUCount()
{
int mib[4];
int numCPU;
size_t len = sizeof(numCPU);
/* set the mib for hw.ncpu */
mib[0] = CTL_HW;
mib[1] = HW_AVAILCPU; // alternatively, try HW_NCPU;
/* get the number of CPUs from the system */
sysctl(mib, 2, &numCPU, &len, NULL, 0);
if (numCPU < 1) {
mib[1] = HW_NCPU;
sysctl(mib, 2, &numCPU, &len, NULL, 0);
if (numCPU < 1)
numCPU = 1;
}
return numCPU;
}
#elif defined(__EMSCRIPTEN__)
// Emscripten
int avifQueryCPUCount()
{
return 1;
}
#else
// POSIX
#include <unistd.h>
int avifQueryCPUCount()
{
int numCPU = (int)sysconf(_SC_NPROCESSORS_ONLN);
return (numCPU > 0) ? numCPU : 1;
}
#endif