system: Linux mars.sprixweb.com 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
// Copyright 2020 Joe Drago. All rights reserved.
// SPDX-License-Identifier: BSD-2-Clause
// #define WIN32_MEMORY_LEAK_DETECTION
#ifdef WIN32_MEMORY_LEAK_DETECTION
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif
#include "avif/avif.h"
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(_WIN32)
#include <windows.h>
typedef struct NextFilenameData
{
int didFirstFile;
HANDLE handle;
WIN32_FIND_DATA wfd;
} NextFilenameData;
static const char * nextFilename(const char * parentDir, const char * extension, NextFilenameData * nfd)
{
for (;;) {
if (nfd->didFirstFile) {
if (FindNextFile(nfd->handle, &nfd->wfd) == 0) {
// No more files
break;
}
} else {
char filenameBuffer[2048];
snprintf(filenameBuffer, sizeof(filenameBuffer), "%s\\*", parentDir);
filenameBuffer[sizeof(filenameBuffer) - 1] = 0;
nfd->handle = FindFirstFile(filenameBuffer, &nfd->wfd);
if (nfd->handle == INVALID_HANDLE_VALUE) {
return NULL;
}
nfd->didFirstFile = 1;
}
// If we get here, we should have a valid wfd
const char * dot = strrchr(nfd->wfd.cFileName, '.');
if (dot) {
++dot;
if (!strcmp(dot, extension)) {
return nfd->wfd.cFileName;
}
}
}
FindClose(nfd->handle);
nfd->handle = INVALID_HANDLE_VALUE;
nfd->didFirstFile = 0;
return NULL;
}
#else
#include <dirent.h>
typedef struct NextFilenameData
{
DIR * dir;
} NextFilenameData;
static const char * nextFilename(const char * parentDir, const char * extension, NextFilenameData * nfd)
{
if (!nfd->dir) {
nfd->dir = opendir(parentDir);
if (!nfd->dir) {
return NULL;
}
}
struct dirent * entry;
while ((entry = readdir(nfd->dir)) != NULL) {
const char * dot = strrchr(entry->d_name, '.');
if (dot) {
++dot;
if (!strcmp(dot, extension)) {
return entry->d_name;
}
}
}
closedir(nfd->dir);
nfd->dir = NULL;
return NULL;
}
#endif
typedef struct avifIOTestReader
{
avifIO io;
avifROData rodata;
size_t availableBytes;
} avifIOTestReader;
static avifResult avifIOTestReaderRead(struct avifIO * io, uint32_t readFlags, uint64_t offset, size_t size, avifROData * out)
{
// printf("avifIOTestReaderRead offset %" PRIu64 " size %zu\n", offset, size);
if (readFlags != 0) {
// Unsupported readFlags
return AVIF_RESULT_IO_ERROR;
}
avifIOTestReader * reader = (avifIOTestReader *)io;
// Sanitize/clamp incoming request
if (offset > reader->rodata.size) {
// The offset is past the end of the buffer.
return AVIF_RESULT_IO_ERROR;
}
if (offset == reader->rodata.size) {
// The parser is *exactly* at EOF: return a 0-size pointer to any valid buffer
offset = 0;
size = 0;
}
uint64_t availableSize = reader->rodata.size - offset;
if (size > availableSize) {
size = (size_t)availableSize;
}
if (offset > reader->availableBytes) {
return AVIF_RESULT_WAITING_ON_IO;
}
if (size > (reader->availableBytes - offset)) {
return AVIF_RESULT_WAITING_ON_IO;
}
out->data = reader->rodata.data + offset;
out->size = size;
return AVIF_RESULT_OK;
}
static void avifIOTestReaderDestroy(struct avifIO * io)
{
avifFree(io);
}
static avifIOTestReader * avifIOCreateTestReader(const uint8_t * data, size_t size)
{
avifIOTestReader * reader = avifAlloc(sizeof(avifIOTestReader));
memset(reader, 0, sizeof(avifIOTestReader));
reader->io.destroy = avifIOTestReaderDestroy;
reader->io.read = avifIOTestReaderRead;
reader->io.sizeHint = size;
reader->io.persistent = AVIF_TRUE;
reader->rodata.data = data;
reader->rodata.size = size;
return reader;
}
#define FILENAME_MAX_LENGTH 2047
static int runIOTests(const char * dataDir)
{
printf("AVIF Test Suite: Running IO Tests...\n");
static const char * ioSuffix = "/io/";
char ioDir[FILENAME_MAX_LENGTH + 1];
size_t dataDirLen = strlen(dataDir);
size_t ioSuffixLen = strlen(ioSuffix);
if ((dataDirLen + ioSuffixLen) > FILENAME_MAX_LENGTH) {
printf("Path too long: %s\n", dataDir);
return 1;
}
strcpy(ioDir, dataDir);
strcat(ioDir, ioSuffix);
size_t ioDirLen = strlen(ioDir);
int retCode = 0;
NextFilenameData nfd;
memset(&nfd, 0, sizeof(nfd));
avifRWData fileBuffer = AVIF_DATA_EMPTY;
const char * filename = nextFilename(ioDir, "avif", &nfd);
for (; filename != NULL; filename = nextFilename(ioDir, "avif", &nfd)) {
char fullFilename[FILENAME_MAX_LENGTH + 1];
size_t filenameLen = strlen(filename);
if ((ioDirLen + filenameLen) > FILENAME_MAX_LENGTH) {
printf("Path too long: %s\n", filename);
retCode = 1;
break;
}
strcpy(fullFilename, ioDir);
strcat(fullFilename, filename);
FILE * f = fopen(fullFilename, "rb");
if (!f) {
printf("Can't open for read: %s\n", filename);
retCode = 1;
break;
}
fseek(f, 0, SEEK_END);
size_t fileSize = ftell(f);
fseek(f, 0, SEEK_SET);
if (avifRWDataRealloc(&fileBuffer, fileSize) != AVIF_RESULT_OK) {
printf("Out of memory when allocating buffer to read file: %s\n", filename);
fclose(f);
retCode = 1;
break;
}
if (fread(fileBuffer.data, 1, fileSize, f) != fileSize) {
printf("Can't read entire file: %s\n", filename);
fclose(f);
retCode = 1;
break;
}
fclose(f);
avifDecoder * decoder = avifDecoderCreate();
avifIOTestReader * io = avifIOCreateTestReader(fileBuffer.data, fileBuffer.size);
avifDecoderSetIO(decoder, (avifIO *)io);
for (int pass = 0; pass < 4; ++pass) {
io->io.persistent = ((pass % 2) == 0);
decoder->ignoreExif = decoder->ignoreXMP = (pass < 2);
// Slowly pretend to have streamed-in / downloaded more and more bytes
avifResult parseResult = AVIF_RESULT_UNKNOWN_ERROR;
for (io->availableBytes = 0; io->availableBytes <= io->io.sizeHint; ++io->availableBytes) {
parseResult = avifDecoderParse(decoder);
if (parseResult == AVIF_RESULT_WAITING_ON_IO) {
continue;
}
if (parseResult != AVIF_RESULT_OK) {
retCode = 1;
}
printf("File: [%s @ %zu / %" PRIu64 " bytes, %s, %s] parse returned: %s\n",
filename,
io->availableBytes,
io->io.sizeHint,
io->io.persistent ? "Persistent" : "NonPersistent",
decoder->ignoreExif ? "IgnoreMetadata" : "Metadata",
avifResultToString(parseResult));
break;
}
if (parseResult == AVIF_RESULT_OK) {
for (; io->availableBytes <= io->io.sizeHint; ++io->availableBytes) {
avifExtent extent;
avifResult extentResult = avifDecoderNthImageMaxExtent(decoder, 0, &extent);
if (extentResult != AVIF_RESULT_OK) {
retCode = 1;
printf("File: [%s @ %zu / %" PRIu64 " bytes, %s, %s] maxExtent returned: %s\n",
filename,
io->availableBytes,
io->io.sizeHint,
io->io.persistent ? "Persistent" : "NonPersistent",
decoder->ignoreExif ? "IgnoreMetadata" : "Metadata",
avifResultToString(extentResult));
} else {
avifResult nextImageResult = avifDecoderNextImage(decoder);
if (nextImageResult == AVIF_RESULT_WAITING_ON_IO) {
continue;
}
if (nextImageResult != AVIF_RESULT_OK) {
retCode = 1;
}
printf("File: [%s @ %zu / %" PRIu64 " bytes, %s, %s] nextImage [MaxExtent off %" PRIu64 ", size %zu] returned: %s\n",
filename,
io->availableBytes,
io->io.sizeHint,
io->io.persistent ? "Persistent" : "NonPersistent",
decoder->ignoreExif ? "IgnoreMetadata" : "Metadata",
extent.offset,
extent.size,
avifResultToString(nextImageResult));
}
break;
}
}
}
avifDecoderDestroy(decoder);
}
avifRWDataFree(&fileBuffer);
return retCode;
}
static void syntax(void)
{
fprintf(stderr, "Syntax: aviftest dataDir\n");
}
int main(int argc, char * argv[])
{
const char * dataDir = NULL;
#ifdef WIN32_MEMORY_LEAK_DETECTION
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
// _CrtSetBreakAlloc(2906);
#endif
// Parse cmdline
for (int i = 1; i < argc; ++i) {
char * arg = argv[i];
if (!strcmp(arg, "--io-only")) {
fprintf(stderr, "WARNING: --io-only is deprecated; ignoring.\n");
} else if (dataDir == NULL) {
dataDir = arg;
} else {
fprintf(stderr, "Too many positional arguments: %s\n", arg);
syntax();
return 1;
}
}
// Verify all required args were set
if (dataDir == NULL) {
fprintf(stderr, "dataDir is required, bailing out.\n");
syntax();
return 1;
}
setbuf(stdout, NULL);
char codecVersions[256];
avifCodecVersions(codecVersions);
printf("Codec Versions: %s\n", codecVersions);
printf("Test Data Dir : %s\n", dataDir);
int retCode = runIOTests(dataDir);
if (retCode == 0) {
printf("AVIF Test Suite: Complete.\n");
} else {
printf("AVIF Test Suite: Failed.\n");
}
return retCode;
}