Merge "Handle 64b box sizes" into main
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce831e6..e44cba0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,10 +13,12 @@
option(AVIFINFO_BUILD_TESTS
"Build and enable tests (GoogleTest must be installed)" OFF)
+option(AVIFINFO_BUILD_TOOLS "Build tools" OFF)
# C library
add_library(avifinfo avifinfo.c)
+target_include_directories(avifinfo PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
# C++ tests
@@ -26,11 +28,42 @@
enable_testing()
add_executable(avifinfo_test tests/avifinfo_test.cc)
- target_include_directories(avifinfo_test PRIVATE ${GTEST_INCLUDE_DIRS}
- ${CMAKE_CURRENT_SOURCE_DIR})
+ target_include_directories(avifinfo_test PRIVATE ${GTEST_INCLUDE_DIRS})
target_link_libraries(avifinfo_test PRIVATE ${GTEST_BOTH_LIBRARIES} avifinfo)
add_test(
NAME avifinfo_test
COMMAND ${CMAKE_CURRENT_BINARY_DIR}/avifinfo_test
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
endif()
+
+# C++ tools
+
+if(AVIFINFO_BUILD_TOOLS)
+ find_package(Threads REQUIRED) # For aom
+
+ # Clone and build libavif and its dependency aom.
+ include(ExternalProject)
+ set(EXTERNAL_INSTALL_LOCATION ${CMAKE_BINARY_DIR}/external)
+ ExternalProject_Add(
+ libavif
+ GIT_REPOSITORY https://github.com/AOMediaCodec/libavif
+ PATCH_COMMAND cd ${CMAKE_BINARY_DIR}/libavif-prefix/src/libavif/ext &&
+ ./aom.cmd
+ UPDATE_DISCONNECTED 1 # Avoid building aom everytime.
+ # aom.cmd builds aom as static so libavif should be built as static too.
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXTERNAL_INSTALL_LOCATION}
+ -DAVIF_CODEC_AOM=ON -DAVIF_LOCAL_AOM=ON -DBUILD_SHARED_LIBS=OFF)
+
+ add_executable(avifinfo_tool tools/avifinfo_tool.cc tests/avifinfo_fuzz.cc)
+ set_property(TARGET avifinfo_tool PROPERTY CXX_STANDARD 17) # for filesystem
+ target_include_directories(avifinfo_tool SYSTEM
+ PRIVATE ${EXTERNAL_INSTALL_LOCATION}/include)
+ # libavif's CMakeLists.txt uses a PRIVATE target_link_libraries() so
+ # avifinfo_tool must be linked to aom too (and thus also to pthread).
+ target_link_directories(
+ avifinfo_tool PRIVATE ${EXTERNAL_INSTALL_LOCATION}/lib
+ ${CMAKE_BINARY_DIR}/libavif-prefix/src/libavif/ext/aom/build.libavif)
+ target_link_libraries(avifinfo_tool PRIVATE avifinfo avif aom
+ Threads::Threads)
+ add_dependencies(avifinfo_tool libavif)
+endif()
diff --git a/tools/avifinfo_tool.cc b/tools/avifinfo_tool.cc
new file mode 100644
index 0000000..b16281c
--- /dev/null
+++ b/tools/avifinfo_tool.cc
@@ -0,0 +1,271 @@
+// Copyright (c) 2021, Alliance for Open Media. All rights reserved
+//
+// This source code is subject to the terms of the BSD 2 Clause License and
+// the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+// was not distributed with this source code in the LICENSE file, you can
+// obtain it at www.aomedia.org/license/software. If the Alliance for Open
+// Media Patent License 1.0 was not distributed with this source code in the
+// PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+
+#include <algorithm>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "avifinfo.h"
+#include "avif/avif.h"
+
+namespace {
+
+//------------------------------------------------------------------------------
+
+std::string GetHelpStr() {
+ std::string str;
+ str += "Command line tool to compare libavif and libavifinfo results.\n";
+ str += "Usage: avifparse [options] <directory>\n";
+ str += "Options:\n";
+ str += " -h, --help ...... Print this help\n";
+ str += " --fast .......... Skip libavif decoding, only use libavifinfo\n";
+ str += " --min-size ...... Find minimum size to extract features per file\n";
+ str += " --validate ...... Check libavifinfo consistency on each file\n";
+ return str;
+}
+
+//------------------------------------------------------------------------------
+
+// Decoding result.
+struct Result {
+ bool success; // True if the 'features' were correctly decoded.
+ AvifInfoFeatures features;
+};
+
+// Decodes the AVIF at 'data' of 'data_size' bytes using libavif.
+Result DecodeAvif(const uint8_t data[], size_t data_size) {
+ Result result;
+ avifImage* const image = avifImageCreateEmpty();
+ avifDecoder* const decoder = avifDecoderCreate();
+ decoder->strictFlags = AVIF_STRICT_DISABLED;
+ const avifResult status =
+ avifDecoderReadMemory(decoder, image, data, data_size);
+ avifDecoderDestroy(decoder);
+ if (status == AVIF_RESULT_OK) {
+ const uint32_t num_channels =
+ ((image->yuvFormat == AVIF_PIXEL_FORMAT_NONE) ? 0
+ : (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) ? 1
+ : 3) +
+ ((image->alphaPlane != nullptr) ? 1 : 0);
+ result = {true, {image->width, image->height, image->depth, num_channels}};
+ } else {
+ result = {false};
+ }
+ avifImageDestroy(image);
+ return result;
+}
+
+// Parses the AVIF at 'data' of 'data_size' bytes using libavifinfo.
+Result ParseAvif(const uint8_t data[], size_t data_size) {
+ Result result;
+ const AvifInfoStatus status = AvifInfoGetWithSize(
+ data, data_size, &result.features, /*file_size=*/data_size);
+ result.success = (status == kAvifInfoOk);
+ return result;
+}
+
+// Same as above but also returns the 'min_data_size' for which 'data' can be
+// successfully parsed.
+Result ParseAvifForSize(const uint8_t data[], size_t data_size,
+ size_t& min_data_size) {
+ const Result result = ParseAvif(data, data_size);
+ if (!result.success) {
+ min_data_size = data_size;
+ return result;
+ }
+ min_data_size = 1;
+ size_t max_data_size = data_size;
+ while (min_data_size < max_data_size) {
+ const size_t middle = (min_data_size + max_data_size) / 2;
+ if (AvifInfoGetWithSize(data, middle, nullptr, /*file_size=*/data_size) ==
+ kAvifInfoOk) {
+ max_data_size = middle;
+ } else {
+ min_data_size = middle + 1;
+ }
+ }
+ return result;
+}
+
+// Reuses the fuzz target for easy library validation.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t data_size);
+
+// Aggregated stats about the decoded/parsed AVIF files.
+struct Stats {
+ uint32_t num_files_invalid_at_decode = 0;
+ uint32_t num_files_invalid_at_parse = 0;
+ uint32_t num_files_invalid_at_both = 0;
+ std::unordered_map<size_t, uint32_t> min_size_to_count;
+};
+
+//------------------------------------------------------------------------------
+
+// Recursively adds all files at 'path' to 'file_paths'.
+void FindFiles(const std::string& path, std::vector<std::string>& file_paths) {
+ if (std::filesystem::is_directory(path)) {
+ for (const std::filesystem::directory_entry& entry :
+ std::filesystem::directory_iterator(path)) {
+ FindFiles(entry.path(), file_paths);
+ }
+ } else {
+ file_paths.emplace_back(path);
+ }
+}
+
+// Find the longest common prefix of all input 'paths'.
+std::string FindCommonLongestPrefix(const std::vector<std::string>& paths) {
+ std::string prefix = paths.empty() ? "" : paths.front();
+ for (const std::string& path : paths) {
+ const auto mismatch =
+ std::mismatch(prefix.begin(), prefix.end(), path.begin(), path.end());
+ prefix = prefix.substr(0, std::distance(prefix.begin(), mismatch.first));
+ }
+ return std::filesystem::path(prefix).remove_filename().string();
+}
+
+//------------------------------------------------------------------------------
+
+// Uses libavifinfo to extract the features of an AVIF file stored in 'data' at
+// 'path'. The AVIF file is 'data_size'-byte long.
+void ParseFile(const std::string& path, const uint8_t* data, size_t data_size,
+ Stats& stats) {
+ const Result parse = ParseAvif(data, data_size);
+ if (!parse.success) {
+ ++stats.num_files_invalid_at_parse;
+ std::cout << "parsing failure for " << path << std::endl;
+ }
+}
+
+// Uses libavif then libavifinfo to extract the features of an AVIF file.
+void DecodeAndParseFile(const std::string& path, const uint8_t* data,
+ size_t data_size, Stats& stats) {
+ const Result decode = DecodeAvif(data, data_size);
+ const Result parse = ParseAvif(data, data_size);
+ if (!decode.success) ++stats.num_files_invalid_at_decode;
+ if (!parse.success) ++stats.num_files_invalid_at_parse;
+ if (!decode.success && !parse.success) ++stats.num_files_invalid_at_both;
+
+ if (!parse.success ||
+ (decode.success &&
+ (decode.features.width != parse.features.width ||
+ decode.features.height != parse.features.height ||
+ decode.features.bit_depth != parse.features.bit_depth ||
+ decode.features.num_channels != parse.features.num_channels))) {
+ if (decode.success && parse.success) {
+ std::cout << "decoded " << decode.features.width << "x"
+ << decode.features.height << "," << decode.features.bit_depth
+ << "b*" << decode.features.num_channels << " / "
+ << "parsed " << parse.features.width << "x"
+ << parse.features.height << "," << parse.features.bit_depth
+ << "b*" << parse.features.num_channels;
+ } else {
+ std::cout << "decoding " << (decode.success ? "success" : "failure")
+ << " / parsing " << (parse.success ? "success" : "failure");
+ }
+ std::cout << " for " << path << std::endl;
+ }
+}
+
+// Returns the minimum number of bytes of AVIF 'data' for features to be
+// extracted.
+void FindMinSizeOfFile(const std::string& path, const uint8_t* data,
+ size_t data_size, Stats& stats) {
+ size_t min_size;
+ const Result parse = ParseAvifForSize(data, data_size, min_size);
+ if (parse.success) {
+ ++stats.min_size_to_count[min_size];
+ } else {
+ ++stats.num_files_invalid_at_parse;
+ }
+}
+
+// Checks the consistency of libavifinfo over an AVIF file.
+void ValidateFile(const std::string& path, const uint8_t* data,
+ size_t data_size) {
+ if (LLVMFuzzerTestOneInput(data, data_size) != 0) {
+ std::cout << "validation failed for " << path << std::endl;
+ }
+}
+
+} // namespace
+
+//------------------------------------------------------------------------------
+
+int main(int argc, char** argv) {
+ std::vector<std::string> file_paths;
+ bool only_parse = false;
+ bool find_min_size = false;
+ bool validate = false;
+
+ for (int arg = 1; arg < argc; ++arg) {
+ if (!std::strcmp(argv[arg], "-h")) {
+ std::cout << GetHelpStr();
+ return 0;
+ } else if (!std::strcmp(argv[arg], "--fast")) {
+ only_parse = true;
+ } else if (!std::strcmp(argv[arg], "--min-size")) {
+ find_min_size = true;
+ only_parse = true;
+ } else if (!std::strcmp(argv[arg], "--validate")) {
+ validate = true;
+ } else {
+ FindFiles(argv[arg], file_paths);
+ }
+ }
+ if (file_paths.empty()) {
+ std::cerr << "No input specified" << std::endl;
+ return 1;
+ }
+ std::cout << "Found " << file_paths.size() << " files" << std::endl;
+ const std::string prefix = FindCommonLongestPrefix(file_paths);
+ for (std::string& file_path : file_paths) {
+ file_path = file_path.substr(prefix.size());
+ }
+
+ Stats stats;
+ for (const std::string& file_path : file_paths) {
+ std::vector<uint8_t> bytes(std::filesystem::file_size(prefix + file_path));
+ std::ifstream file(prefix + file_path, std::ios::binary);
+ file.read(reinterpret_cast<char*>(bytes.data()), bytes.size());
+ if (find_min_size) {
+ FindMinSizeOfFile(file_path, bytes.data(), bytes.size(), stats);
+ } else if (only_parse) {
+ ParseFile(file_path, bytes.data(), bytes.size(), stats);
+ } else {
+ DecodeAndParseFile(file_path, bytes.data(), bytes.size(), stats);
+ }
+ if (validate) {
+ ValidateFile(file_path, bytes.data(), bytes.size());
+ }
+ }
+
+ std::cout << stats.num_files_invalid_at_parse << " files failed to parse"
+ << std::endl;
+ if (!only_parse) {
+ std::cout << stats.num_files_invalid_at_decode << " files failed to decode"
+ << std::endl;
+ std::cout << stats.num_files_invalid_at_both
+ << " files failed to parse and decode" << std::endl;
+ }
+
+ if (find_min_size) {
+ std::cout << std::endl;
+ for (const auto& it : stats.min_size_to_count) {
+ std::cout << it.second << " files need " << it.first
+ << " bytes to extract features" << std::endl;
+ }
+ }
+ return 0;
+}
