| // 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; |
| } |