diff options
Diffstat (limited to 'chromium/third_party/libavif/src')
39 files changed, 3836 insertions, 1563 deletions
diff --git a/chromium/third_party/libavif/src/.github/workflows/ci.yml b/chromium/third_party/libavif/src/.github/workflows/ci.yml index 0a64fbac63c..fb807dc83c9 100644 --- a/chromium/third_party/libavif/src/.github/workflows/ci.yml +++ b/chromium/third_party/libavif/src/.github/workflows/ci.yml @@ -4,30 +4,26 @@ jobs: build: runs-on: ubuntu-18.04 env: - CC: gcc-8 - CXX: g++-8 + CC: gcc-10 + CXX: g++-10 steps: - name: Set up Python 3.8 uses: actions/setup-python@v2 with: python-version: '3.8' - - name: Install nasm - env: - LINK: http://debian-archive.trafficmanager.net/debian/pool/main/n/nasm - NASM_VERSION: 2.14.02-1 - NASM_SHA256: >- - 5225d0654783134ae616f56ce8649e4df09cba191d612a0300cfd0494bb5a3ef - run: | - curl -O "$LINK/nasm_${NASM_VERSION}_amd64.deb" - echo "$NASM_SHA256 nasm_${NASM_VERSION}_amd64.deb" | sha256sum --check - sudo dpkg -i "nasm_${NASM_VERSION}_amd64.deb" - name: Install dependencies run: | DEBIAN_FRONTEND=noninteractive sudo apt-get update - DEBIAN_FRONTEND=noninteractive sudo apt-get install -y ninja-build gcc-8 g++-8 + DEBIAN_FRONTEND=noninteractive sudo apt-get install -y ninja-build gcc-10 g++-10 pip install --upgrade pip pip install setuptools pip install meson + - name: Install nasm + run: | + curl -L https://download.videolan.org/contrib/nasm/nasm-2.14.tar.gz | tar xvz + cd nasm-2.14 + ./configure && make -j2 && sudo make install + nasm --version - uses: actions/checkout@v2 - name: Setup aom working-directory: ./ext diff --git a/chromium/third_party/libavif/src/.travis.yml b/chromium/third_party/libavif/src/.travis.yml index d7d1a788547..4670c97c973 100644 --- a/chromium/third_party/libavif/src/.travis.yml +++ b/chromium/third_party/libavif/src/.travis.yml @@ -27,9 +27,9 @@ before_script: - cd .. - mkdir build - cd build - - cmake -DCMAKE_BUILD_TYPE=$config -DBUILD_SHARED_LIBS=OFF -DAVIF_CODEC_AOM=ON -DAVIF_LOCAL_AOM=ON -DAVIF_CODEC_DAV1D=ON -DAVIF_LOCAL_DAV1D=ON -DAVIF_CODEC_RAV1E=ON -DAVIF_LOCAL_RAV1E=ON -DAVIF_CODEC_LIBGAV1=ON -DAVIF_LOCAL_LIBGAV1=ON -DAVIF_BUILD_EXAMPLES=ON -DAVIF_BUILD_APPS=ON -DAVIF_BUILD_TESTS=ON .. + - cmake -G Ninja -DCMAKE_BUILD_TYPE=$config -DBUILD_SHARED_LIBS=OFF -DAVIF_CODEC_AOM=ON -DAVIF_LOCAL_AOM=ON -DAVIF_CODEC_DAV1D=ON -DAVIF_LOCAL_DAV1D=ON -DAVIF_CODEC_RAV1E=ON -DAVIF_LOCAL_RAV1E=ON -DAVIF_CODEC_LIBGAV1=ON -DAVIF_LOCAL_LIBGAV1=ON -DAVIF_BUILD_EXAMPLES=ON -DAVIF_BUILD_APPS=ON -DAVIF_BUILD_TESTS=ON .. script: - - make + - ninja matrix: include: @@ -45,3 +45,28 @@ matrix: - name: "Clang Release" compiler: clang config: Release + - &freebsd_common + name: "Clang 10 + system libraries" + os: freebsd + compiler: clang + before_install: + - | # FreeBSD 12.2 has Clang 10 but TravisCI uses FreeBSD 12.1 + if [[ $(${CC:-clang} --version) =~ 8.0 ]]; then + export CC=clang10 CXX=clang++10 + sudo pkg install -y llvm10 + fi + before_script: + - sudo pkg install -y aom dav1d librav1e ninja + - $WRAPPER cmake -B build -G Ninja -DAVIF_{CODEC_{AOM,DAV1D,RAV1E},BUILD_{APPS,TESTS}}=ON + script: + - $WRAPPER cmake --build build + - <<: *freebsd_common + name: "GCC 10 + system libraries" + compiler: gcc + before_install: + - sudo pkg upgrade -y gcc10-devel + - <<: *freebsd_common + name: "Clang Static Analyzer" + env: WRAPPER="scan-build10 --status-bugs" + before_install: + - sudo pkg install -y llvm10 diff --git a/chromium/third_party/libavif/src/CHANGELOG.md b/chromium/third_party/libavif/src/CHANGELOG.md index 43e8c1b48e9..211584eba6a 100644 --- a/chromium/third_party/libavif/src/CHANGELOG.md +++ b/chromium/third_party/libavif/src/CHANGELOG.md @@ -6,6 +6,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [0.8.1] - 2020-08-05 + +### Added +* Add `ignoreAlpha` field to avifRGBImage (linkmauve) +* Save support in gdk-pixbuf component (novomesk) + +### Changed +* Only ever create one iref box, filled with multiple cdsc boxes (#247) +* Fix incorrect 16-to-8 monochrome YUV conversion +* Make decoding optional in CMake, like encoding is +* Include avif INTERFACE_INCLUDE_DIRECTORIES first (cryptomilk) +* Set C standard to C99, adjust flags for dav1d (1480c1) +* Minor cleanup/fixes in reformat.c (wantehchang) +* Fix a crash in the gdk-pixbuf loader, removed unnecessary asserts (novomesk) + +## [0.8.0] - 2020-07-14 + +### Added +* Monochrome (YUV400) support ** + * All encoding/decoding and internal memory savings are done/functional + * libaom has a bug in chroma_check() which crashes when encoding monochrome, to be fixed in a future (>v2.0.0) version + * rav1e didn't implement CS400 until rav1e v0.4.0 + * libavif safely falls back to YUV420 when these earlier codec versions are detected + * NOTE: If you want to do heavy monochrome testing, wait for newer versions to libaom/rav1e! +* Image sequence encoding support + * Required medium-sized refactors in the codec layers + * Image sequences (tracks) now fully support all metadata properly (Exif/XMP/transforms) + * avifenc can now encode a series of same-sized images with a consistent framerate, or each with their own custom duration +* Bilinear upsampling support +* avifenc: Add --ignore-icc, which avoids embedding the ICC profile found in the source image +* avifdec: Add --info, which attempts to decode all frames and display their basic info (merge of avifdump) +* avifenc: add --tilerowslog2 and --tilecolslog2 (wantehchang) +* Added `contrib` dir for any unofficially supported code contributions (e.g. gdk-pixbuf) + ### Changed * CICP Refactor (breaking change!) * Remove most references to "NCLX", as it is mostly an implementation detail, and the values are really from MPEG-CICP @@ -19,8 +53,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * Added comments explaining various decisions and citing standards * Removed ICC inspection code regarding chroma-derived mtxCoeffs; this was overdesigned. Now just honor the assoc. colorPrimaries enum * Reworked all examples in the README to reflect the new state of things, and clean out some cruft -* Switch libaom.cmd to point at v2.0.0-rc1 + * Harvest CICP from AV1 bitstream as a fallback in avifDecoderParse() if nclx box is absent +* All data other than actual pixel data should be available and valid after a call to avifDecoderParse() +* Refactor avifDecoder internal structures to properly handle meta boxes in trak boxes (see avifMeta) +* Update libaom.cmd to point at the v2.0.0 tag +* Update dav1d.cmd to point at the 0.7.1 tag * Re-enable cpu-used=7+ in codec_aom when libaom major version > 1 +* Memory allocation failures now cause libavif to abort the process (rather than undefined behavior) +* Fix to maintain alpha range when decoding an image grid with alpha +* Improvements to avifyuv to show drift when yuv and rgb depths differ +* Remove any references to (incorrect) "av01" brand (wantehchang) +* Set up libaom to use reduced_still_picture_header (wantehchang) +* Use libaom cpu_used 6 in "good quality" usage mode (wantehchang) +* Update avifBitsReadUleb128 with latest dav1d code (wantehchang) +* Set encoder chroma sample position (wantehchang) ## [0.7.3] - 2020-05-04 ### Added @@ -422,7 +468,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Constants `AVIF_VERSION`, `AVIF_VERSION_MAJOR`, `AVIF_VERSION_MINOR`, `AVIF_VERSION_PATCH` - `avifVersion()` function -[Unreleased]: https://github.com/AOMediaCodec/libavif/compare/v0.7.3...HEAD +[Unreleased]: https://github.com/AOMediaCodec/libavif/compare/v0.8.1...HEAD +[0.8.1]: https://github.com/AOMediaCodec/libavif/compare/v0.8.0...v0.8.1 +[0.8.0]: https://github.com/AOMediaCodec/libavif/compare/v0.7.3...v0.8.0 [0.7.3]: https://github.com/AOMediaCodec/libavif/compare/v0.7.2...v0.7.3 [0.7.2]: https://github.com/AOMediaCodec/libavif/compare/v0.7.1...v0.7.2 [0.7.1]: https://github.com/AOMediaCodec/libavif/compare/v0.7.0...v0.7.1 diff --git a/chromium/third_party/libavif/src/CMakeLists.txt b/chromium/third_party/libavif/src/CMakeLists.txt index 969c6a3bbc2..df8c538749c 100644 --- a/chromium/third_party/libavif/src/CMakeLists.txt +++ b/chromium/third_party/libavif/src/CMakeLists.txt @@ -7,7 +7,10 @@ cmake_minimum_required(VERSION 3.5) # and find_package() list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules") -project(libavif LANGUAGES C CXX VERSION 0.7.3) +project(libavif LANGUAGES C VERSION 0.8.1) + +# Set C99 as the default +set(CMAKE_C_STANDARD 99) # SOVERSION scheme: MAJOR.MINOR.PATCH # If there was an incompatible interface change: @@ -16,9 +19,9 @@ project(libavif LANGUAGES C CXX VERSION 0.7.3) # Increment MINOR. Set PATCH to 0 # If the source code was changed, but there were no interface changes: # Increment PATCH. -set(LIBRARY_VERSION_MAJOR 4) +set(LIBRARY_VERSION_MAJOR 6) set(LIBRARY_VERSION_MINOR 0) -set(LIBRARY_VERSION_PATCH 1) +set(LIBRARY_VERSION_PATCH 0) set(LIBRARY_VERSION "${LIBRARY_VERSION_MAJOR}.${LIBRARY_VERSION_MINOR}.${LIBRARY_VERSION_PATCH}") set(LIBRARY_SOVERSION ${LIBRARY_VERSION_MAJOR}) @@ -34,6 +37,10 @@ option(AVIF_LOCAL_DAV1D "Build the dav1d codec by providing your own copy of the option(AVIF_LOCAL_LIBGAV1 "Build the libgav1 codec by providing your own copy of the repo in ext/libgav1 (see Local Builds in README)" OFF) option(AVIF_LOCAL_RAV1E "Build the rav1e codec by providing your own copy of the repo in ext/rav1e (see Local Builds in README)" OFF) +if(AVIF_LOCAL_LIBGAV1) + enable_language(CXX) +endif() + # --------------------------------------------------------------------------------------- # This insanity is for people embedding libavif or making fully static or Windows builds. # Any proper unix environment should ignore these entire following blocks. @@ -89,9 +96,9 @@ if(CMAKE_C_COMPILER_ID MATCHES "Clang") -Wno-missing-noreturn -Wno-padded -Wno-sign-conversion + -Wno-error=c11-extensions ) elseif(CMAKE_C_COMPILER_ID MATCHES "GNU") - add_definitions(-std=gnu99) # Enforce C99 for gcc MESSAGE(STATUS "libavif: Enabling warnings for GCC") add_definitions(-Werror -Wall -Wextra) elseif(CMAKE_C_COMPILER_ID MATCHES "MSVC") @@ -118,6 +125,7 @@ set(AVIF_SRCS src/avif.c src/colr.c src/mem.c + src/obu.c src/rawdata.c src/read.c src/reformat.c @@ -208,12 +216,9 @@ if(AVIF_CODEC_RAV1E) ) if(AVIF_LOCAL_RAV1E) - set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/rav1e/target/release/rav1e.lib") + set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/rav1e/target/release/${CMAKE_STATIC_LIBRARY_PREFIX}rav1e${CMAKE_STATIC_LIBRARY_SUFFIX}") if(NOT EXISTS "${LIB_FILENAME}") - set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/rav1e/target/release/librav1e.a") - if(NOT EXISTS "${LIB_FILENAME}") - message(FATAL_ERROR "libavif: compiled rav1e library is missing (in ext/rav1e/target/release), bailing out") - endif() + message(FATAL_ERROR "libavif: compiled rav1e library is missing (in ext/rav1e/target/release), bailing out") endif() set(AVIF_CODEC_INCLUDES ${AVIF_CODEC_INCLUDES} @@ -244,11 +249,7 @@ if(AVIF_CODEC_AOM) src/codec_aom.c ) if(AVIF_LOCAL_AOM) - if(WIN32) - set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/aom/build.libavif/aom.lib") - else() - set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/aom/build.libavif/libaom.a") - endif() + set(LIB_FILENAME "${CMAKE_CURRENT_SOURCE_DIR}/ext/aom/build.libavif/${CMAKE_STATIC_LIBRARY_PREFIX}aom${CMAKE_STATIC_LIBRARY_SUFFIX}") if(NOT EXISTS "${LIB_FILENAME}") message(FATAL_ERROR "libavif: ${LIB_FILENAME} is missing, bailing out") endif() @@ -270,7 +271,7 @@ if(AVIF_CODEC_AOM) endif() if(NOT AVIF_CODEC_AOM AND NOT AVIF_CODEC_DAV1D AND NOT AVIF_CODEC_LIBGAV1) - message(FATAL_ERROR "libavif: No decoding library is enabled, bailing out.") + message(WARNING "libavif: No decoding library is enabled.") endif() add_library(avif ${AVIF_SRCS}) @@ -323,7 +324,13 @@ if(AVIF_BUILD_APPS) set_target_properties(avifenc PROPERTIES LINKER_LANGUAGE "CXX") endif() target_link_libraries(avifenc avif ${AVIF_PLATFORM_LIBRARIES} ${ZLIB_LIBRARY} ${PNG_LIBRARY} ${JPEG_LIBRARY}) - target_include_directories(avifenc PRIVATE apps/shared ${ZLIB_INCLUDE_DIR} ${PNG_PNG_INCLUDE_DIR} ${JPEG_INCLUDE_DIR}) + target_include_directories(avifenc + PRIVATE + $<TARGET_PROPERTY:avif,INTERFACE_INCLUDE_DIRECTORIES> + ${CMAKE_CURRENT_SOURCE_DIR}/apps/shared + ${ZLIB_INCLUDE_DIR} + ${PNG_PNG_INCLUDE_DIR} + ${JPEG_INCLUDE_DIR}) add_executable(avifdec apps/avifdec.c @@ -337,18 +344,13 @@ if(AVIF_BUILD_APPS) set_target_properties(avifdec PROPERTIES LINKER_LANGUAGE "CXX") endif() target_link_libraries(avifdec avif ${AVIF_PLATFORM_LIBRARIES} ${ZLIB_LIBRARY} ${PNG_LIBRARY} ${JPEG_LIBRARY}) - target_include_directories(avifdec PRIVATE apps/shared ${ZLIB_INCLUDE_DIR} ${PNG_PNG_INCLUDE_DIR} ${JPEG_INCLUDE_DIR}) - - add_executable(avifdump - apps/avifdump.c - - apps/shared/avifutil.c - ) - if(AVIF_LOCAL_LIBGAV1) - set_target_properties(avifdump PROPERTIES LINKER_LANGUAGE "CXX") - endif() - target_link_libraries(avifdump avif ${AVIF_PLATFORM_LIBRARIES}) - target_include_directories(avifdump PRIVATE apps/shared) + target_include_directories(avifdec + PRIVATE + $<TARGET_PROPERTY:avif,INTERFACE_INCLUDE_DIRECTORIES> + ${CMAKE_CURRENT_SOURCE_DIR}/apps/shared + ${ZLIB_INCLUDE_DIR} + ${PNG_PNG_INCLUDE_DIR} + ${JPEG_INCLUDE_DIR}) if(NOT SKIP_INSTALL_APPS AND NOT SKIP_INSTALL_ALL) install(TARGETS avifenc avifdec @@ -393,6 +395,7 @@ configure_file(libavif.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libavif.pc @ONLY) if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL) install(TARGETS avif EXPORT ${PROJECT_NAME}-config + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" ) @@ -455,4 +458,4 @@ if(WIN32) endif() endif() -# --------------------------------------------------------------------------------------- +add_subdirectory(contrib) diff --git a/chromium/third_party/libavif/src/LICENSE b/chromium/third_party/libavif/src/LICENSE index a4165881521..e8318ef745a 100644 --- a/chromium/third_party/libavif/src/LICENSE +++ b/chromium/third_party/libavif/src/LICENSE @@ -47,6 +47,34 @@ THE SOFTWARE. ------------------------------------------------------------------------------ +Files: src/obu.c + +Copyright © 2018-2019, VideoLAN and dav1d authors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +------------------------------------------------------------------------------ + Files: apps/shared/iccjpeg.* In plain English: @@ -113,3 +141,30 @@ We are required to state that "The Graphics Interchange Format(c) is the Copyright property of CompuServe Incorporated. GIF(sm) is a Service Mark property of CompuServe Incorporated." + +------------------------------------------------------------------------------ + +Files: contrib/gdk-pixbuf/* + +Copyright 2020 Emmanuel Gil Peyrot. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/chromium/third_party/libavif/src/README.md b/chromium/third_party/libavif/src/README.md index 620b57a589e..f394a402250 100644 --- a/chromium/third_party/libavif/src/README.md +++ b/chromium/third_party/libavif/src/README.md @@ -235,25 +235,26 @@ avifImageAllocatePlanes(image, AVIF_PLANES_YUV); ... image->yuvRowBytes; // Option 2: Convert from interleaved RGB(A)/BGR(A) using a libavif-allocated buffer. -uint32_t rgbDepth = ...; // [8, 10, 12, 16]; Does not need to match image->depth. - // If >8, rgb->pixels is uint16_t* -avifRGBFormat rgbFormat = AVIF_RGB_FORMAT_RGBA; // See choices in avif.h -avifRGBImage * rgb = avifRGBImageCreate(image->width, image->height, rgbDepth, rgbFormat); +avifRGBImage rgb; +avifRGBImageSetDefaults(&rgb, image); +rgb.depth = ...; // [8, 10, 12, 16]; Does not need to match image->depth. + // If >8, rgb->pixels is uint16_t* +rgb.format = ...; // See choices in avif.h +avifRGBImageAllocatePixels(&rgb); ... rgb->pixels; // fill these pixels; all channel data must be full range ... rgb->rowBytes; -avifImageRGBToYUV(image, rgb); // if alpha is present, it will also be copied/converted -avifRGBImageDestroy(rgb); +avifImageRGBToYUV(image, &rgb); // if alpha is present, it will also be copied/converted +avifRGBImageFreePixels(&rgb); // Option 3: Convert directly from your own pre-existing interleaved RGB(A)/BGR(A) buffer avifRGBImage rgb; -rgb.width = image->width; -rgb.height = image->height; +avifRGBImageSetDefaults(&rgb, image); rgb.depth = ...; // [8, 10, 12, 16]; Does not need to match image->depth. // If >8, rgb->pixels is uint16_t* rgb.format = ...; // See choices in avif.h, match to your buffer's pixel format rgb.pixels = ...; // Point at your RGB(A)/BGR(A) pixels here rgb.rowBytes = ...; -avifImageRGBToYUV(image, rgb); // if alpha is present, it will also be copied/converted +avifImageRGBToYUV(image, &rgb); // if alpha is present, it will also be copied/converted // no need to cleanup avifRGBImage // Optional: Populate alpha plane diff --git a/chromium/third_party/libavif/src/apps/avifdec.c b/chromium/third_party/libavif/src/apps/avifdec.c index e0468ad7e56..94bec871ab5 100644 --- a/chromium/third_party/libavif/src/apps/avifdec.c +++ b/chromium/third_party/libavif/src/apps/avifdec.c @@ -8,6 +8,7 @@ #include "avifutil.h" #include "y4m.h" +#include <inttypes.h> #include <stdio.h> #include <stdlib.h> #include <string.h> @@ -24,15 +25,85 @@ static void syntax(void) { printf("Syntax: avifdec [options] input.avif output.[jpg|jpeg|png|y4m]\n"); + printf(" avifdec --info input.avif\n"); printf("Options:\n"); printf(" -h,--help : Show syntax help\n"); printf(" -c,--codec C : AV1 codec to use (choose from versions list below)\n"); printf(" -d,--depth D : Output depth [8,16]. (PNG only; For y4m, depth is retained, and JPEG is always 8bpc)\n"); printf(" -q,--quality Q : Output quality [0-100]. (JPEG only, default: %d)\n", DEFAULT_JPEG_QUALITY); + printf(" -u,--upsampling U : Chroma upsampling (for 420/422). bilinear (default) or nearest\n"); + printf(" -i,--info : Decode all frames and display all image information instead of saving to disk\n"); printf("\n"); avifPrintVersions(); } +static int info(const char * inputFilename) +{ + FILE * inputFile = fopen(inputFilename, "rb"); + if (!inputFile) { + fprintf(stderr, "Cannot open file for read: %s\n", inputFilename); + return 1; + } + fseek(inputFile, 0, SEEK_END); + size_t inputFileSize = ftell(inputFile); + fseek(inputFile, 0, SEEK_SET); + + if (inputFileSize < 1) { + fprintf(stderr, "File too small: %s\n", inputFilename); + fclose(inputFile); + return 1; + } + + avifRWData raw = AVIF_DATA_EMPTY; + avifRWDataRealloc(&raw, inputFileSize); + if (fread(raw.data, 1, inputFileSize, inputFile) != inputFileSize) { + fprintf(stderr, "Failed to read " AVIF_FMT_ZU " bytes: %s\n", inputFileSize, inputFilename); + fclose(inputFile); + avifRWDataFree(&raw); + return 1; + } + + fclose(inputFile); + inputFile = NULL; + + avifDecoder * decoder = avifDecoderCreate(); + avifResult result = avifDecoderParse(decoder, (avifROData *)&raw); + if (result == AVIF_RESULT_OK) { + printf("Image decoded: %s\n", inputFilename); + + int frameIndex = 0; + avifBool firstImage = AVIF_TRUE; + while (avifDecoderNextImage(decoder) == AVIF_RESULT_OK) { + if (firstImage) { + firstImage = AVIF_FALSE; + avifImageDump(decoder->image); + + printf(" * %" PRIu64 " timescales per second, %2.2f seconds (%" PRIu64 " timescales), %d frame%s\n", + decoder->timescale, + decoder->duration, + decoder->durationInTimescales, + decoder->imageCount, + (decoder->imageCount == 1) ? "" : "s"); + printf(" * Frames:\n"); + } + + printf(" * Decoded frame [%d] [pts %2.2f (%" PRIu64 " timescales)] [duration %2.2f (%" PRIu64 " timescales)]\n", + frameIndex, + decoder->imageTiming.pts, + decoder->imageTiming.ptsInTimescales, + decoder->imageTiming.duration, + decoder->imageTiming.durationInTimescales); + ++frameIndex; + } + } else { + printf("ERROR: Failed to decode image: %s\n", avifResultToString(result)); + } + + avifRWDataFree(&raw); + avifDecoderDestroy(decoder); + return 0; +} + int main(int argc, char * argv[]) { const char * inputFilename = NULL; @@ -40,6 +111,8 @@ int main(int argc, char * argv[]) int requestedDepth = 0; int jpegQuality = DEFAULT_JPEG_QUALITY; avifCodecChoice codecChoice = AVIF_CODEC_CHOICE_AUTO; + avifBool infoOnly = AVIF_FALSE; + avifChromaUpsampling chromaUpsampling = AVIF_CHROMA_UPSAMPLING_BILINEAR; if (argc < 2) { syntax(); @@ -81,6 +154,18 @@ int main(int argc, char * argv[]) } else if (jpegQuality > 100) { jpegQuality = 100; } + } else if (!strcmp(arg, "-u") || !strcmp(arg, "--upsampling")) { + NEXTARG(); + if (!strcmp(arg, "bilinear")) { + chromaUpsampling = AVIF_CHROMA_UPSAMPLING_BILINEAR; + } else if (!strcmp(arg, "nearest")) { + chromaUpsampling = AVIF_CHROMA_UPSAMPLING_NEAREST; + } else { + fprintf(stderr, "ERROR: invalid upsampling: %s\n", arg); + return 1; + } + } else if (!strcmp(arg, "-i") || !strcmp(arg, "--info")) { + infoOnly = AVIF_TRUE; } else { // Positional argument if (!inputFilename) { @@ -97,11 +182,24 @@ int main(int argc, char * argv[]) ++argIndex; } - if (!inputFilename || !outputFilename) { + if (!inputFilename) { syntax(); return 1; } + if (infoOnly) { + if (!inputFilename || outputFilename) { + syntax(); + return 1; + } + return info(inputFilename); + } else { + if (!inputFilename || !outputFilename) { + syntax(); + return 1; + } + } + FILE * inputFile = fopen(inputFilename, "rb"); if (!inputFile) { fprintf(stderr, "Cannot open file for read: %s\n", inputFilename); @@ -120,7 +218,7 @@ int main(int argc, char * argv[]) avifRWData raw = AVIF_DATA_EMPTY; avifRWDataRealloc(&raw, inputFileSize); if (fread(raw.data, 1, inputFileSize, inputFile) != inputFileSize) { - fprintf(stderr, "Failed to read %zu bytes: %s\n", inputFileSize, inputFilename); + fprintf(stderr, "Failed to read " AVIF_FMT_ZU " bytes: %s\n", inputFileSize, inputFilename); fclose(inputFile); avifRWDataFree(&raw); return 1; @@ -149,11 +247,11 @@ int main(int argc, char * argv[]) returnCode = 1; } } else if (outputFormat == AVIF_APP_FILE_FORMAT_JPEG) { - if (!avifJPEGWrite(avif, outputFilename, jpegQuality)) { + if (!avifJPEGWrite(avif, outputFilename, jpegQuality, chromaUpsampling)) { returnCode = 1; } } else if (outputFormat == AVIF_APP_FILE_FORMAT_PNG) { - if (!avifPNGWrite(avif, outputFilename, requestedDepth)) { + if (!avifPNGWrite(avif, outputFilename, requestedDepth, chromaUpsampling)) { returnCode = 1; } } else { diff --git a/chromium/third_party/libavif/src/apps/avifdump.c b/chromium/third_party/libavif/src/apps/avifdump.c deleted file mode 100644 index 737f51523c8..00000000000 --- a/chromium/third_party/libavif/src/apps/avifdump.c +++ /dev/null @@ -1,90 +0,0 @@ -// Copyright 2019 Joe Drago. All rights reserved. -// SPDX-License-Identifier: BSD-2-Clause - -#include "avif/avif.h" - -#include "avifutil.h" - -#include <inttypes.h> -#include <stdio.h> -#include <string.h> - -static int syntax(void) -{ - printf("Syntax: avifdump input.avif\n"); - return 0; -} - -int main(int argc, char * argv[]) -{ - const char * inputFilename = NULL; - if (argc != 2) { - syntax(); - return 0; - } - inputFilename = argv[1]; - - FILE * inputFile = fopen(inputFilename, "rb"); - if (!inputFile) { - fprintf(stderr, "Cannot open file for read: %s\n", inputFilename); - return 1; - } - fseek(inputFile, 0, SEEK_END); - size_t inputFileSize = ftell(inputFile); - fseek(inputFile, 0, SEEK_SET); - - if (inputFileSize < 1) { - fprintf(stderr, "File too small: %s\n", inputFilename); - fclose(inputFile); - return 1; - } - - avifRWData raw = AVIF_DATA_EMPTY; - avifRWDataRealloc(&raw, inputFileSize); - if (fread(raw.data, 1, inputFileSize, inputFile) != inputFileSize) { - fprintf(stderr, "Failed to read %zu bytes: %s\n", inputFileSize, inputFilename); - fclose(inputFile); - avifRWDataFree(&raw); - return 1; - } - - fclose(inputFile); - inputFile = NULL; - - avifDecoder * decoder = avifDecoderCreate(); - avifResult result = avifDecoderParse(decoder, (avifROData *)&raw); - if (result == AVIF_RESULT_OK) { - printf("Image decoded: %s\n", inputFilename); - - int frameIndex = 0; - avifBool firstImage = AVIF_TRUE; - while (avifDecoderNextImage(decoder) == AVIF_RESULT_OK) { - if (firstImage) { - firstImage = AVIF_FALSE; - avifImageDump(decoder->image); - - printf(" * %" PRIu64 " timescales per second, %2.2f seconds (%" PRIu64 " timescales), %d frame%s\n", - decoder->timescale, - decoder->duration, - decoder->durationInTimescales, - decoder->imageCount, - (decoder->imageCount == 1) ? "" : "s"); - printf(" * Frames:\n"); - } - - printf(" * Decoded frame [%d] [pts %2.2f (%" PRIu64 " timescales)] [duration %2.2f (%" PRIu64 " timescales)]\n", - frameIndex, - decoder->imageTiming.pts, - decoder->imageTiming.ptsInTimescales, - decoder->imageTiming.duration, - decoder->imageTiming.durationInTimescales); - ++frameIndex; - } - } else { - printf("ERROR: Failed to decode image: %s\n", avifResultToString(result)); - } - - avifRWDataFree(&raw); - avifDecoderDestroy(decoder); - return 0; -} diff --git a/chromium/third_party/libavif/src/apps/avifenc.c b/chromium/third_party/libavif/src/apps/avifenc.c index 17496d1ca31..e288f713f2f 100644 --- a/chromium/third_party/libavif/src/apps/avifenc.c +++ b/chromium/third_party/libavif/src/apps/avifenc.c @@ -12,28 +12,54 @@ #include <stdlib.h> #include <string.h> +#if defined(_WIN32) +// for setmode() +#include <fcntl.h> +#include <io.h> +#endif + #define NEXTARG() \ if (((argIndex + 1) == argc) || (argv[argIndex + 1][0] == '-')) { \ fprintf(stderr, "%s requires an argument.", arg); \ - return 1; \ + goto cleanup; \ } \ arg = argv[++argIndex] +typedef struct avifInputFile +{ + const char * filename; + int duration; +} avifInputFile; +static avifInputFile stdinFile; + +typedef struct avifInput +{ + avifInputFile * files; + int filesCount; + int fileIndex; + struct y4mFrameIterator * frameIter; + avifPixelFormat requestedFormat; + int requestedDepth; + avifBool useStdin; +} avifInput; + static void syntax(void) { printf("Syntax: avifenc [options] input.[jpg|jpeg|png|y4m] output.avif\n"); printf("Options:\n"); printf(" -h,--help : Show syntax help\n"); printf(" -j,--jobs J : Number of jobs (worker threads, default: 1)\n"); + printf(" -o,--output FILENAME : Instead of using the last filename given as output, use this filename\n"); printf(" -l,--lossless : Set all defaults to encode losslessly, and emit warnings when settings/input don't allow for it\n"); - printf(" -d,--depth D : Output depth [8,10,12]. (JPEG/PNG only; For y4m, depth is retained)\n"); - printf(" -y,--yuv FORMAT : Output format [default=444, 422, 420]. (JPEG/PNG only; For y4m, format is retained)\n"); + printf(" -d,--depth D : Output depth [8,10,12]. (JPEG/PNG only; For y4m or stdin, depth is retained)\n"); + printf(" -y,--yuv FORMAT : Output format [default=444, 422, 420, 400]. (JPEG/PNG only; For y4m or stdin, format is retained)\n"); + printf(" --stdin : Read y4m frames from stdin instead of files; no input filenames allowed, must set before offering output filename\n"); printf(" --cicp,--nclx P/T/M : Set CICP values (nclx colr box) (3 raw numbers, use -r to set range flag)\n"); printf(" P = enum avifColorPrimaries\n"); printf(" T = enum avifTransferCharacteristics\n"); printf(" M = enum avifMatrixCoefficients\n"); printf(" (use 2 for any you wish to leave unspecified)\n"); - printf(" -r,--range RANGE : YUV range [limited or l, full or f]. (JPEG/PNG only, default: full; For y4m, range is retained)\n"); + printf(" -r,--range RANGE : YUV range [limited or l, full or f]. (JPEG/PNG only, default: full; For y4m or stdin, range is retained)\n"); printf(" --min Q : Set min quantizer for color (%d-%d, where %d is lossless)\n", AVIF_QUANTIZER_BEST_QUALITY, AVIF_QUANTIZER_WORST_QUALITY, @@ -50,10 +76,16 @@ static void syntax(void) AVIF_QUANTIZER_BEST_QUALITY, AVIF_QUANTIZER_WORST_QUALITY, AVIF_QUANTIZER_LOSSLESS); + printf(" --tilerowslog2 R : Set log2 of number of tile rows (0-6, default: 0)\n"); + printf(" --tilecolslog2 C : Set log2 of number of tile columns (0-6, default: 0)\n"); printf(" -s,--speed S : Encoder speed (%d-%d, slowest-fastest, 'default' or 'd' for codec internal defaults. default speed: 8)\n", AVIF_SPEED_SLOWEST, AVIF_SPEED_FASTEST); printf(" -c,--codec C : AV1 codec to use (choose from versions list below)\n"); + printf(" --duration D : Set all following frame durations (in timescales) to D; default 1. Can be set multiple times (before supplying each filename)\n"); + printf(" --timescale,--fps V : Set the timescale to V. If all frames are 1 timescale in length, this is equivalent to frames per second\n"); + printf(" -k,--keyframe INTERVAL : Set the forced keyframe interval (maximum frames between keyframes). Set to 0 to disable (default).\n"); + printf(" --ignore-icc : If the input file contains an embedded ICC profile, ignore it (no-op if absent)\n"); printf(" --pasp H,V : Add pasp property (aspect ratio). H=horizontal spacing, V=vertical spacing\n"); printf(" --clap WN,WD,HN,HD,HON,HOD,VON,VOD: Add clap property (clean aperture). Width, Height, HOffset, VOffset (in num/denom pairs)\n"); printf(" --irot ANGLE : Add irot property (rotation). [0-3], makes (90 * ANGLE) degree rotation anti-clockwise\n"); @@ -125,23 +157,91 @@ static int parseU32List(uint32_t output[8], const char * arg) return index; } -int main(int argc, char * argv[]) +static avifInputFile * avifInputGetNextFile(avifInput * input) { - const char * inputFilename = NULL; - const char * outputFilename = NULL; + if (input->useStdin) { + ungetc(fgetc(stdin), stdin); // Kick stdin to force EOF + if (feof(stdin)) { + return NULL; + } + return &stdinFile; + } + + if (input->fileIndex >= input->filesCount) { + return NULL; + } + return &input->files[input->fileIndex]; +} + +static avifAppFileFormat avifInputReadImage(avifInput * input, avifImage * image, uint32_t * outDepth) +{ + if (input->useStdin) { + if (feof(stdin)) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + if (!y4mRead(image, NULL, &input->frameIter)) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + return AVIF_APP_FILE_FORMAT_Y4M; + } + + if (input->fileIndex >= input->filesCount) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + + avifAppFileFormat nextInputFormat = avifGuessFileFormat(input->files[input->fileIndex].filename); + if (nextInputFormat == AVIF_APP_FILE_FORMAT_Y4M) { + if (!y4mRead(image, input->files[input->fileIndex].filename, &input->frameIter)) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + if (outDepth) { + *outDepth = image->depth; + } + } else if (nextInputFormat == AVIF_APP_FILE_FORMAT_JPEG) { + if (!avifJPEGRead(image, input->files[input->fileIndex].filename, input->requestedFormat, input->requestedDepth)) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + if (outDepth) { + *outDepth = 8; + } + } else if (nextInputFormat == AVIF_APP_FILE_FORMAT_PNG) { + if (!avifPNGRead(image, input->files[input->fileIndex].filename, input->requestedFormat, input->requestedDepth, outDepth)) { + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + } else { + fprintf(stderr, "Unrecognized file format: %s\n", input->files[input->fileIndex].filename); + return AVIF_APP_FILE_FORMAT_UNKNOWN; + } + + if (!input->frameIter) { + ++input->fileIndex; + } + return nextInputFormat; +} + +int main(int argc, char * argv[]) +{ if (argc < 2) { syntax(); return 1; } + const char * outputFilename = NULL; + + avifInput input; + memset(&input, 0, sizeof(input)); + input.files = malloc(sizeof(avifInputFile) * argc); + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV444; + + int returnCode = 0; int jobs = 1; - avifPixelFormat requestedFormat = AVIF_PIXEL_FORMAT_YUV444; - int requestedDepth = 0; int minQuantizer = AVIF_QUANTIZER_BEST_QUALITY; int maxQuantizer = 10; // "High Quality", but not lossless int minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; int maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; + int tileRowsLog2 = 0; + int tileColsLog2 = 0; int speed = 8; int paspCount = 0; uint32_t paspValues[8]; // only the first two are used @@ -152,11 +252,22 @@ int main(int argc, char * argv[]) avifCodecChoice codecChoice = AVIF_CODEC_CHOICE_AUTO; avifRange requestedRange = AVIF_RANGE_FULL; avifBool lossless = AVIF_FALSE; + avifBool ignoreICC = AVIF_FALSE; avifEncoder * encoder = NULL; - + avifImage * image = NULL; + avifImage * nextImage = NULL; + avifRWData raw = AVIF_DATA_EMPTY; + int duration = 1; // in timescales, stored per-inputFile (see avifInputFile) + int timescale = 1; // 1 fps by default + int keyframeInterval = 0; + avifBool cicpExplicitlySet = AVIF_FALSE; + + // By default, the color profile itself is unspecified, so CP/TC are set (to 2) accordingly. + // However, if the end-user doesn't specify any CICP, we will convert to YUV using BT709 + // coefficients anyway (as MC:2 falls back to MC:1), so we might as well signal it explicitly. avifColorPrimaries colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED; avifTransferCharacteristics transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED; - avifMatrixCoefficients matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED; + avifMatrixCoefficients matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT709; int argIndex = 1; while (argIndex < argc) { @@ -164,32 +275,44 @@ int main(int argc, char * argv[]) if (!strcmp(arg, "-h") || !strcmp(arg, "--help")) { syntax(); - return 0; + goto cleanup; } else if (!strcmp(arg, "-j") || !strcmp(arg, "--jobs")) { NEXTARG(); jobs = atoi(arg); if (jobs < 1) { jobs = 1; } + } else if (!strcmp(arg, "--stdin")) { + input.useStdin = AVIF_TRUE; + } else if (!strcmp(arg, "-o") || !strcmp(arg, "--output")) { + NEXTARG(); + outputFilename = arg; } else if (!strcmp(arg, "-d") || !strcmp(arg, "--depth")) { NEXTARG(); - requestedDepth = atoi(arg); - if ((requestedDepth != 8) && (requestedDepth != 10) && (requestedDepth != 12)) { + input.requestedDepth = atoi(arg); + if ((input.requestedDepth != 8) && (input.requestedDepth != 10) && (input.requestedDepth != 12)) { fprintf(stderr, "ERROR: invalid depth: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "-y") || !strcmp(arg, "--yuv")) { NEXTARG(); if (!strcmp(arg, "444")) { - requestedFormat = AVIF_PIXEL_FORMAT_YUV444; + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV444; } else if (!strcmp(arg, "422")) { - requestedFormat = AVIF_PIXEL_FORMAT_YUV422; + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV422; } else if (!strcmp(arg, "420")) { - requestedFormat = AVIF_PIXEL_FORMAT_YUV420; + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV420; + } else if (!strcmp(arg, "400")) { + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV400; } else { fprintf(stderr, "ERROR: invalid format: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } + } else if (!strcmp(arg, "-k") || !strcmp(arg, "--keyframe")) { + NEXTARG(); + keyframeInterval = atoi(arg); } else if (!strcmp(arg, "--min")) { NEXTARG(); minQuantizer = atoi(arg); @@ -226,15 +349,35 @@ int main(int argc, char * argv[]) if (maxQuantizerAlpha > AVIF_QUANTIZER_WORST_QUALITY) { maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY; } + } else if (!strcmp(arg, "--tilerowslog2")) { + NEXTARG(); + tileRowsLog2 = atoi(arg); + if (tileRowsLog2 < 0) { + tileRowsLog2 = 0; + } + if (tileRowsLog2 > 6) { + tileRowsLog2 = 6; + } + } else if (!strcmp(arg, "--tilecolslog2")) { + NEXTARG(); + tileColsLog2 = atoi(arg); + if (tileColsLog2 < 0) { + tileColsLog2 = 0; + } + if (tileColsLog2 > 6) { + tileColsLog2 = 6; + } } else if (!strcmp(arg, "--cicp") || !strcmp(arg, "--nclx")) { NEXTARG(); int cicp[3]; if (!parseCICP(cicp, arg)) { - return 1; + returnCode = 1; + goto cleanup; } colorPrimaries = (avifColorPrimaries)cicp[0]; transferCharacteristics = (avifTransferCharacteristics)cicp[1]; matrixCoefficients = (avifMatrixCoefficients)cicp[2]; + cicpExplicitlySet = AVIF_TRUE; } else if (!strcmp(arg, "-r") || !strcmp(arg, "--range")) { NEXTARG(); if (!strcmp(arg, "limited") || !strcmp(arg, "l")) { @@ -243,7 +386,8 @@ int main(int argc, char * argv[]) requestedRange = AVIF_RANGE_FULL; } else { fprintf(stderr, "ERROR: Unknown range: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "-s") || !strcmp(arg, "--speed")) { NEXTARG(); @@ -258,148 +402,174 @@ int main(int argc, char * argv[]) speed = AVIF_SPEED_SLOWEST; } } + } else if (!strcmp(arg, "--duration")) { + NEXTARG(); + duration = atoi(arg); + if (duration < 1) { + fprintf(stderr, "ERROR: Invalid duration: %d\n", duration); + returnCode = 1; + goto cleanup; + } + } else if (!strcmp(arg, "--timescale") || !strcmp(arg, "--fps")) { + NEXTARG(); + timescale = atoi(arg); + if (timescale < 1) { + fprintf(stderr, "ERROR: Invalid timescale: %d\n", timescale); + returnCode = 1; + goto cleanup; + } } else if (!strcmp(arg, "-c") || !strcmp(arg, "--codec")) { NEXTARG(); codecChoice = avifCodecChoiceFromName(arg); if (codecChoice == AVIF_CODEC_CHOICE_AUTO) { fprintf(stderr, "ERROR: Unrecognized codec: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } else { const char * codecName = avifCodecName(codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE); if (codecName == NULL) { fprintf(stderr, "ERROR: AV1 Codec cannot encode: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } + } else if (!strcmp(arg, "--ignore-icc")) { + ignoreICC = AVIF_TRUE; } else if (!strcmp(arg, "--pasp")) { NEXTARG(); paspCount = parseU32List(paspValues, arg); if (paspCount != 2) { fprintf(stderr, "ERROR: Invalid pasp values: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "--clap")) { NEXTARG(); clapCount = parseU32List(clapValues, arg); if (clapCount != 8) { fprintf(stderr, "ERROR: Invalid clap values: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "--irot")) { NEXTARG(); irotAngle = (uint8_t)atoi(arg); if (irotAngle > 3) { fprintf(stderr, "ERROR: Invalid irot angle: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "--imir")) { NEXTARG(); imirAxis = (uint8_t)atoi(arg); if (imirAxis > 1) { fprintf(stderr, "ERROR: Invalid imir axis: %s\n", arg); - return 1; + returnCode = 1; + goto cleanup; } } else if (!strcmp(arg, "-l") || !strcmp(arg, "--lossless")) { lossless = AVIF_TRUE; // Set defaults, and warn later on if anything looks incorrect - requestedFormat = AVIF_PIXEL_FORMAT_YUV444; // don't subsample when using AVIF_MATRIX_COEFFICIENTS_IDENTITY - minQuantizer = AVIF_QUANTIZER_LOSSLESS; // lossless - maxQuantizer = AVIF_QUANTIZER_LOSSLESS; // lossless - minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; // lossless - maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; // lossless - codecChoice = AVIF_CODEC_CHOICE_AOM; // rav1e doesn't support lossless transform yet: - // https://github.com/xiph/rav1e/issues/151 - requestedRange = AVIF_RANGE_FULL; // avoid limited range + input.requestedFormat = AVIF_PIXEL_FORMAT_YUV444; // don't subsample when using AVIF_MATRIX_COEFFICIENTS_IDENTITY + minQuantizer = AVIF_QUANTIZER_LOSSLESS; // lossless + maxQuantizer = AVIF_QUANTIZER_LOSSLESS; // lossless + minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; // lossless + maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS; // lossless + codecChoice = AVIF_CODEC_CHOICE_AOM; // rav1e doesn't support lossless transform yet: + // https://github.com/xiph/rav1e/issues/151 + requestedRange = AVIF_RANGE_FULL; // avoid limited range matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_IDENTITY; // this is key for lossless } else { // Positional argument - if (!inputFilename) { - inputFilename = arg; - } else if (!outputFilename) { - outputFilename = arg; - } else { - fprintf(stderr, "Too many positional arguments: %s\n", arg); - syntax(); - return 1; - } + input.files[input.filesCount].filename = arg; + input.files[input.filesCount].duration = duration; + ++input.filesCount; } ++argIndex; } - if (!inputFilename || !outputFilename) { + stdinFile.filename = "(stdin)"; + stdinFile.duration = duration; // TODO: Allow arbitrary frame durations from stdin? + + if (!outputFilename) { + if (((input.useStdin && (input.filesCount == 1)) || (!input.useStdin && (input.filesCount > 1)))) { + --input.filesCount; + outputFilename = input.files[input.filesCount].filename; + } + } + + if (!outputFilename || (input.useStdin && (input.filesCount > 0)) || (!input.useStdin && (input.filesCount < 1))) { syntax(); - return 1; + returnCode = 1; + goto cleanup; } - int returnCode = 0; - avifImage * avif = avifImageCreateEmpty(); - avifRWData raw = AVIF_DATA_EMPTY; +#if defined(_WIN32) + if (input.useStdin) { + setmode(fileno(stdin), O_BINARY); + } +#endif + + image = avifImageCreateEmpty(); + // Set these in advance so any upcoming RGB -> YUV use the proper coefficients + image->colorPrimaries = colorPrimaries; + image->transferCharacteristics = transferCharacteristics; + image->matrixCoefficients = matrixCoefficients; + image->yuvRange = requestedRange; + + avifInputFile * firstFile = avifInputGetNextFile(&input); uint32_t sourceDepth = 0; - avifBool sourceWasRGB = AVIF_TRUE; - avifAppFileFormat inputFormat = avifGuessFileFormat(inputFilename); + avifAppFileFormat inputFormat = avifInputReadImage(&input, image, &sourceDepth); if (inputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) { - fprintf(stderr, "Cannot determine input file extension: %s\n", inputFilename); + fprintf(stderr, "Cannot determine input file format: %s\n", firstFile->filename); returnCode = 1; goto cleanup; } + avifBool sourceWasRGB = (inputFormat != AVIF_APP_FILE_FORMAT_Y4M); - // Set these in advance so any upcoming RGB -> YUV use the proper coefficients - avif->colorPrimaries = colorPrimaries; - avif->transferCharacteristics = transferCharacteristics; - avif->matrixCoefficients = matrixCoefficients; - avif->yuvRange = requestedRange; + printf("Successfully loaded: %s\n", firstFile->filename); - if (inputFormat == AVIF_APP_FILE_FORMAT_Y4M) { - if (!y4mRead(avif, inputFilename)) { - returnCode = 1; - goto cleanup; - } - sourceDepth = avif->depth; - sourceWasRGB = AVIF_FALSE; - } else if (inputFormat == AVIF_APP_FILE_FORMAT_JPEG) { - if (!avifJPEGRead(avif, inputFilename, requestedFormat, requestedDepth)) { - returnCode = 1; - goto cleanup; - } - sourceDepth = 8; - } else if (inputFormat == AVIF_APP_FILE_FORMAT_PNG) { - if (!avifPNGRead(avif, inputFilename, requestedFormat, requestedDepth, &sourceDepth)) { - returnCode = 1; - goto cleanup; + if ((image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY) && (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV444)) { + // matrixCoefficients was likely set to AVIF_MATRIX_COEFFICIENTS_IDENTITY as a side effect + // of --lossless, and Identity is only valid with YUV444. Set this back to the default. + image->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT709; + + if (cicpExplicitlySet) { + // Only warn if someone explicitly asked for identity. + printf("WARNING: matrixCoefficients may not be set to identity(0) when subsampling. Resetting MC to defaults.\n"); } - } else { - fprintf(stderr, "Unrecognized file extension: %s\n", inputFilename); - returnCode = 1; - goto cleanup; } - printf("Successfully loaded: %s\n", inputFilename); + + if (ignoreICC) { + avifImageSetProfileICC(image, NULL, 0); + } if (paspCount == 2) { - avif->transformFlags |= AVIF_TRANSFORM_PASP; - avif->pasp.hSpacing = paspValues[0]; - avif->pasp.vSpacing = paspValues[1]; + image->transformFlags |= AVIF_TRANSFORM_PASP; + image->pasp.hSpacing = paspValues[0]; + image->pasp.vSpacing = paspValues[1]; } if (clapCount == 8) { - avif->transformFlags |= AVIF_TRANSFORM_CLAP; - avif->clap.widthN = clapValues[0]; - avif->clap.widthD = clapValues[1]; - avif->clap.heightN = clapValues[2]; - avif->clap.heightD = clapValues[3]; - avif->clap.horizOffN = clapValues[4]; - avif->clap.horizOffD = clapValues[5]; - avif->clap.vertOffN = clapValues[6]; - avif->clap.vertOffD = clapValues[7]; + image->transformFlags |= AVIF_TRANSFORM_CLAP; + image->clap.widthN = clapValues[0]; + image->clap.widthD = clapValues[1]; + image->clap.heightN = clapValues[2]; + image->clap.heightD = clapValues[3]; + image->clap.horizOffN = clapValues[4]; + image->clap.horizOffD = clapValues[5]; + image->clap.vertOffN = clapValues[6]; + image->clap.vertOffD = clapValues[7]; } if (irotAngle != 0xff) { - avif->transformFlags |= AVIF_TRANSFORM_IROT; - avif->irot.angle = irotAngle; + image->transformFlags |= AVIF_TRANSFORM_IROT; + image->irot.angle = irotAngle; } if (imirAxis != 0xff) { - avif->transformFlags |= AVIF_TRANSFORM_IMIR; - avif->imir.axis = imirAxis; + image->transformFlags |= AVIF_TRANSFORM_IMIR; + image->imir.axis = imirAxis; } avifBool usingAOM = AVIF_FALSE; @@ -407,13 +577,14 @@ int main(int argc, char * argv[]) if (codecName && !strcmp(codecName, "aom")) { usingAOM = AVIF_TRUE; } - avifBool hasAlpha = (avif->alphaPlane && avif->alphaRowBytes); + avifBool hasAlpha = (image->alphaPlane && image->alphaRowBytes); avifBool losslessColorQP = (minQuantizer == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizer == AVIF_QUANTIZER_LOSSLESS); avifBool losslessAlphaQP = (minQuantizerAlpha == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizerAlpha == AVIF_QUANTIZER_LOSSLESS); - avifBool depthMatches = (sourceDepth == avif->depth); - avifBool using444 = (avif->yuvFormat == AVIF_PIXEL_FORMAT_YUV444); - avifBool usingFullRange = (avif->yuvRange == AVIF_RANGE_FULL); - avifBool usingIdentityMatrix = (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY); + avifBool depthMatches = (sourceDepth == image->depth); + avifBool using400 = (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400); + avifBool using444 = (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444); + avifBool usingFullRange = (image->yuvRange == AVIF_RANGE_FULL); + avifBool usingIdentityMatrix = (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY); // Guess if the enduser is asking for lossless and enable it so that warnings can be emitted if (!lossless && losslessColorQP && (!hasAlpha || losslessAlphaQP)) { @@ -447,12 +618,12 @@ int main(int argc, char * argv[]) fprintf(stderr, "WARNING: [--lossless] Input depth (%d) does not match output depth (%d). Output might not be lossless.\n", sourceDepth, - avif->depth); + image->depth); lossless = AVIF_FALSE; } if (sourceWasRGB) { - if (!using444) { + if (!using444 && !using400) { fprintf(stderr, "WARNING: [--lossless] Input data was RGB and YUV subsampling (-y) isn't YUV444. Output might not be lossless.\n"); lossless = AVIF_FALSE; } @@ -462,7 +633,7 @@ int main(int argc, char * argv[]) lossless = AVIF_FALSE; } - if (!usingIdentityMatrix) { + if (!usingIdentityMatrix && !using400) { fprintf(stderr, "WARNING: [--lossless] Input data was RGB and matrixCoefficients isn't set to identity (--cicp x/x/0); Output might not be lossless.\n"); lossless = AVIF_FALSE; } @@ -474,9 +645,9 @@ int main(int argc, char * argv[]) lossyHint = " (Lossless)"; } printf("AVIF to be written:%s\n", lossyHint); - avifImageDump(avif); + avifImageDump(image); - printf("Encoding with AV1 codec '%s' speed [%d], color QP [%d (%s) <-> %d (%s)], alpha QP [%d (%s) <-> %d (%s)], %d worker thread(s), please wait...\n", + printf("Encoding with AV1 codec '%s' speed [%d], color QP [%d (%s) <-> %d (%s)], alpha QP [%d (%s) <-> %d (%s)], tileRowsLog2 [%d], tileColsLog2 [%d], %d worker thread(s), please wait...\n", avifCodecName(codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE), speed, minQuantizer, @@ -487,6 +658,8 @@ int main(int argc, char * argv[]) quantizerString(minQuantizerAlpha), maxQuantizerAlpha, quantizerString(maxQuantizerAlpha), + tileRowsLog2, + tileColsLog2, jobs); encoder = avifEncoderCreate(); encoder->maxThreads = jobs; @@ -494,24 +667,108 @@ int main(int argc, char * argv[]) encoder->maxQuantizer = maxQuantizer; encoder->minQuantizerAlpha = minQuantizerAlpha; encoder->maxQuantizerAlpha = maxQuantizerAlpha; + encoder->tileRowsLog2 = tileRowsLog2; + encoder->tileColsLog2 = tileColsLog2; encoder->codecChoice = codecChoice; encoder->speed = speed; - avifResult encodeResult = avifEncoderWrite(encoder, avif, &raw); - if (encodeResult != AVIF_RESULT_OK) { - fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(encodeResult)); + encoder->timescale = (uint64_t)timescale; + encoder->keyframeInterval = keyframeInterval; + + uint32_t addImageFlags = AVIF_ADD_IMAGE_FLAG_NONE; + if (input.filesCount == 1) { + addImageFlags |= AVIF_ADD_IMAGE_FLAG_SINGLE; + } + + uint32_t firstDurationInTimescales = firstFile->duration; + if (input.useStdin || (input.filesCount > 1)) { + printf(" * Encoding frame 1 [%u/%d ts]: %s\n", firstDurationInTimescales, timescale, firstFile->filename); + } + avifResult addImageResult = avifEncoderAddImage(encoder, image, firstDurationInTimescales, addImageFlags); + if (addImageResult != AVIF_RESULT_OK) { + fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(addImageResult)); + goto cleanup; + } + + avifInputFile * nextFile; + int nextImageIndex = -1; + while ((nextFile = avifInputGetNextFile(&input)) != NULL) { + ++nextImageIndex; + + printf(" * Encoding frame %d [%u/%d ts]: %s\n", nextImageIndex + 1, nextFile->duration, timescale, nextFile->filename); + + nextImage = avifImageCreateEmpty(); + nextImage->colorPrimaries = image->colorPrimaries; + nextImage->transferCharacteristics = image->transferCharacteristics; + nextImage->matrixCoefficients = image->matrixCoefficients; + nextImage->yuvRange = image->yuvRange; + + avifAppFileFormat nextInputFormat = avifInputReadImage(&input, nextImage, NULL); + if (nextInputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) { + returnCode = 1; + goto cleanup; + } + + // Verify that this frame's properties matches the first frame's properties + if ((image->width != nextImage->width) || (image->height != nextImage->height)) { + fprintf(stderr, + "ERROR: Image sequence dimensions mismatch, [%ux%u] vs [%ux%u]: %s\n", + image->width, + image->height, + nextImage->width, + nextImage->height, + nextFile->filename); + goto cleanup; + } + if (image->depth != nextImage->depth) { + fprintf(stderr, "ERROR: Image sequence depth mismatch, [%u] vs [%u]: %s\n", image->depth, nextImage->depth, nextFile->filename); + goto cleanup; + } + if ((image->colorPrimaries != nextImage->colorPrimaries) || + (image->transferCharacteristics != nextImage->transferCharacteristics) || + (image->matrixCoefficients != nextImage->matrixCoefficients)) { + fprintf(stderr, + "ERROR: Image sequence CICP mismatch, [%u/%u/%u] vs [%u/%u/%u]: %s\n", + image->colorPrimaries, + image->matrixCoefficients, + image->transferCharacteristics, + nextImage->colorPrimaries, + nextImage->transferCharacteristics, + nextImage->matrixCoefficients, + nextFile->filename); + goto cleanup; + } + if (image->yuvRange != nextImage->yuvRange) { + fprintf(stderr, + "ERROR: Image sequence range mismatch, [%s] vs [%s]: %s\n", + (image->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited", + (nextImage->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited", + nextFile->filename); + goto cleanup; + } + + avifResult nextImageResult = avifEncoderAddImage(encoder, nextImage, nextFile->duration, AVIF_ADD_IMAGE_FLAG_NONE); + if (nextImageResult != AVIF_RESULT_OK) { + fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(nextImageResult)); + goto cleanup; + } + } + + avifResult finishResult = avifEncoderFinish(encoder, &raw); + if (finishResult != AVIF_RESULT_OK) { + fprintf(stderr, "ERROR: Failed to finish encoding: %s\n", avifResultToString(finishResult)); goto cleanup; } printf("Encoded successfully.\n"); - printf(" * ColorOBU size: %zu bytes\n", encoder->ioStats.colorOBUSize); - printf(" * AlphaOBU size: %zu bytes\n", encoder->ioStats.alphaOBUSize); + printf(" * Color AV1 total size: " AVIF_FMT_ZU " bytes\n", encoder->ioStats.colorOBUSize); + printf(" * Alpha AV1 total size: " AVIF_FMT_ZU " bytes\n", encoder->ioStats.alphaOBUSize); FILE * f = fopen(outputFilename, "wb"); if (!f) { fprintf(stderr, "ERROR: Failed to open file for write: %s\n", outputFilename); goto cleanup; } if (fwrite(raw.data, 1, raw.size, f) != raw.size) { - fprintf(stderr, "Failed to write %zu bytes: %s\n", raw.size, outputFilename); + fprintf(stderr, "Failed to write " AVIF_FMT_ZU " bytes: %s\n", raw.size, outputFilename); returnCode = 1; } else { printf("Wrote AVIF: %s\n", outputFilename); @@ -522,7 +779,13 @@ cleanup: if (encoder) { avifEncoderDestroy(encoder); } - avifImageDestroy(avif); + if (image) { + avifImageDestroy(image); + } + if (nextImage) { + avifImageDestroy(nextImage); + } avifRWDataFree(&raw); + free((void *)input.files); return returnCode; } diff --git a/chromium/third_party/libavif/src/apps/shared/avifjpeg.c b/chromium/third_party/libavif/src/apps/shared/avifjpeg.c index 33415baa3cf..4a7349987b9 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifjpeg.c +++ b/chromium/third_party/libavif/src/apps/shared/avifjpeg.c @@ -108,7 +108,7 @@ cleanup: return ret; } -avifBool avifJPEGWrite(avifImage * avif, const char * outputFilename, int jpegQuality) +avifBool avifJPEGWrite(avifImage * avif, const char * outputFilename, int jpegQuality, avifChromaUpsampling chromaUpsampling) { avifBool ret = AVIF_FALSE; FILE * f = NULL; @@ -119,6 +119,7 @@ avifBool avifJPEGWrite(avifImage * avif, const char * outputFilename, int jpegQu avifRGBImage rgb; avifRGBImageSetDefaults(&rgb, avif); rgb.format = AVIF_RGB_FORMAT_RGB; + rgb.chromaUpsampling = chromaUpsampling; rgb.depth = 8; avifRGBImageAllocatePixels(&rgb); avifImageYUVToRGB(avif, &rgb); diff --git a/chromium/third_party/libavif/src/apps/shared/avifjpeg.h b/chromium/third_party/libavif/src/apps/shared/avifjpeg.h index 3824aea146c..4eefa904bd9 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifjpeg.h +++ b/chromium/third_party/libavif/src/apps/shared/avifjpeg.h @@ -7,6 +7,6 @@ #include "avif/avif.h" avifBool avifJPEGRead(avifImage * avif, const char * inputFilename, avifPixelFormat requestedFormat, uint32_t requestedDepth); -avifBool avifJPEGWrite(avifImage * avif, const char * outputFilename, int jpegQuality); +avifBool avifJPEGWrite(avifImage * avif, const char * outputFilename, int jpegQuality, avifChromaUpsampling chromaUpsampling); #endif // ifndef LIBAVIF_APPS_SHARED_AVIFJPEG_H diff --git a/chromium/third_party/libavif/src/apps/shared/avifpng.c b/chromium/third_party/libavif/src/apps/shared/avifpng.c index 1d6c5d47381..5ebf9239a9b 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifpng.c +++ b/chromium/third_party/libavif/src/apps/shared/avifpng.c @@ -152,7 +152,7 @@ cleanup: return readResult; } -avifBool avifPNGWrite(avifImage * avif, const char * outputFilename, uint32_t requestedDepth) +avifBool avifPNGWrite(avifImage * avif, const char * outputFilename, uint32_t requestedDepth, avifChromaUpsampling chromaUpsampling) { volatile avifBool writeResult = AVIF_FALSE; png_structp png = NULL; @@ -204,6 +204,7 @@ avifBool avifPNGWrite(avifImage * avif, const char * outputFilename, uint32_t re avifRGBImageSetDefaults(&rgb, avif); rgb.depth = rgbDepth; + rgb.chromaUpsampling = chromaUpsampling; avifRGBImageAllocatePixels(&rgb); avifImageYUVToRGB(avif, &rgb); rowPointers = (png_bytep *)malloc(sizeof(png_bytep) * rgb.height); diff --git a/chromium/third_party/libavif/src/apps/shared/avifpng.h b/chromium/third_party/libavif/src/apps/shared/avifpng.h index 12b68ad3e24..38f87e0ad2f 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifpng.h +++ b/chromium/third_party/libavif/src/apps/shared/avifpng.h @@ -8,6 +8,6 @@ // if (requestedDepth == 0), do best-fit avifBool avifPNGRead(avifImage * avif, const char * inputFilename, avifPixelFormat requestedFormat, uint32_t requestedDepth, uint32_t * outPNGDepth); -avifBool avifPNGWrite(avifImage * avif, const char * outputFilename, uint32_t requestedDepth); +avifBool avifPNGWrite(avifImage * avif, const char * outputFilename, uint32_t requestedDepth, avifChromaUpsampling chromaUpsampling); #endif // ifndef LIBAVIF_APPS_SHARED_AVIFPNG_H diff --git a/chromium/third_party/libavif/src/apps/shared/avifutil.c b/chromium/third_party/libavif/src/apps/shared/avifutil.c index 23bf06fd7f0..1341728673d 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifutil.c +++ b/chromium/third_party/libavif/src/apps/shared/avifutil.c @@ -19,9 +19,9 @@ void avifImageDump(avifImage * avif) printf(" * Transfer Char. : %d\n", avif->transferCharacteristics); printf(" * Matrix Coeffs. : %d\n", avif->matrixCoefficients); - printf(" * ICC Profile : %s (%zu bytes)\n", (avif->icc.size > 0) ? "Present" : "Absent", avif->icc.size); - printf(" * XMP Metadata : %s (%zu bytes)\n", (avif->xmp.size > 0) ? "Present" : "Absent", avif->xmp.size); - printf(" * EXIF Metadata : %s (%zu bytes)\n", (avif->exif.size > 0) ? "Present" : "Absent", avif->exif.size); + printf(" * ICC Profile : %s (" AVIF_FMT_ZU " bytes)\n", (avif->icc.size > 0) ? "Present" : "Absent", avif->icc.size); + printf(" * XMP Metadata : %s (" AVIF_FMT_ZU " bytes)\n", (avif->xmp.size > 0) ? "Present" : "Absent", avif->xmp.size); + printf(" * EXIF Metadata : %s (" AVIF_FMT_ZU " bytes)\n", (avif->exif.size > 0) ? "Present" : "Absent", avif->exif.size); if (avif->transformFlags == AVIF_TRANSFORM_NONE) { printf(" * Transformations: None\n"); diff --git a/chromium/third_party/libavif/src/apps/shared/avifutil.h b/chromium/third_party/libavif/src/apps/shared/avifutil.h index 83f08ee58cf..5db081b0fbc 100644 --- a/chromium/third_party/libavif/src/apps/shared/avifutil.h +++ b/chromium/third_party/libavif/src/apps/shared/avifutil.h @@ -6,6 +6,20 @@ #include "avif/avif.h" +/* + * The %z format specifier is not available with Visual Studios before 2013 and + * mingw-w64 toolchains with `__USE_MINGW_ANSI_STDIO` not set to 1. + * Hence the %I format specifier must be used instead to print out `size_t`. + * Newer Visual Studios and mingw-w64 toolchains built with the commit + * mentioned with c99 set as the standard supports the %z specifier properly. + * Related mingw-w64 commit: bfd33f6c0ec5e652cc9911857dd1492ece8d8383 + */ +#if (defined(_MSVC) && _MSVC < 1800) || (defined(__USE_MINGW_ANSI_STDIO) && __USE_MINGW_ANSI_STDIO == 0) +# define AVIF_FMT_ZU "%Iu" +#else +# define AVIF_FMT_ZU "%zu" +#endif + void avifImageDump(avifImage * avif); void avifPrintVersions(void); diff --git a/chromium/third_party/libavif/src/apps/shared/y4m.c b/chromium/third_party/libavif/src/apps/shared/y4m.c index 72e97a23602..9e6b39a1cea 100644 --- a/chromium/third_party/libavif/src/apps/shared/y4m.c +++ b/chromium/third_party/libavif/src/apps/shared/y4m.c @@ -10,6 +10,21 @@ #include <stdlib.h> #include <string.h> +#define Y4M_MAX_LINE_SIZE 2048 // Arbitrary limit. Y4M headers should be much smaller than this + +struct y4mFrameIterator +{ + int width; + int height; + int depth; + avifBool hasAlpha; + avifPixelFormat format; + avifRange range; + + FILE * inputFile; + const char * displayFilename; +}; + static avifBool y4mColorSpaceParse(const char * formatString, avifPixelFormat * format, int * depth, avifBool * hasAlpha) { *hasAlpha = AVIF_FALSE; @@ -80,6 +95,21 @@ static avifBool y4mColorSpaceParse(const char * formatString, avifPixelFormat * *depth = 8; return AVIF_TRUE; } + if (!strcmp(formatString, "Cmono")) { + *format = AVIF_PIXEL_FORMAT_YUV400; + *depth = 8; + return AVIF_TRUE; + } + if (!strcmp(formatString, "Cmono10")) { + *format = AVIF_PIXEL_FORMAT_YUV400; + *depth = 10; + return AVIF_TRUE; + } + if (!strcmp(formatString, "Cmono12")) { + *format = AVIF_PIXEL_FORMAT_YUV400; + *depth = 12; + return AVIF_TRUE; + } return AVIF_FALSE; } @@ -102,6 +132,31 @@ static avifBool getHeaderString(uint8_t * p, uint8_t * end, char * out, size_t m return AVIF_TRUE; } +static int y4mReadLine(FILE * inputFile, avifRWData * raw, const char * displayFilename) +{ + static const int maxBytes = Y4M_MAX_LINE_SIZE; + int bytesRead = 0; + uint8_t * front = raw->data; + + for (;;) { + if (fread(front, 1, 1, inputFile) != 1) { + fprintf(stderr, "Failed to read line: %s\n", displayFilename); + break; + } + + ++bytesRead; + if (bytesRead >= maxBytes) { + break; + } + + if (*front == '\n') { + return bytesRead; + } + ++front; + } + return -1; +} + #define ADVANCE(BYTES) \ do { \ p += BYTES; \ @@ -109,136 +164,136 @@ static avifBool getHeaderString(uint8_t * p, uint8_t * end, char * out, size_t m goto cleanup; \ } while (0) -avifBool y4mRead(avifImage * avif, const char * inputFilename) +avifBool y4mRead(avifImage * avif, const char * inputFilename, struct y4mFrameIterator ** iter) { - FILE * inputFile = fopen(inputFilename, "rb"); - if (!inputFile) { - fprintf(stderr, "Cannot open file for read: %s\n", inputFilename); - return AVIF_FALSE; - } - fseek(inputFile, 0, SEEK_END); - size_t inputFileSize = ftell(inputFile); - fseek(inputFile, 0, SEEK_SET); + avifBool result = AVIF_FALSE; - if (inputFileSize < 10) { - fprintf(stderr, "File too small: %s\n", inputFilename); - fclose(inputFile); - return AVIF_FALSE; - } + struct y4mFrameIterator frame; + frame.width = -1; + frame.height = -1; + frame.depth = -1; + frame.hasAlpha = AVIF_FALSE; + frame.format = AVIF_PIXEL_FORMAT_NONE; + frame.range = AVIF_RANGE_LIMITED; + frame.inputFile = NULL; + frame.displayFilename = inputFilename; avifRWData raw = AVIF_DATA_EMPTY; - avifRWDataRealloc(&raw, inputFileSize); - if (fread(raw.data, 1, inputFileSize, inputFile) != inputFileSize) { - fprintf(stderr, "Failed to read %zu bytes: %s\n", inputFileSize, inputFilename); - fclose(inputFile); - avifRWDataFree(&raw); - return AVIF_FALSE; - } + avifRWDataRealloc(&raw, Y4M_MAX_LINE_SIZE); - avifBool result = AVIF_FALSE; + if (iter && *iter) { + // Continue reading FRAMEs from this y4m stream + memcpy(&frame, *iter, sizeof(struct y4mFrameIterator)); + } else { + // Open a fresh y4m and read its header - fclose(inputFile); - inputFile = NULL; + if (inputFilename) { + frame.inputFile = fopen(inputFilename, "rb"); + if (!frame.inputFile) { + fprintf(stderr, "Cannot open file for read: %s\n", inputFilename); + goto cleanup; + } + } else { + frame.inputFile = stdin; + frame.displayFilename = "(stdin)"; + } - uint8_t * end = raw.data + raw.size; - uint8_t * p = raw.data; + int headerBytes = y4mReadLine(frame.inputFile, &raw, frame.displayFilename); + if (headerBytes < 0) { + fprintf(stderr, "Y4M header too large: %s\n", frame.displayFilename); + goto cleanup; + } + if (headerBytes < 10) { + fprintf(stderr, "Y4M header too small: %s\n", frame.displayFilename); + goto cleanup; + } - if (memcmp(p, "YUV4MPEG2 ", 10) != 0) { - fprintf(stderr, "Not a y4m file: %s\n", inputFilename); - avifRWDataFree(&raw); - return AVIF_FALSE; - } - ADVANCE(10); // skip past header + uint8_t * end = raw.data + headerBytes; + uint8_t * p = raw.data; - char tmpBuffer[32]; + if (memcmp(p, "YUV4MPEG2 ", 10) != 0) { + fprintf(stderr, "Not a y4m file: %s\n", frame.displayFilename); + goto cleanup; + } + ADVANCE(10); // skip past header - int width = -1; - int height = -1; - int depth = -1; - avifBool hasAlpha = AVIF_FALSE; - avifPixelFormat format = AVIF_PIXEL_FORMAT_NONE; - avifRange range = AVIF_RANGE_LIMITED; - while (p != end) { - switch (*p) { - case 'W': // width - width = atoi((const char *)p + 1); - break; - case 'H': // height - height = atoi((const char *)p + 1); - break; - case 'C': // color space - if (!getHeaderString(p, end, tmpBuffer, 31)) { - fprintf(stderr, "Bad y4m header: %s\n", inputFilename); - goto cleanup; - } - if (!y4mColorSpaceParse(tmpBuffer, &format, &depth, &hasAlpha)) { - fprintf(stderr, "Unsupported y4m pixel format: %s\n", inputFilename); - goto cleanup; - } - break; - case 'X': - if (!getHeaderString(p, end, tmpBuffer, 31)) { - fprintf(stderr, "Bad y4m header: %s\n", inputFilename); - goto cleanup; - } - if (!strcmp(tmpBuffer, "XCOLORRANGE=FULL")) { - range = AVIF_RANGE_FULL; - } - break; - default: + char tmpBuffer[32]; + + while (p != end) { + switch (*p) { + case 'W': // width + frame.width = atoi((const char *)p + 1); + break; + case 'H': // height + frame.height = atoi((const char *)p + 1); + break; + case 'C': // color space + if (!getHeaderString(p, end, tmpBuffer, 31)) { + fprintf(stderr, "Bad y4m header: %s\n", frame.displayFilename); + goto cleanup; + } + if (!y4mColorSpaceParse(tmpBuffer, &frame.format, &frame.depth, &frame.hasAlpha)) { + fprintf(stderr, "Unsupported y4m pixel format: %s\n", frame.displayFilename); + goto cleanup; + } + break; + case 'X': + if (!getHeaderString(p, end, tmpBuffer, 31)) { + fprintf(stderr, "Bad y4m header: %s\n", frame.displayFilename); + goto cleanup; + } + if (!strcmp(tmpBuffer, "XCOLORRANGE=FULL")) { + frame.range = AVIF_RANGE_FULL; + } + break; + default: + break; + } + + // Advance past header section + while ((*p != '\n') && (*p != ' ')) { + ADVANCE(1); + } + if (*p == '\n') { + // Done with y4m header break; - } + } - // Advance past header section - while ((*p != '\n') && (*p != ' ')) { ADVANCE(1); } - if (*p == '\n') { - // Done with y4m header - break; - } - ADVANCE(1); - } - - if (*p != '\n') { - fprintf(stderr, "Truncated y4m header (no newline): %s\n", inputFilename); - goto cleanup; + if (*p != '\n') { + fprintf(stderr, "Truncated y4m header (no newline): %s\n", frame.displayFilename); + goto cleanup; + } } - ADVANCE(1); // advance past newline - size_t remainingBytes = end - p; - if (remainingBytes < 6) { - fprintf(stderr, "Truncated y4m (no room for frame header): %s\n", inputFilename); + int frameHeaderBytes = y4mReadLine(frame.inputFile, &raw, frame.displayFilename); + if (frameHeaderBytes < 0) { + fprintf(stderr, "Y4M frame header too large: %s\n", frame.displayFilename); goto cleanup; } - if (memcmp(p, "FRAME", 5) != 0) { - fprintf(stderr, "Truncated y4m (no frame): %s\n", inputFilename); + if (frameHeaderBytes < 6) { + fprintf(stderr, "Y4M frame header too small: %s\n", frame.displayFilename); goto cleanup; } - - // Advance past frame header - // TODO: Parse frame overrides similarly to header parsing above? - while (*p != '\n') { - ADVANCE(1); - } - if (*p != '\n') { - fprintf(stderr, "Invalid y4m frame header: %s\n", inputFilename); + if (memcmp(raw.data, "FRAME", 5) != 0) { + fprintf(stderr, "Truncated y4m (no frame): %s\n", frame.displayFilename); goto cleanup; } - ADVANCE(1); // advance past newline - if ((width < 1) || (height < 1) || ((depth != 8) && (depth != 10) && (depth != 12)) || (format == AVIF_PIXEL_FORMAT_NONE)) { - fprintf(stderr, "Failed to parse y4m header (not enough information): %s\n", inputFilename); + if ((frame.width < 1) || (frame.height < 1) || ((frame.depth != 8) && (frame.depth != 10) && (frame.depth != 12)) || + (frame.format == AVIF_PIXEL_FORMAT_NONE)) { + fprintf(stderr, "Failed to parse y4m header (not enough information): %s\n", frame.displayFilename); goto cleanup; } avifImageFreePlanes(avif, AVIF_PLANES_YUV | AVIF_PLANES_A); - avif->width = width; - avif->height = height; - avif->depth = depth; - avif->yuvFormat = format; - avif->yuvRange = range; + avif->width = frame.width; + avif->height = frame.height; + avif->depth = frame.depth; + avif->yuvFormat = frame.format; + avif->yuvRange = frame.range; avifImageAllocatePlanes(avif, AVIF_PLANES_YUV); avifPixelFormatInfo info; @@ -246,39 +301,57 @@ avifBool y4mRead(avifImage * avif, const char * inputFilename) uint32_t planeBytes[4]; planeBytes[0] = avif->yuvRowBytes[0] * avif->height; - planeBytes[1] = avif->yuvRowBytes[1] * (avif->height >> info.chromaShiftY); - planeBytes[2] = avif->yuvRowBytes[2] * (avif->height >> info.chromaShiftY); - if (hasAlpha) { + planeBytes[1] = avif->yuvRowBytes[1] * ((avif->height + info.chromaShiftY) >> info.chromaShiftY); + planeBytes[2] = avif->yuvRowBytes[2] * ((avif->height + info.chromaShiftY) >> info.chromaShiftY); + if (frame.hasAlpha) { planeBytes[3] = avif->alphaRowBytes * avif->height; } else { planeBytes[3] = 0; } - uint32_t bytesNeeded = planeBytes[0] + planeBytes[1] + planeBytes[2] + planeBytes[3]; - remainingBytes = end - p; - if (bytesNeeded > remainingBytes) { - fprintf(stderr, "Not enough bytes in y4m for first frame: %s\n", inputFilename); - goto cleanup; - } - for (int i = 0; i < 3; ++i) { - memcpy(avif->yuvPlanes[i], p, planeBytes[i]); - p += planeBytes[i]; + uint32_t bytesRead = (uint32_t)fread(avif->yuvPlanes[i], 1, planeBytes[i], frame.inputFile); + if (bytesRead != planeBytes[i]) { + fprintf(stderr, "Failed to read y4m plane (not enough data, wanted %d, got %d): %s\n", planeBytes[i], bytesRead, frame.displayFilename); + goto cleanup; + } } - if (hasAlpha) { + if (frame.hasAlpha) { avifImageAllocatePlanes(avif, AVIF_PLANES_A); - memcpy(avif->alphaPlane, p, planeBytes[3]); + if (fread(avif->alphaPlane, 1, planeBytes[3], frame.inputFile) != planeBytes[3]) { + fprintf(stderr, "Failed to read y4m plane (not enough data): %s\n", frame.displayFilename); + goto cleanup; + } } result = AVIF_TRUE; cleanup: + if (iter) { + if (*iter) { + free(*iter); + *iter = NULL; + } + + if (result && frame.inputFile) { + ungetc(fgetc(frame.inputFile), frame.inputFile); // Kick frame.inputFile to force EOF + + if (!feof(frame.inputFile)) { + // Remember y4m state for next time + *iter = malloc(sizeof(struct y4mFrameIterator)); + memcpy(*iter, &frame, sizeof(struct y4mFrameIterator)); + } + } + } + + if (inputFilename && frame.inputFile && (!iter || !(*iter))) { + fclose(frame.inputFile); + } avifRWDataFree(&raw); return result; } avifBool y4mWrite(avifImage * avif, const char * outputFilename) { - avifBool swapUV = AVIF_FALSE; avifBool hasAlpha = (avif->alphaPlane != NULL) && (avif->alphaRowBytes > 0); avifBool writeAlpha = AVIF_FALSE; char * y4mHeaderFormat = NULL; @@ -304,9 +377,8 @@ avifBool y4mWrite(avifImage * avif, const char * outputFilename) case AVIF_PIXEL_FORMAT_YUV420: y4mHeaderFormat = "C420jpeg XYSCSS=420JPEG"; break; - case AVIF_PIXEL_FORMAT_YV12: - y4mHeaderFormat = "C420jpeg XYSCSS=420JPEG"; - swapUV = AVIF_TRUE; + case AVIF_PIXEL_FORMAT_YUV400: + y4mHeaderFormat = "Cmono XYSCSS=400"; break; case AVIF_PIXEL_FORMAT_NONE: // will error later; this case is here for warning's sake @@ -324,9 +396,8 @@ avifBool y4mWrite(avifImage * avif, const char * outputFilename) case AVIF_PIXEL_FORMAT_YUV420: y4mHeaderFormat = "C420p10 XYSCSS=420P10"; break; - case AVIF_PIXEL_FORMAT_YV12: - y4mHeaderFormat = "C422p10 XYSCSS=422P10"; - swapUV = AVIF_TRUE; + case AVIF_PIXEL_FORMAT_YUV400: + y4mHeaderFormat = "Cmono10 XYSCSS=400"; break; case AVIF_PIXEL_FORMAT_NONE: // will error later; this case is here for warning's sake @@ -344,9 +415,8 @@ avifBool y4mWrite(avifImage * avif, const char * outputFilename) case AVIF_PIXEL_FORMAT_YUV420: y4mHeaderFormat = "C420p12 XYSCSS=420P12"; break; - case AVIF_PIXEL_FORMAT_YV12: - y4mHeaderFormat = "C422p12 XYSCSS=422P12"; - swapUV = AVIF_TRUE; + case AVIF_PIXEL_FORMAT_YUV400: + y4mHeaderFormat = "Cmono12 XYSCSS=400"; break; case AVIF_PIXEL_FORMAT_NONE: // will error later; this case is here for warning's sake @@ -392,16 +462,6 @@ avifBool y4mWrite(avifImage * avif, const char * outputFilename) planeBytes[0] = avif->yuvRowBytes[0] * avif->height; planeBytes[1] = avif->yuvRowBytes[1] * (avif->height >> info.chromaShiftY); planeBytes[2] = avif->yuvRowBytes[2] * (avif->height >> info.chromaShiftY); - if (swapUV) { - uint8_t * tmpPtr; - uint32_t tmp; - tmpPtr = planes[1]; - tmp = planeBytes[1]; - planes[1] = planes[2]; - planeBytes[1] = planeBytes[2]; - planes[2] = tmpPtr; - planeBytes[2] = tmp; - } for (int i = 0; i < 3; ++i) { if (fwrite(planes[i], 1, planeBytes[i], f) != planeBytes[i]) { diff --git a/chromium/third_party/libavif/src/apps/shared/y4m.h b/chromium/third_party/libavif/src/apps/shared/y4m.h index 851663b9732..45ee109df55 100644 --- a/chromium/third_party/libavif/src/apps/shared/y4m.h +++ b/chromium/third_party/libavif/src/apps/shared/y4m.h @@ -6,7 +6,13 @@ #include "avif/avif.h" -avifBool y4mRead(avifImage * avif, const char * inputFilename); +// Optionally pass one of these pointers (set to NULL) on a fresh input. If it successfully reads in +// a frame and sees that there is more data to be read, it will allocate an internal structure remembering +// the y4m header and FILE position and return it. Pass in this pointer to continue reading frames. +// The structure will always be freed upon failure or reaching EOF. +struct y4mFrameIterator; + +avifBool y4mRead(avifImage * avif, const char * inputFilename, struct y4mFrameIterator ** iter); avifBool y4mWrite(avifImage * avif, const char * outputFilename); #endif // ifndef LIBAVIF_APPS_SHARED_Y4M_H diff --git a/chromium/third_party/libavif/src/contrib/CMakeLists.txt b/chromium/third_party/libavif/src/contrib/CMakeLists.txt new file mode 100644 index 00000000000..602e8aa3484 --- /dev/null +++ b/chromium/third_party/libavif/src/contrib/CMakeLists.txt @@ -0,0 +1,4 @@ +# Copyright 2020 Joe Drago. All rights reserved. +# SPDX-License-Identifier: BSD-2-Clause + +add_subdirectory(gdk-pixbuf) diff --git a/chromium/third_party/libavif/src/contrib/README.md b/chromium/third_party/libavif/src/contrib/README.md new file mode 100644 index 00000000000..fdb9851df78 --- /dev/null +++ b/chromium/third_party/libavif/src/contrib/README.md @@ -0,0 +1,9 @@ +# libavif external contributions + +Anything in this directory was contributed by an external author and is not officially maintained by +libavif directly, nor are there any expectations of continued functionality. Any CMake options +offered in libavif's CMakeLists that cite files in this subdirectory are guaranteed to be disabled +by default. + +See libavif's `LICENSE` file to learn about any additional license requirements/information for any +subdirectories in here. diff --git a/chromium/third_party/libavif/src/contrib/gdk-pixbuf/CMakeLists.txt b/chromium/third_party/libavif/src/contrib/gdk-pixbuf/CMakeLists.txt new file mode 100644 index 00000000000..22eb7c7fa2b --- /dev/null +++ b/chromium/third_party/libavif/src/contrib/gdk-pixbuf/CMakeLists.txt @@ -0,0 +1,28 @@ +# Copyright 2020 Emmanuel Gil Peyrot. All rights reserved. +# SPDX-License-Identifier: BSD-2-Clause + +option(AVIF_BUILD_GDK_PIXBUF "Build a gdk-pixbuf loader" OFF) +if(AVIF_BUILD_GDK_PIXBUF) + find_package(PkgConfig) + if(PKG_CONFIG_FOUND) + pkg_search_module(GDK_PIXBUF gdk-pixbuf-2.0) + if(GDK_PIXBUF_FOUND) + set(GDK_PIXBUF_SRCS + loader.c + ) + add_library(pixbufloader-avif ${GDK_PIXBUF_SRCS}) + + # This is required because glib stupidly uses invalid #define names, such as __G_LIB_H__… + add_definitions(-Wno-reserved-id-macro) + target_link_libraries(pixbufloader-avif PUBLIC ${GDK_PIXBUF_LIBRARIES} avif) + target_include_directories(pixbufloader-avif PUBLIC ${GDK_PIXBUF_INCLUDE_DIRS}) + + pkg_get_variable(GDK_PIXBUF_MODULEDIR gdk-pixbuf-2.0 gdk_pixbuf_moduledir) + install(TARGETS pixbufloader-avif DESTINATION ${GDK_PIXBUF_MODULEDIR}) + else() + message(WARNING "gdk-pixbuf loader: disabled due to missing gdk-pixbuf-2.0") + endif() + else() + message(WARNING "gdk-pixbuf loader: disabled due to missing pkg-config") + endif() +endif() diff --git a/chromium/third_party/libavif/src/contrib/gdk-pixbuf/loader.c b/chromium/third_party/libavif/src/contrib/gdk-pixbuf/loader.c new file mode 100644 index 00000000000..af0e77599d1 --- /dev/null +++ b/chromium/third_party/libavif/src/contrib/gdk-pixbuf/loader.c @@ -0,0 +1,395 @@ +/* Copyright 2020 Emmanuel Gil Peyrot. All rights reserved. + SPDX-License-Identifier: BSD-2-Clause +*/ + +#include <avif/avif.h> + +#define GDK_PIXBUF_ENABLE_BACKEND +#include <gdk-pixbuf/gdk-pixbuf-io.h> + +G_MODULE_EXPORT void fill_vtable (GdkPixbufModule * module); +G_MODULE_EXPORT void fill_info (GdkPixbufFormat * info); + +struct avif_context { + GdkPixbuf * pixbuf; + + GdkPixbufModuleSizeFunc size_func; + GdkPixbufModuleUpdatedFunc updated_func; + GdkPixbufModulePreparedFunc prepared_func; + gpointer user_data; + + avifDecoder * decoder; + GByteArray * data; + GBytes * bytes; +}; + +static void avif_context_free(struct avif_context * context) +{ + if (!context) + return; + + if (context->decoder) { + avifDecoderDestroy(context->decoder); + context->decoder = NULL; + } + + if (context->data) { + g_byte_array_unref(context->data); + context->bytes = NULL; + } + + if (context->bytes) { + g_bytes_unref(context->bytes); + context->bytes = NULL; + } + + if (context->pixbuf) { + g_object_unref(context->pixbuf); + context->pixbuf = NULL; + } + + g_free(context); +} + +static gboolean avif_context_try_load(struct avif_context * context, GError ** error) +{ + avifResult ret; + avifDecoder * decoder = context->decoder; + avifImage * image; + avifRGBImage rgb; + avifROData raw; + int width, height; + + raw.data = g_bytes_get_data(context->bytes, &raw.size); + + ret = avifDecoderParse(decoder, &raw); + if (ret != AVIF_RESULT_OK) { + g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + "Couldn’t decode image: %s", avifResultToString(ret)); + return FALSE; + } + + if (decoder->imageCount > 1) { + g_set_error_literal(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED, + "Image sequences not yet implemented"); + return FALSE; + } + + ret = avifDecoderNextImage(decoder); + if (ret == AVIF_RESULT_NO_IMAGES_REMAINING) { + /* No more images, bail out. Verify that you got the expected amount of images decoded. */ + return TRUE; + } else if (ret != AVIF_RESULT_OK) { + g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED, + "Failed to decode all frames: %s", avifResultToString(ret)); + return FALSE; + } + + image = decoder->image; + width = image->width; + height = image->height; + + if (context->size_func) { + (*context->size_func)(&width, &height, context->user_data); + } + + if (width == 0 || height == 0) { + g_set_error_literal(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + "Transformed AVIF has zero width or height"); + return FALSE; + } + + if (!context->pixbuf) { + int bits_per_sample = 8; + + context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, + !!image->alphaPlane, bits_per_sample, + image->width, image->height); + if (context->pixbuf == NULL) { + g_set_error_literal(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + "Insufficient memory to open AVIF file"); + return FALSE; + } + context->prepared_func(context->pixbuf, NULL, context->user_data); + } + + avifRGBImageSetDefaults(&rgb, image); + rgb.depth = 8; + rgb.format = image->alphaPlane ? AVIF_RGB_FORMAT_RGBA : AVIF_RGB_FORMAT_RGB; + rgb.pixels = gdk_pixbuf_get_pixels(context->pixbuf); + rgb.rowBytes = gdk_pixbuf_get_rowstride(context->pixbuf); + + ret = avifImageYUVToRGB(image, &rgb); + if (ret != AVIF_RESULT_OK) { + g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED, + "Failed to convert YUV to RGB: %s", avifResultToString(ret)); + return FALSE; + } + + return TRUE; +} + +static gpointer begin_load(GdkPixbufModuleSizeFunc size_func, + GdkPixbufModulePreparedFunc prepared_func, + GdkPixbufModuleUpdatedFunc updated_func, + gpointer user_data, GError ** error) +{ + struct avif_context * context; + avifDecoder * decoder; + + g_assert(prepared_func != NULL); + + decoder = avifDecoderCreate(); + if (!decoder) { + g_set_error_literal(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + "Couldn’t allocate memory for decoder"); + return NULL; + } + + context = g_new0(struct avif_context, 1); + if (!context) + return NULL; + + context->size_func = size_func; + context->updated_func = updated_func; + context->prepared_func = prepared_func; + context->user_data = user_data; + + context->decoder = decoder; + context->data = g_byte_array_sized_new(40000); + + return context; +} + +static gboolean stop_load(gpointer data, GError ** error) +{ + struct avif_context * context = (struct avif_context *) data; + gboolean ret; + + context->bytes = g_byte_array_free_to_bytes(context->data); + context->data = NULL; + ret = avif_context_try_load(context, error); + + avif_context_free(context); + + return ret; +} + +static gboolean load_increment(gpointer data, const guchar * buf, guint size, GError ** error) +{ + struct avif_context * context = (struct avif_context *) data; + g_byte_array_append(context->data, buf, size); + if (error) + *error = NULL; + return TRUE; +} + +static gboolean avif_is_save_option_supported (const gchar *option_key) +{ + if (g_strcmp0(option_key, "quality") == 0) { + return TRUE; + } + + return FALSE; +} + +static gboolean avif_image_saver(FILE *f, + GdkPixbuf *pixbuf, + gchar **keys, + gchar **values, + GError **error) +{ + int width, height, min_quantizer, max_quantizer, alpha_quantizer; + long quality = 52; /* default; must be between 0 and 100 */ + gboolean save_alpha; + avifImage *avif; + avifRGBImage rgb; + avifResult res; + avifRWData raw = AVIF_DATA_EMPTY; + avifEncoder *encoder; + guint maxThreads; + + if (f == NULL || pixbuf == NULL) { + return FALSE; + } + + if (keys && *keys) { + gchar **kiter = keys; + gchar **viter = values; + + while (*kiter) { + if (strcmp(*kiter, "quality") == 0) { + char *endptr = NULL; + quality = strtol(*viter, &endptr, 10); + + if (endptr == *viter) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_BAD_OPTION, + "AVIF quality must be a value between 0 and 100; value “%s” could not be parsed.", + *viter); + + return FALSE; + } + + if (quality < 0 || quality > 100) { + + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_BAD_OPTION, + "AVIF quality must be a value between 0 and 100; value “%d” is not allowed.", + (int)quality); + + return FALSE; + } + } else { + g_warning("Unrecognized parameter (%s) passed to AVIF saver.", *kiter); + } + + ++kiter; + ++viter; + } + } + + if (gdk_pixbuf_get_bits_per_sample(pixbuf) != 8) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_UNKNOWN_TYPE, + "Sorry, only 8bit images are supported by this AVIF saver"); + return FALSE; + } + + width = gdk_pixbuf_get_width(pixbuf); + height = gdk_pixbuf_get_height(pixbuf); + + if ( width == 0 || height == 0) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + "Empty image, nothing to save"); + return FALSE; + } + + save_alpha = gdk_pixbuf_get_has_alpha(pixbuf); + + if (save_alpha) { + if ( gdk_pixbuf_get_n_channels(pixbuf) != 4) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_UNKNOWN_TYPE, + "Unsupported number of channels"); + return FALSE; + } + } + else { + if ( gdk_pixbuf_get_n_channels(pixbuf) != 3) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_UNKNOWN_TYPE, + "Unsupported number of channels"); + return FALSE; + } + } + + max_quantizer = AVIF_QUANTIZER_WORST_QUALITY * ( 100 - CLAMP(quality, 0, 100)) / 100; + min_quantizer = 0; + alpha_quantizer = 0; + + if ( max_quantizer > 20 ) { + min_quantizer = max_quantizer - 20; + + if (max_quantizer > 40) { + alpha_quantizer = max_quantizer - 40; + } + } + + avif = avifImageCreate(width, height, 8, AVIF_PIXEL_FORMAT_YUV420); + avif->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601; + avifRGBImageSetDefaults( &rgb, avif); + + rgb.depth = 8; + rgb.pixels = (uint8_t*) gdk_pixbuf_read_pixels(pixbuf); + rgb.rowBytes = gdk_pixbuf_get_rowstride(pixbuf); + + if (save_alpha) { + rgb.format = AVIF_RGB_FORMAT_RGBA; + } else { + rgb.format = AVIF_RGB_FORMAT_RGB; + } + + res = avifImageRGBToYUV(avif, &rgb); + if ( res != AVIF_RESULT_OK ) { + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_FAILED, + "Problem in RGB->YUV conversion: %s", avifResultToString(res)); + avifImageDestroy(avif); + return FALSE; + } + + maxThreads = g_get_num_processors(); + encoder = avifEncoderCreate(); + + encoder->maxThreads = CLAMP(maxThreads, 1, 64); + encoder->minQuantizer = min_quantizer; + encoder->maxQuantizer = max_quantizer; + encoder->minQuantizerAlpha = 0; + encoder->maxQuantizerAlpha = alpha_quantizer; + encoder->speed = 8; + + res = avifEncoderWrite(encoder, avif, &raw); + avifEncoderDestroy(encoder); + avifImageDestroy(avif); + + if ( res == AVIF_RESULT_OK ) { + fwrite(raw.data, 1, raw.size, f); + avifRWDataFree(&raw); + return TRUE; + } + + g_set_error(error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_FAILED, + "AVIF encoder problem: %s", avifResultToString(res)); + return FALSE; +} + + +G_MODULE_EXPORT void fill_vtable(GdkPixbufModule * module) +{ + module->begin_load = begin_load; + module->stop_load = stop_load; + module->load_increment = load_increment; + module->is_save_option_supported = avif_is_save_option_supported; + module->save = avif_image_saver; +} + +G_MODULE_EXPORT void fill_info(GdkPixbufFormat * info) +{ + static GdkPixbufModulePattern signature[] = { + { " ftypavif", "zzz ", 100 }, /* file begins with 'ftypavif' at offset 4 */ + { NULL, NULL, 0 } + }; + static gchar * mime_types[] = { + "image/avif", + NULL + }; + static gchar * extensions[] = { + "avif", + NULL + }; + + info->name = "avif"; + info->signature = (GdkPixbufModulePattern *)signature; + info->description = "AV1 Image File Format"; + info->mime_types = (gchar **)mime_types; + info->extensions = (gchar **)extensions; + info->flags = GDK_PIXBUF_FORMAT_WRITABLE | GDK_PIXBUF_FORMAT_THREADSAFE; + info->license = "BSD"; + info->disabled = FALSE; +} + diff --git a/chromium/third_party/libavif/src/ext/aom.cmd b/chromium/third_party/libavif/src/ext/aom.cmd index 89fa6a8eb0d..e52ede1d464 100755 --- a/chromium/third_party/libavif/src/ext/aom.cmd +++ b/chromium/third_party/libavif/src/ext/aom.cmd @@ -5,10 +5,10 @@ : # cmake and ninja must be in your PATH. -: # If you're running this on Windows, be sure you've already run this (from your VC2017 install dir): -: # "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat" +: # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir): +: # "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat" -git clone -b v2.0.0-rc1 --depth 1 https://aomedia.googlesource.com/aom +git clone -b v2.0.0 --depth 1 https://aomedia.googlesource.com/aom cd aom mkdir build.libavif diff --git a/chromium/third_party/libavif/src/ext/dav1d.cmd b/chromium/third_party/libavif/src/ext/dav1d.cmd index 6d33b11b2d0..6333a8c35e7 100644 --- a/chromium/third_party/libavif/src/ext/dav1d.cmd +++ b/chromium/third_party/libavif/src/ext/dav1d.cmd @@ -5,10 +5,10 @@ : # meson and ninja must be in your PATH. -: # If you're running this on Windows, be sure you've already run this (from your VC2017 install dir): -: # "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat" +: # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir): +: # "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat" -git clone -b 0.6.0 --depth 1 https://code.videolan.org/videolan/dav1d.git +git clone -b 0.7.1 --depth 1 https://code.videolan.org/videolan/dav1d.git cd dav1d mkdir build diff --git a/chromium/third_party/libavif/src/ext/libgav1.cmd b/chromium/third_party/libavif/src/ext/libgav1.cmd index 913c81fd39c..cd163cd1904 100755 --- a/chromium/third_party/libavif/src/ext/libgav1.cmd +++ b/chromium/third_party/libavif/src/ext/libgav1.cmd @@ -5,14 +5,14 @@ : # cmake and ninja must be in your PATH. -: # If you're running this on Windows, be sure you've already run this (from your VC2017 install dir): -: # "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat" +: # If you're running this on Windows, be sure you've already run this (from your VC2019 install dir): +: # "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat" git clone --single-branch https://chromium.googlesource.com/codecs/libgav1 cd libgav1 git checkout 45a1d76 -git clone https://github.com/abseil/abseil-cpp.git third_party/abseil-cpp +git clone -b 20200225.2 --depth 1 https://github.com/abseil/abseil-cpp.git third_party/abseil-cpp mkdir build cd build diff --git a/chromium/third_party/libavif/src/ext/rav1e.cmd b/chromium/third_party/libavif/src/ext/rav1e.cmd index 101db19f632..9956b0b14d1 100644 --- a/chromium/third_party/libavif/src/ext/rav1e.cmd +++ b/chromium/third_party/libavif/src/ext/rav1e.cmd @@ -5,13 +5,13 @@ : # cargo must be in your PATH. (use rustup or brew to install) -: # If you're running this on Windows targeting Rust's windows-msvc, be sure you've already run this (from your VC2017 install dir): -: # "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\VC\Auxiliary\Build\vcvars64.bat" +: # If you're running this on Windows targeting Rust's windows-msvc, be sure you've already run this (from your VC2019 install dir): +: # "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat" : # : # Also, the error that "The target windows-msvc is not supported yet" can safely be ignored provided that rav1e/target/release : # contains rav1e.h and rav1e.lib. -git clone -b v0.3.1 --depth 1 https://github.com/xiph/rav1e.git +git clone -b 0.3 --depth 1 https://github.com/xiph/rav1e.git cd rav1e cargo install cbindgen diff --git a/chromium/third_party/libavif/src/include/avif/avif.h b/chromium/third_party/libavif/src/include/avif/avif.h index 15be2b598f4..3dba45154eb 100644 --- a/chromium/third_party/libavif/src/include/avif/avif.h +++ b/chromium/third_party/libavif/src/include/avif/avif.h @@ -15,8 +15,8 @@ extern "C" { // Constants #define AVIF_VERSION_MAJOR 0 -#define AVIF_VERSION_MINOR 7 -#define AVIF_VERSION_PATCH 3 +#define AVIF_VERSION_MINOR 8 +#define AVIF_VERSION_PATCH 1 #define AVIF_VERSION (AVIF_VERSION_MAJOR * 10000) + (AVIF_VERSION_MINOR * 100) + AVIF_VERSION_PATCH typedef int avifBool; @@ -48,7 +48,7 @@ enum avifChannelIndex AVIF_CHAN_G = 1, AVIF_CHAN_B = 2, - // yuvPlanes - These are always correct, even if UV is flipped when encoded (YV12) + // yuvPlanes AVIF_CHAN_Y = 0, AVIF_CHAN_U = 1, AVIF_CHAN_V = 2 @@ -131,27 +131,36 @@ typedef enum avifPixelFormat AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422, AVIF_PIXEL_FORMAT_YUV420, - AVIF_PIXEL_FORMAT_YV12 + AVIF_PIXEL_FORMAT_YUV400 } avifPixelFormat; const char * avifPixelFormatToString(avifPixelFormat format); typedef struct avifPixelFormatInfo { + avifBool monochrome; int chromaShiftX; int chromaShiftY; - int aomIndexU; // maps U plane to AOM-side plane index - int aomIndexV; // maps V plane to AOM-side plane index } avifPixelFormatInfo; void avifGetPixelFormatInfo(avifPixelFormat format, avifPixelFormatInfo * info); // --------------------------------------------------------------------------- +// avifChromaSamplePosition + +typedef enum avifChromaSamplePosition +{ + AVIF_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + AVIF_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + AVIF_CHROMA_SAMPLE_POSITION_COLOCATED = 2 +} avifChromaSamplePosition; + +// --------------------------------------------------------------------------- // avifRange typedef enum avifRange { AVIF_RANGE_LIMITED = 0, - AVIF_RANGE_FULL = 0x80 + AVIF_RANGE_FULL = 1 } avifRange; // --------------------------------------------------------------------------- @@ -179,7 +188,7 @@ typedef enum avifColorPrimaries // outPrimaries: rX, rY, gX, gY, bX, bY, wX, wY void avifColorPrimariesGetValues(avifColorPrimaries acp, float outPrimaries[8]); -avifColorPrimaries avifColorPrimariesFind(float inPrimaries[8], const char ** outName); +avifColorPrimaries avifColorPrimariesFind(const float inPrimaries[8], const char ** outName); typedef enum avifTransferCharacteristics { @@ -294,14 +303,15 @@ typedef struct avifImage avifPixelFormat yuvFormat; avifRange yuvRange; + avifChromaSamplePosition yuvChromaSamplePosition; uint8_t * yuvPlanes[AVIF_PLANE_COUNT_YUV]; uint32_t yuvRowBytes[AVIF_PLANE_COUNT_YUV]; - avifBool decoderOwnsYUVPlanes; + avifBool imageOwnsYUVPlanes; avifRange alphaRange; uint8_t * alphaPlane; uint32_t alphaRowBytes; - avifBool decoderOwnsAlphaPlane; + avifBool imageOwnsAlphaPlane; // ICC Profile avifRWData icc; @@ -335,8 +345,8 @@ typedef struct avifImage } avifImage; avifImage * avifImageCreate(int width, int height, int depth, avifPixelFormat yuvFormat); -avifImage * avifImageCreateEmpty(void); // helper for making an image to decode into -void avifImageCopy(avifImage * dstImage, avifImage * srcImage); // deep copy +avifImage * avifImageCreateEmpty(void); // helper for making an image to decode into +void avifImageCopy(avifImage * dstImage, const avifImage * srcImage, uint32_t planes); // deep copy void avifImageDestroy(avifImage * image); void avifImageSetProfileICC(avifImage * image, const uint8_t * icc, size_t iccSize); @@ -375,27 +385,37 @@ typedef enum avifRGBFormat uint32_t avifRGBFormatChannelCount(avifRGBFormat format); avifBool avifRGBFormatHasAlpha(avifRGBFormat format); +typedef enum avifChromaUpsampling +{ + AVIF_CHROMA_UPSAMPLING_BILINEAR = 0, // Slower and prettier (default) + AVIF_CHROMA_UPSAMPLING_NEAREST = 1 // Faster and uglier +} avifChromaUpsampling; + typedef struct avifRGBImage { - uint32_t width; // must match associated avifImage - uint32_t height; // must match associated avifImage - uint32_t depth; // legal depths [8, 10, 12, 16]. if depth>8, pixels must be uint16_t internally - avifRGBFormat format; // all channels are always full range + uint32_t width; // must match associated avifImage + uint32_t height; // must match associated avifImage + uint32_t depth; // legal depths [8, 10, 12, 16]. if depth>8, pixels must be uint16_t internally + avifRGBFormat format; // all channels are always full range + avifChromaUpsampling chromaUpsampling; // How to upsample non-4:4:4 UV (ignored for 444) when converting to RGB. + // Unused when converting to YUV. avifRGBImageSetDefaults() prefers quality over speed. + avifBool ignoreAlpha; // Used for XRGB formats, treats formats containing alpha (such as ARGB) as if they were + // RGB, treating the alpha bits as if they were all 1. uint8_t * pixels; uint32_t rowBytes; } avifRGBImage; -void avifRGBImageSetDefaults(avifRGBImage * rgb, avifImage * image); -uint32_t avifRGBImagePixelSize(avifRGBImage * rgb); +void avifRGBImageSetDefaults(avifRGBImage * rgb, const avifImage * image); +uint32_t avifRGBImagePixelSize(const avifRGBImage * rgb); // Convenience functions. If you supply your own pixels/rowBytes, you do not need to use these. void avifRGBImageAllocatePixels(avifRGBImage * rgb); void avifRGBImageFreePixels(avifRGBImage * rgb); // The main conversion functions -avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb); -avifResult avifImageYUVToRGB(avifImage * image, avifRGBImage * rgb); +avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb); +avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb); // --------------------------------------------------------------------------- // YUV Utils @@ -435,7 +455,7 @@ typedef struct avifReformatState avifReformatMode mode; } avifReformatState; -avifBool avifPrepareReformatState(avifImage * image, avifRGBImage * rgb, avifReformatState * state); +avifBool avifPrepareReformatState(const avifImage * image, const avifRGBImage * rgb, avifReformatState * state); // --------------------------------------------------------------------------- // Codec selection @@ -459,6 +479,30 @@ typedef enum avifCodecFlags const char * avifCodecName(avifCodecChoice choice, uint32_t requiredFlags); avifCodecChoice avifCodecChoiceFromName(const char * name); +typedef struct avifCodecConfigurationBox +{ + // [skipped; is constant] unsigned int (1)marker = 1; + // [skipped; is constant] unsigned int (7)version = 1; + + uint8_t seqProfile; // unsigned int (3) seq_profile; + uint8_t seqLevelIdx0; // unsigned int (5) seq_level_idx_0; + uint8_t seqTier0; // unsigned int (1) seq_tier_0; + uint8_t highBitdepth; // unsigned int (1) high_bitdepth; + uint8_t twelveBit; // unsigned int (1) twelve_bit; + uint8_t monochrome; // unsigned int (1) monochrome; + uint8_t chromaSubsamplingX; // unsigned int (1) chroma_subsampling_x; + uint8_t chromaSubsamplingY; // unsigned int (1) chroma_subsampling_y; + uint8_t chromaSamplePosition; // unsigned int (2) chroma_sample_position; + + // unsigned int (3)reserved = 0; + // unsigned int (1)initial_presentation_delay_present; + // if (initial_presentation_delay_present) { + // unsigned int (4)initial_presentation_delay_minus_one; + // } else { + // unsigned int (4)reserved = 0; + // } +} avifCodecConfigurationBox; + // --------------------------------------------------------------------------- // avifDecoder @@ -507,11 +551,19 @@ typedef struct avifDecoder // Set this via avifDecoderSetSource(). avifDecoderSource requestedSource; - // The current decoded image, owned by the decoder. Is invalid if the decoder hasn't run or has run - // out of images. The YUV and A contents of this image are likely owned by the decoder, so be - // sure to copy any data inside of this image before advancing to the next image or reusing the - // decoder. It is legal to call avifImageYUVToRGB() on this in between calls to avifDecoderNextImage(), - // but use avifImageCopy() if you want to make a permanent copy of this image's contents. + // All decoded image data; owned by the decoder. All information in this image is incrementally + // added and updated as avifDecoder*() functions are called. After a successful call to + // avifDecoderParse(), all values in decoder->image (other than the planes/rowBytes themselves) + // will be pre-populated with all information found in the outer AVIF container, prior to any + // AV1 decoding. If the contents of the inner AV1 payload disagree with the outer container, + // these values may change after calls to avifDecoderRead(),avifDecoderNextImage(), or + // avifDecoderNthImage(). + // + // The YUV and A contents of this image are likely owned by the decoder, so be sure to copy any + // data inside of this image before advancing to the next image or reusing the decoder. It is + // legal to call avifImageYUVToRGB() on this in between calls to avifDecoderNextImage(), but use + // avifImageCopy() if you want to make a complete, permanent copy of this image's YUV content or + // metadata. avifImage * image; // Counts and timing for the current image in an image sequence. Uninteresting for single image files. @@ -522,25 +574,13 @@ typedef struct avifDecoder double duration; // in seconds (durationInTimescales / timescale) uint64_t durationInTimescales; // duration in "timescales" - // The width and height as reported by the AVIF container, if any. There is no guarantee - // these match the decoded images; they are merely reporting what is independently offered - // from the container's boxes. - // * If decoding an "item" and the item is associated with an ImageSpatialExtentsBox, - // it will use the box's width/height - // * Else if decoding tracks, these will be the integer portions of the TrackHeaderBox width/height - // * Else both will be set to 0. - uint32_t containerWidth; - uint32_t containerHeight; - - // The bit depth as reported by the AVIF container, if any. There is no guarantee - // this matches the decoded images; it is merely reporting what is independently offered - // from the container's boxes. - // * If decoding an "item" and the item is associated with an av1C property, - // it will use the box's depth flags. - // * Else if decoding tracks and there is a SampleDescriptionBox of type av01 containing an av1C box, - // it will use the box's depth flags. - // * Else it will be set to 0. - uint32_t containerDepth; + // This is true when avifDecoderParse() detects an alpha plane. Use this to find out if alpha is + // present after a successful call to avifDecoderParse(), but prior to any call to + // avifDecoderNextImage() or avifDecoderNthImage(), as decoder->image->alphaPlane won't exist yet. + avifBool alphaPresent; + + // Set this to true to disable support of grid images. If a grid image is encountered, AVIF_RESULT_BMFF_PARSE_FAILED will be returned. + avifBool disableGridImages; // stats from the most recent read, possibly 0s if reading an image sequence avifIOStats ioStats; @@ -553,7 +593,7 @@ avifDecoder * avifDecoderCreate(void); void avifDecoderDestroy(avifDecoder * decoder); // Simple interface to decode a single image, independent of the decoder afterwards (decoder may be deestroyed). -avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, avifROData * input); +avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, const avifROData * input); // Multi-function alternative to avifDecoderRead() for image sequences and gaining direct access // to the decoder's YUV buffers (for performance's sake). Data passed into avifDecoderParse() is NOT @@ -574,7 +614,7 @@ avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, avifROData // items in a file containing both, but switch between sources without having to // Parse again. Normally AVIF_DECODER_SOURCE_AUTO is enough for the common path. avifResult avifDecoderSetSource(avifDecoder * decoder, avifDecoderSource source); -avifResult avifDecoderParse(avifDecoder * decoder, avifROData * input); +avifResult avifDecoderParse(avifDecoder * decoder, const avifROData * input); avifResult avifDecoderNextImage(avifDecoder * decoder); avifResult avifDecoderNthImage(avifDecoder * decoder, uint32_t frameIndex); avifResult avifDecoderReset(avifDecoder * decoder); @@ -582,11 +622,12 @@ avifResult avifDecoderReset(avifDecoder * decoder); // Keyframe information // frameIndex - 0-based, matching avifDecoder->imageIndex, bound by avifDecoder->imageCount // "nearest" keyframe means the keyframe prior to this frame index (returns frameIndex if it is a keyframe) -avifBool avifDecoderIsKeyframe(avifDecoder * decoder, uint32_t frameIndex); -uint32_t avifDecoderNearestKeyframe(avifDecoder * decoder, uint32_t frameIndex); +avifBool avifDecoderIsKeyframe(const avifDecoder * decoder, uint32_t frameIndex); +uint32_t avifDecoderNearestKeyframe(const avifDecoder * decoder, uint32_t frameIndex); // Timing helper - This does not change the current image or invoke the codec (safe to call repeatedly) -avifResult avifDecoderNthImageTiming(avifDecoder * decoder, uint32_t frameIndex, avifImageTiming * outTiming); +// This function may be used after a successful call to avifDecoderParse(). +avifResult avifDecoderNthImageTiming(const avifDecoder * decoder, uint32_t frameIndex, avifImageTiming * outTiming); // --------------------------------------------------------------------------- // avifEncoder @@ -617,6 +658,8 @@ typedef struct avifEncoder int tileRowsLog2; int tileColsLog2; int speed; + int keyframeInterval; // How many frames between automatic forced keyframes; 0 to disable (default). + uint64_t timescale; // timescale of the media (Hz) // stats from the most recent write avifIOStats ioStats; @@ -626,15 +669,40 @@ typedef struct avifEncoder } avifEncoder; avifEncoder * avifEncoderCreate(void); -avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData * output); +avifResult avifEncoderWrite(avifEncoder * encoder, const avifImage * image, avifRWData * output); void avifEncoderDestroy(avifEncoder * encoder); +enum avifAddImageFlags +{ + AVIF_ADD_IMAGE_FLAG_NONE = 0, + + // Force this frame to be a keyframe (sync frame). + AVIF_ADD_IMAGE_FLAG_FORCE_KEYFRAME = (1 << 0), + + // Use this flag when encoding a single image. Signals "still_picture" to AV1 encoders, which + // tweaks various compression rules. This is enabled automatically when using the + // avifEncoderWrite() single-image encode path. + AVIF_ADD_IMAGE_FLAG_SINGLE = (1 << 1) +}; + +// Multi-function alternative to avifEncoderWrite() for image sequences. +// +// Usage / function call order is: +// * avifEncoderCreate() +// * Set encoder->timescale (Hz) correctly +// * avifEncoderAddImage() ... [repeatedly; at least once] +// * avifEncoderFinish() +// * avifEncoderDestroy() +// +avifResult avifEncoderAddImage(avifEncoder * encoder, const avifImage * image, uint64_t durationInTimescales, uint32_t addImageFlags); +avifResult avifEncoderFinish(avifEncoder * encoder, avifRWData * output); + // Helpers -avifBool avifImageUsesU16(avifImage * image); +avifBool avifImageUsesU16(const avifImage * image); // Returns AVIF_TRUE if input begins with a valid FileTypeBox (ftyp) that supports // either the brand 'avif' or 'avis' (or both), without performing any allocations. -avifBool avifPeekCompatibleFileType(avifROData * input); +avifBool avifPeekCompatibleFileType(const avifROData * input); #ifdef __cplusplus } // extern "C" diff --git a/chromium/third_party/libavif/src/include/avif/internal.h b/chromium/third_party/libavif/src/include/avif/internal.h index 33d19f00a23..992bc553ee4 100644 --- a/chromium/third_party/libavif/src/include/avif/internal.h +++ b/chromium/third_party/libavif/src/include/avif/internal.h @@ -41,7 +41,7 @@ uint32_t avifNTOHL(uint32_t l); uint64_t avifHTON64(uint64_t l); uint64_t avifNTOH64(uint64_t l); -void avifCalcYUVCoefficients(avifImage * image, float * outR, float * outG, float * outB); +void avifCalcYUVCoefficients(const avifImage * image, float * outR, float * outG, float * outB); #define AVIF_ARRAY_DECLARE(TYPENAME, ITEMSTYPE, ITEMSNAME) \ typedef struct TYPENAME \ @@ -87,16 +87,16 @@ avifBool avifReformatAlpha(const avifAlphaParams * const params); // --------------------------------------------------------------------------- // avifCodecDecodeInput -typedef struct avifSample +typedef struct avifDecodeSample { avifROData data; avifBool sync; // is sync sample (keyframe) -} avifSample; -AVIF_ARRAY_DECLARE(avifSampleArray, avifSample, sample); +} avifDecodeSample; +AVIF_ARRAY_DECLARE(avifDecodeSampleArray, avifDecodeSample, sample); typedef struct avifCodecDecodeInput { - avifSampleArray samples; + avifDecodeSampleArray samples; avifBool alpha; // if true, this is decoding an alpha plane } avifCodecDecodeInput; @@ -104,39 +104,41 @@ avifCodecDecodeInput * avifCodecDecodeInputCreate(void); void avifCodecDecodeInputDestroy(avifCodecDecodeInput * decodeInput); // --------------------------------------------------------------------------- -// avifCodec (abstraction layer to use different AV1 implementations) +// avifCodecEncodeOutput + +typedef struct avifEncodeSample +{ + avifRWData data; + avifBool sync; // is sync sample (keyframe) +} avifEncodeSample; +AVIF_ARRAY_DECLARE(avifEncodeSampleArray, avifEncodeSample, sample); -typedef struct avifCodecConfigurationBox +typedef struct avifCodecEncodeOutput { - // [skipped; is constant] unsigned int (1)marker = 1; - // [skipped; is constant] unsigned int (7)version = 1; - - uint8_t seqProfile; // unsigned int (3) seq_profile; - uint8_t seqLevelIdx0; // unsigned int (5) seq_level_idx_0; - uint8_t seqTier0; // unsigned int (1) seq_tier_0; - uint8_t highBitdepth; // unsigned int (1) high_bitdepth; - uint8_t twelveBit; // unsigned int (1) twelve_bit; - uint8_t monochrome; // unsigned int (1) monochrome; - uint8_t chromaSubsamplingX; // unsigned int (1) chroma_subsampling_x; - uint8_t chromaSubsamplingY; // unsigned int (1) chroma_subsampling_y; - uint8_t chromaSamplePosition; // unsigned int (2) chroma_sample_position; - - // unsigned int (3)reserved = 0; - // unsigned int (1)initial_presentation_delay_present; - // if (initial_presentation_delay_present) { - // unsigned int (4)initial_presentation_delay_minus_one; - // } else { - // unsigned int (4)reserved = 0; - // } -} avifCodecConfigurationBox; + avifEncodeSampleArray samples; +} avifCodecEncodeOutput; + +avifCodecEncodeOutput * avifCodecEncodeOutputCreate(void); +void avifCodecEncodeOutputAddSample(avifCodecEncodeOutput * encodeOutput, const uint8_t * data, size_t len, avifBool sync); +void avifCodecEncodeOutputDestroy(avifCodecEncodeOutput * encodeOutput); + +// --------------------------------------------------------------------------- +// avifCodec (abstraction layer to use different AV1 implementations) struct avifCodec; struct avifCodecInternal; typedef avifBool (*avifCodecOpenFunc)(struct avifCodec * codec, uint32_t firstSampleIndex); typedef avifBool (*avifCodecGetNextImageFunc)(struct avifCodec * codec, avifImage * image); -// avifCodecEncodeImageFunc: if either OBU* is null, skip its encode. alpha should always be lossless -typedef avifBool (*avifCodecEncodeImageFunc)(struct avifCodec * codec, avifImage * image, avifEncoder * encoder, avifRWData * obu, avifBool alpha); +// EncodeImage and EncodeFinish are not required to always emit a sample, but when all images are +// encoded and EncodeFinish is called, the number of samples emitted must match the number of submitted frames. +typedef avifBool (*avifCodecEncodeImageFunc)(struct avifCodec * codec, + avifEncoder * encoder, + const avifImage * image, + avifBool alpha, + uint32_t addImageFlags, + avifCodecEncodeOutput * output); +typedef avifBool (*avifCodecEncodeFinishFunc)(struct avifCodec * codec, avifCodecEncodeOutput * output); typedef void (*avifCodecDestroyInternalFunc)(struct avifCodec * codec); typedef struct avifCodec @@ -148,6 +150,7 @@ typedef struct avifCodec avifCodecOpenFunc open; avifCodecGetNextImageFunc getNextImage; avifCodecEncodeImageFunc encodeImage; + avifCodecEncodeFinishFunc encodeFinish; avifCodecDestroyInternalFunc destroyInternal; } avifCodec; @@ -182,11 +185,11 @@ typedef struct avifROStream const uint8_t * avifROStreamCurrent(avifROStream * stream); void avifROStreamStart(avifROStream * stream, avifROData * raw); -size_t avifROStreamOffset(avifROStream * stream); +size_t avifROStreamOffset(const avifROStream * stream); void avifROStreamSetOffset(avifROStream * stream, size_t offset); -avifBool avifROStreamHasBytesLeft(avifROStream * stream, size_t byteCount); -size_t avifROStreamRemainingBytes(avifROStream * stream); +avifBool avifROStreamHasBytesLeft(const avifROStream * stream, size_t byteCount); +size_t avifROStreamRemainingBytes(const avifROStream * stream); avifBool avifROStreamSkip(avifROStream * stream, size_t byteCount); avifBool avifROStreamRead(avifROStream * stream, uint8_t * data, size_t size); avifBool avifROStreamReadU16(avifROStream * stream, uint16_t * v); @@ -195,8 +198,8 @@ avifBool avifROStreamReadUX8(avifROStream * stream, uint64_t * v, uint64_t facto avifBool avifROStreamReadU64(avifROStream * stream, uint64_t * v); avifBool avifROStreamReadString(avifROStream * stream, char * output, size_t outputSize); avifBool avifROStreamReadBoxHeader(avifROStream * stream, avifBoxHeader * header); -avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * version, uint8_t * flags); // flags is an optional uint8_t[3] -avifBool avifROStreamReadAndEnforceVersion(avifROStream * stream, uint8_t enforcedVersion); // currently discards flags +avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * version, uint32_t * flags); // version and flags ptrs are both optional +avifBool avifROStreamReadAndEnforceVersion(avifROStream * stream, uint8_t enforcedVersion); // currently discards flags typedef struct avifRWStream { @@ -206,19 +209,42 @@ typedef struct avifRWStream uint8_t * avifRWStreamCurrent(avifRWStream * stream); void avifRWStreamStart(avifRWStream * stream, avifRWData * raw); -size_t avifRWStreamOffset(avifRWStream * stream); +size_t avifRWStreamOffset(const avifRWStream * stream); void avifRWStreamSetOffset(avifRWStream * stream, size_t offset); void avifRWStreamFinishWrite(avifRWStream * stream); -void avifRWStreamWrite(avifRWStream * stream, const uint8_t * data, size_t size); +void avifRWStreamWrite(avifRWStream * stream, const void * data, size_t size); void avifRWStreamWriteChars(avifRWStream * stream, const char * chars, size_t size); -avifBoxMarker avifRWStreamWriteBox(avifRWStream * stream, const char * type, int version /* -1 for "not a FullBox" */, size_t contentSize); +avifBoxMarker avifRWStreamWriteBox(avifRWStream * stream, const char * type, size_t contentSize); +avifBoxMarker avifRWStreamWriteFullBox(avifRWStream * stream, const char * type, size_t contentSize, int version, uint32_t flags); void avifRWStreamFinishBox(avifRWStream * stream, avifBoxMarker marker); void avifRWStreamWriteU8(avifRWStream * stream, uint8_t v); void avifRWStreamWriteU16(avifRWStream * stream, uint16_t v); void avifRWStreamWriteU32(avifRWStream * stream, uint32_t v); +void avifRWStreamWriteU64(avifRWStream * stream, uint64_t v); void avifRWStreamWriteZeros(avifRWStream * stream, size_t byteCount); +// This is to make it clear that the box size is currently unknown, and will be determined later (with a call to avifRWStreamFinishBox) +#define AVIF_BOX_SIZE_TBD 0 + +typedef struct avifSequenceHeader +{ + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t bitDepth; + avifPixelFormat yuvFormat; + avifChromaSamplePosition chromaSamplePosition; + avifColorPrimaries colorPrimaries; + avifTransferCharacteristics transferCharacteristics; + avifMatrixCoefficients matrixCoefficients; + avifRange range; +} avifSequenceHeader; +avifBool avifSequenceHeaderParse(avifSequenceHeader * header, const avifROData * sample); + +// A maximum image size to avoid out-of-memory errors or integer overflow in +// (32-bit) int or unsigned int arithmetic operations. +#define AVIF_MAX_IMAGE_SIZE (16384 * 16384) + #ifdef __cplusplus } // extern "C" #endif diff --git a/chromium/third_party/libavif/src/src/avif.c b/chromium/third_party/libavif/src/src/avif.c index e88d4071de1..98585be194d 100644 --- a/chromium/third_party/libavif/src/src/avif.c +++ b/chromium/third_party/libavif/src/src/avif.c @@ -23,8 +23,8 @@ const char * avifPixelFormatToString(avifPixelFormat format) return "YUV420"; case AVIF_PIXEL_FORMAT_YUV422: return "YUV422"; - case AVIF_PIXEL_FORMAT_YV12: - return "YV12"; + case AVIF_PIXEL_FORMAT_YUV400: + return "YUV400"; case AVIF_PIXEL_FORMAT_NONE: default: break; @@ -35,8 +35,6 @@ const char * avifPixelFormatToString(avifPixelFormat format) void avifGetPixelFormatInfo(avifPixelFormat format, avifPixelFormatInfo * info) { memset(info, 0, sizeof(avifPixelFormatInfo)); - info->aomIndexU = 1; - info->aomIndexV = 2; switch (format) { case AVIF_PIXEL_FORMAT_YUV444: @@ -54,11 +52,10 @@ void avifGetPixelFormatInfo(avifPixelFormat format, avifPixelFormatInfo * info) info->chromaShiftY = 1; break; - case AVIF_PIXEL_FORMAT_YV12: + case AVIF_PIXEL_FORMAT_YUV400: info->chromaShiftX = 1; info->chromaShiftY = 1; - info->aomIndexU = 2; - info->aomIndexV = 1; + info->monochrome = AVIF_TRUE; break; case AVIF_PIXEL_FORMAT_NONE: @@ -124,7 +121,7 @@ avifImage * avifImageCreateEmpty(void) return avifImageCreate(0, 0, 0, AVIF_PIXEL_FORMAT_NONE); } -void avifImageCopy(avifImage * dstImage, avifImage * srcImage) +void avifImageCopy(avifImage * dstImage, const avifImage * srcImage, uint32_t planes) { avifImageFreePlanes(dstImage, AVIF_PLANES_ALL); @@ -133,6 +130,7 @@ void avifImageCopy(avifImage * dstImage, avifImage * srcImage) dstImage->depth = srcImage->depth; dstImage->yuvFormat = srcImage->yuvFormat; dstImage->yuvRange = srcImage->yuvRange; + dstImage->yuvChromaSamplePosition = srcImage->yuvChromaSamplePosition; dstImage->alphaRange = srcImage->alphaRange; dstImage->colorPrimaries = srcImage->colorPrimaries; @@ -150,41 +148,33 @@ void avifImageCopy(avifImage * dstImage, avifImage * srcImage) avifImageSetMetadataExif(dstImage, srcImage->exif.data, srcImage->exif.size); avifImageSetMetadataXMP(dstImage, srcImage->xmp.data, srcImage->xmp.size); - if (srcImage->yuvPlanes[AVIF_CHAN_Y]) { + if ((planes & AVIF_PLANES_YUV) && srcImage->yuvPlanes[AVIF_CHAN_Y]) { avifImageAllocatePlanes(dstImage, AVIF_PLANES_YUV); avifPixelFormatInfo formatInfo; avifGetPixelFormatInfo(srcImage->yuvFormat, &formatInfo); - int uvHeight = (dstImage->height + formatInfo.chromaShiftY) >> formatInfo.chromaShiftY; + uint32_t uvHeight = (dstImage->height + formatInfo.chromaShiftY) >> formatInfo.chromaShiftY; for (int yuvPlane = 0; yuvPlane < 3; ++yuvPlane) { - int aomPlaneIndex = yuvPlane; - int planeHeight = dstImage->height; - if (yuvPlane == AVIF_CHAN_U) { - aomPlaneIndex = formatInfo.aomIndexU; - planeHeight = uvHeight; - } else if (yuvPlane == AVIF_CHAN_V) { - aomPlaneIndex = formatInfo.aomIndexV; - planeHeight = uvHeight; - } + uint32_t planeHeight = (yuvPlane == AVIF_CHAN_Y) ? dstImage->height : uvHeight; - if (!srcImage->yuvRowBytes[aomPlaneIndex]) { + if (!srcImage->yuvRowBytes[yuvPlane]) { // plane is absent. If we're copying from a source without // them, mimic the source image's state by removing our copy. - avifFree(dstImage->yuvPlanes[aomPlaneIndex]); - dstImage->yuvPlanes[aomPlaneIndex] = NULL; - dstImage->yuvRowBytes[aomPlaneIndex] = 0; + avifFree(dstImage->yuvPlanes[yuvPlane]); + dstImage->yuvPlanes[yuvPlane] = NULL; + dstImage->yuvRowBytes[yuvPlane] = 0; continue; } - for (int j = 0; j < planeHeight; ++j) { - uint8_t * srcRow = &srcImage->yuvPlanes[aomPlaneIndex][j * srcImage->yuvRowBytes[aomPlaneIndex]]; + for (uint32_t j = 0; j < planeHeight; ++j) { + uint8_t * srcRow = &srcImage->yuvPlanes[yuvPlane][j * srcImage->yuvRowBytes[yuvPlane]]; uint8_t * dstRow = &dstImage->yuvPlanes[yuvPlane][j * dstImage->yuvRowBytes[yuvPlane]]; memcpy(dstRow, srcRow, dstImage->yuvRowBytes[yuvPlane]); } } } - if (srcImage->alphaPlane) { + if ((planes & AVIF_PLANES_A) && srcImage->alphaPlane) { avifImageAllocatePlanes(dstImage, AVIF_PLANES_A); for (uint32_t j = 0; j < dstImage->height; ++j) { uint8_t * srcAlphaRow = &srcImage->alphaPlane[j * srcImage->alphaRowBytes]; @@ -237,27 +227,32 @@ void avifImageAllocatePlanes(avifImage * image, uint32_t planes) image->yuvRowBytes[AVIF_CHAN_Y] = fullRowBytes; image->yuvPlanes[AVIF_CHAN_Y] = avifAlloc(fullSize); } - if (!image->yuvPlanes[AVIF_CHAN_U]) { - image->yuvRowBytes[AVIF_CHAN_U] = uvRowBytes; - image->yuvPlanes[AVIF_CHAN_U] = avifAlloc(uvSize); - } - if (!image->yuvPlanes[AVIF_CHAN_V]) { - image->yuvRowBytes[AVIF_CHAN_V] = uvRowBytes; - image->yuvPlanes[AVIF_CHAN_V] = avifAlloc(uvSize); + + if (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV400) { + if (!image->yuvPlanes[AVIF_CHAN_U]) { + image->yuvRowBytes[AVIF_CHAN_U] = uvRowBytes; + image->yuvPlanes[AVIF_CHAN_U] = avifAlloc(uvSize); + } + if (!image->yuvPlanes[AVIF_CHAN_V]) { + image->yuvRowBytes[AVIF_CHAN_V] = uvRowBytes; + image->yuvPlanes[AVIF_CHAN_V] = avifAlloc(uvSize); + } } + image->imageOwnsYUVPlanes = AVIF_TRUE; } if (planes & AVIF_PLANES_A) { if (!image->alphaPlane) { image->alphaRowBytes = fullRowBytes; image->alphaPlane = avifAlloc(fullRowBytes * image->height); } + image->imageOwnsAlphaPlane = AVIF_TRUE; } } void avifImageFreePlanes(avifImage * image, uint32_t planes) { if ((planes & AVIF_PLANES_YUV) && (image->yuvFormat != AVIF_PIXEL_FORMAT_NONE)) { - if (!image->decoderOwnsYUVPlanes) { + if (image->imageOwnsYUVPlanes) { avifFree(image->yuvPlanes[AVIF_CHAN_Y]); avifFree(image->yuvPlanes[AVIF_CHAN_U]); avifFree(image->yuvPlanes[AVIF_CHAN_V]); @@ -268,15 +263,15 @@ void avifImageFreePlanes(avifImage * image, uint32_t planes) image->yuvRowBytes[AVIF_CHAN_U] = 0; image->yuvPlanes[AVIF_CHAN_V] = NULL; image->yuvRowBytes[AVIF_CHAN_V] = 0; - image->decoderOwnsYUVPlanes = AVIF_FALSE; + image->imageOwnsYUVPlanes = AVIF_FALSE; } if (planes & AVIF_PLANES_A) { - if (!image->decoderOwnsAlphaPlane) { + if (image->imageOwnsAlphaPlane) { avifFree(image->alphaPlane); } image->alphaPlane = NULL; image->alphaRowBytes = 0; - image->decoderOwnsAlphaPlane = AVIF_FALSE; + image->imageOwnsAlphaPlane = AVIF_FALSE; } } @@ -301,8 +296,9 @@ void avifImageStealPlanes(avifImage * dstImage, avifImage * srcImage, uint32_t p dstImage->yuvFormat = srcImage->yuvFormat; dstImage->yuvRange = srcImage->yuvRange; - dstImage->decoderOwnsYUVPlanes = srcImage->decoderOwnsYUVPlanes; - srcImage->decoderOwnsYUVPlanes = AVIF_FALSE; + dstImage->yuvChromaSamplePosition = srcImage->yuvChromaSamplePosition; + dstImage->imageOwnsYUVPlanes = srcImage->imageOwnsYUVPlanes; + srcImage->imageOwnsYUVPlanes = AVIF_FALSE; } if (planes & AVIF_PLANES_A) { dstImage->alphaPlane = srcImage->alphaPlane; @@ -312,12 +308,12 @@ void avifImageStealPlanes(avifImage * dstImage, avifImage * srcImage, uint32_t p srcImage->alphaPlane = NULL; srcImage->alphaRowBytes = 0; - dstImage->decoderOwnsAlphaPlane = srcImage->decoderOwnsAlphaPlane; - srcImage->decoderOwnsAlphaPlane = AVIF_FALSE; + dstImage->imageOwnsAlphaPlane = srcImage->imageOwnsAlphaPlane; + srcImage->imageOwnsAlphaPlane = AVIF_FALSE; } } -avifBool avifImageUsesU16(avifImage * image) +avifBool avifImageUsesU16(const avifImage * image) { return (image->depth > 8); } @@ -345,17 +341,19 @@ uint32_t avifRGBFormatChannelCount(avifRGBFormat format) return avifRGBFormatHasAlpha(format) ? 4 : 3; } -uint32_t avifRGBImagePixelSize(avifRGBImage * rgb) +uint32_t avifRGBImagePixelSize(const avifRGBImage * rgb) { return avifRGBFormatChannelCount(rgb->format) * ((rgb->depth > 8) ? 2 : 1); } -void avifRGBImageSetDefaults(avifRGBImage * rgb, avifImage * image) +void avifRGBImageSetDefaults(avifRGBImage * rgb, const avifImage * image) { rgb->width = image->width; rgb->height = image->height; rgb->depth = image->depth; rgb->format = AVIF_RGB_FORMAT_RGBA; + rgb->chromaUpsampling = AVIF_CHROMA_UPSAMPLING_BILINEAR; + rgb->ignoreAlpha = AVIF_FALSE; rgb->pixels = NULL; rgb->rowBytes = 0; } diff --git a/chromium/third_party/libavif/src/src/codec_aom.c b/chromium/third_party/libavif/src/src/codec_aom.c index 56fa4751ee7..10bc8e87d92 100644 --- a/chromium/third_party/libavif/src/src/codec_aom.c +++ b/chromium/third_party/libavif/src/src/codec_aom.c @@ -34,6 +34,12 @@ struct avifCodecInternal aom_codec_iter_t iter; uint32_t inputSampleIndex; aom_image_t * image; + + avifBool encoderInitialized; + aom_codec_ctx_t encoder; + avifPixelFormatInfo formatInfo; + aom_img_fmt_t aomFormat; + avifBool monochromeEnabled; }; static void aomCodecDestroyInternal(avifCodec * codec) @@ -41,6 +47,9 @@ static void aomCodecDestroyInternal(avifCodec * codec) if (codec->internal->decoderInitialized) { aom_codec_destroy(&codec->internal->decoder); } + if (codec->internal->encoderInitialized) { + aom_codec_destroy(&codec->internal->encoder); + } avifFree(codec->internal); } @@ -71,7 +80,7 @@ static avifBool aomCodecGetNextImage(avifCodec * codec, avifImage * image) break; } else if (codec->internal->inputSampleIndex < codec->decodeInput->samples.count) { // Feed another sample - avifSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; + avifDecodeSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; ++codec->internal->inputSampleIndex; codec->internal->iter = NULL; if (aom_codec_decode(&codec->internal->decoder, sample->data.data, sample->data.size, NULL)) { @@ -112,14 +121,15 @@ static avifBool aomCodecGetNextImage(avifCodec * codec, avifImage * image) case AOM_IMG_FMT_I44416: yuvFormat = AVIF_PIXEL_FORMAT_YUV444; break; + case AOM_IMG_FMT_NONE: case AOM_IMG_FMT_YV12: case AOM_IMG_FMT_AOMYV12: case AOM_IMG_FMT_YV1216: - yuvFormat = AVIF_PIXEL_FORMAT_YV12; - break; - case AOM_IMG_FMT_NONE: default: - break; + return AVIF_FALSE; + } + if (codec->internal->image->monochrome) { + yuvFormat = AVIF_PIXEL_FORMAT_YUV400; } if (image->width && image->height) { @@ -145,17 +155,12 @@ static avifBool aomCodecGetNextImage(avifCodec * codec, avifImage * image) // Steal the pointers from the decoder's image directly avifImageFreePlanes(image, AVIF_PLANES_YUV); - for (int yuvPlane = 0; yuvPlane < 3; ++yuvPlane) { - int aomPlaneIndex = yuvPlane; - if (yuvPlane == AVIF_CHAN_U) { - aomPlaneIndex = formatInfo.aomIndexU; - } else if (yuvPlane == AVIF_CHAN_V) { - aomPlaneIndex = formatInfo.aomIndexV; - } - image->yuvPlanes[yuvPlane] = codec->internal->image->planes[aomPlaneIndex]; - image->yuvRowBytes[yuvPlane] = codec->internal->image->stride[aomPlaneIndex]; + int yuvPlaneCount = (yuvFormat == AVIF_PIXEL_FORMAT_YUV400) ? 1 : 3; + for (int yuvPlane = 0; yuvPlane < yuvPlaneCount; ++yuvPlane) { + image->yuvPlanes[yuvPlane] = codec->internal->image->planes[yuvPlane]; + image->yuvRowBytes[yuvPlane] = codec->internal->image->stride[yuvPlane]; } - image->decoderOwnsYUVPlanes = AVIF_TRUE; + image->imageOwnsYUVPlanes = AVIF_FALSE; } else { // Alpha plane - ensure image is correct size, fill color @@ -174,21 +179,18 @@ static avifBool aomCodecGetNextImage(avifCodec * codec, avifImage * image) image->alphaPlane = codec->internal->image->planes[0]; image->alphaRowBytes = codec->internal->image->stride[0]; image->alphaRange = (codec->internal->image->range == AOM_CR_STUDIO_RANGE) ? AVIF_RANGE_LIMITED : AVIF_RANGE_FULL; - image->decoderOwnsAlphaPlane = AVIF_TRUE; + image->imageOwnsAlphaPlane = AVIF_FALSE; } return AVIF_TRUE; } -static aom_img_fmt_t avifImageCalcAOMFmt(avifImage * image, avifBool alpha, int * yShift) +static aom_img_fmt_t avifImageCalcAOMFmt(const avifImage * image, avifBool alpha) { - *yShift = 0; - aom_img_fmt_t fmt; if (alpha) { // We're going monochrome, who cares about chroma quality fmt = AOM_IMG_FMT_I420; - *yShift = 1; } else { switch (image->yuvFormat) { case AVIF_PIXEL_FORMAT_YUV444: @@ -198,12 +200,8 @@ static aom_img_fmt_t avifImageCalcAOMFmt(avifImage * image, avifBool alpha, int fmt = AOM_IMG_FMT_I422; break; case AVIF_PIXEL_FORMAT_YUV420: + case AVIF_PIXEL_FORMAT_YUV400: fmt = AOM_IMG_FMT_I420; - *yShift = 1; - break; - case AVIF_PIXEL_FORMAT_YV12: - fmt = AOM_IMG_FMT_YV12; - *yShift = 1; break; case AVIF_PIXEL_FORMAT_NONE: default: @@ -218,145 +216,169 @@ static aom_img_fmt_t avifImageCalcAOMFmt(avifImage * image, avifBool alpha, int return fmt; } -static avifBool aomCodecEncodeImage(avifCodec * codec, avifImage * image, avifEncoder * encoder, avifRWData * obu, avifBool alpha) +static avifBool aomCodecEncodeImage(avifCodec * codec, + avifEncoder * encoder, + const avifImage * image, + avifBool alpha, + uint32_t addImageFlags, + avifCodecEncodeOutput * output) { - avifBool success = AVIF_FALSE; - aom_codec_iface_t * encoder_interface = aom_codec_av1_cx(); - aom_codec_ctx_t aomEncoder; - - // Map encoder speed to AOM usage + CpuUsed: - // Speed 0: GoodQuality CpuUsed 0 - // Speed 1: GoodQuality CpuUsed 1 - // Speed 2: GoodQuality CpuUsed 2 - // Speed 3: GoodQuality CpuUsed 3 - // Speed 4: GoodQuality CpuUsed 4 - // Speed 5: GoodQuality CpuUsed 5 - // Speed 6: GoodQuality CpuUsed 5 - // Speed 7: GoodQuality CpuUsed 5 - // Speed 8: RealTime CpuUsed 6 - // Speed 9: RealTime CpuUsed 7 - // Speed 10: RealTime CpuUsed 8 - unsigned int aomUsage = AOM_USAGE_GOOD_QUALITY; - int aomCpuUsed = -1; - if (encoder->speed != AVIF_SPEED_DEFAULT) { - if (encoder->speed < 8) { - aomUsage = AOM_USAGE_GOOD_QUALITY; - aomCpuUsed = AVIF_CLAMP(encoder->speed, 0, 5); - } else { - aomUsage = AOM_USAGE_REALTIME; - aomCpuUsed = AVIF_CLAMP(encoder->speed - 2, 6, 8); + if (!codec->internal->encoderInitialized) { + // Map encoder speed to AOM usage + CpuUsed: + // Speed 0: GoodQuality CpuUsed 0 + // Speed 1: GoodQuality CpuUsed 1 + // Speed 2: GoodQuality CpuUsed 2 + // Speed 3: GoodQuality CpuUsed 3 + // Speed 4: GoodQuality CpuUsed 4 + // Speed 5: GoodQuality CpuUsed 5 + // Speed 6: GoodQuality CpuUsed 6 + // Speed 7: GoodQuality CpuUsed 6 + // Speed 8: RealTime CpuUsed 6 + // Speed 9: RealTime CpuUsed 7 + // Speed 10: RealTime CpuUsed 8 + unsigned int aomUsage = AOM_USAGE_GOOD_QUALITY; + int aomCpuUsed = -1; + if (encoder->speed != AVIF_SPEED_DEFAULT) { + if (encoder->speed < 8) { + aomUsage = AOM_USAGE_GOOD_QUALITY; + aomCpuUsed = AVIF_CLAMP(encoder->speed, 0, 6); + } else { + aomUsage = AOM_USAGE_REALTIME; + aomCpuUsed = AVIF_CLAMP(encoder->speed - 2, 6, 8); + } } - } - int aomMajorVersion = aom_codec_version_major(); - if ((aomMajorVersion < 2) && (image->depth > 8)) { - // Due to a known issue with libavif v1.0.0-errata1-avif, 10bpc and - // 12bpc image encodes will call the wrong variant of - // aom_subtract_block when cpu-used is 7 or 8, and crash. Until we get - // a new tagged release from libaom with the fix and can verify we're - // running with that version of libaom, we must avoid using - // cpu-used=7/8 on any >8bpc image encodes. - // - // Context: - // * https://github.com/AOMediaCodec/libavif/issues/49 - // * https://bugs.chromium.org/p/aomedia/issues/detail?id=2587 - // - // Continued bug tracking here: - // * https://github.com/AOMediaCodec/libavif/issues/56 - - if (aomCpuUsed > 6) { - aomCpuUsed = 6; + // aom_codec.h says: aom_codec_version() == (major<<16 | minor<<8 | patch) + static const int aomVersion_2_0_0 = (2 << 16); + const int aomVersion = aom_codec_version(); + if ((aomVersion < aomVersion_2_0_0) && (image->depth > 8)) { + // Due to a known issue with libavif v1.0.0-errata1-avif, 10bpc and + // 12bpc image encodes will call the wrong variant of + // aom_subtract_block when cpu-used is 7 or 8, and crash. Until we get + // a new tagged release from libaom with the fix and can verify we're + // running with that version of libaom, we must avoid using + // cpu-used=7/8 on any >8bpc image encodes. + // + // Context: + // * https://github.com/AOMediaCodec/libavif/issues/49 + // * https://bugs.chromium.org/p/aomedia/issues/detail?id=2587 + // + // Continued bug tracking here: + // * https://github.com/AOMediaCodec/libavif/issues/56 + + if (aomCpuUsed > 6) { + aomCpuUsed = 6; + } } - } - int yShift = 0; - aom_img_fmt_t aomFormat = avifImageCalcAOMFmt(image, alpha, &yShift); - if (aomFormat == AOM_IMG_FMT_NONE) { - return AVIF_FALSE; - } + codec->internal->aomFormat = avifImageCalcAOMFmt(image, alpha); + if (codec->internal->aomFormat == AOM_IMG_FMT_NONE) { + return AVIF_FALSE; + } - avifPixelFormatInfo formatInfo; - avifGetPixelFormatInfo(image->yuvFormat, &formatInfo); - - struct aom_codec_enc_cfg cfg; - aom_codec_enc_config_default(encoder_interface, &cfg, aomUsage); - - cfg.g_profile = codec->configBox.seqProfile; - cfg.g_bit_depth = image->depth; - cfg.g_input_bit_depth = image->depth; - cfg.g_w = image->width; - cfg.g_h = image->height; - if (encoder->maxThreads > 1) { - cfg.g_threads = encoder->maxThreads; - } + avifGetPixelFormatInfo(image->yuvFormat, &codec->internal->formatInfo); + + aom_codec_iface_t * encoderInterface = aom_codec_av1_cx(); + struct aom_codec_enc_cfg cfg; + aom_codec_enc_config_default(encoderInterface, &cfg, aomUsage); + + cfg.g_profile = codec->configBox.seqProfile; + cfg.g_bit_depth = image->depth; + cfg.g_input_bit_depth = image->depth; + cfg.g_w = image->width; + cfg.g_h = image->height; + if (addImageFlags & AVIF_ADD_IMAGE_FLAG_SINGLE) { + // Set the maximum number of frames to encode to 1. This instructs + // libaom to set still_picture and reduced_still_picture_header to + // 1 in AV1 sequence headers. + cfg.g_limit = 1; + } + if (encoder->maxThreads > 1) { + cfg.g_threads = encoder->maxThreads; + } - int minQuantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63); - int maxQuantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63); - if (alpha) { - minQuantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63); - maxQuantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63); - } - avifBool lossless = ((minQuantizer == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizer == AVIF_QUANTIZER_LOSSLESS)); - cfg.rc_min_quantizer = minQuantizer; - cfg.rc_max_quantizer = maxQuantizer; + int minQuantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63); + int maxQuantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63); + if (alpha) { + minQuantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63); + maxQuantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63); + } + avifBool lossless = ((minQuantizer == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizer == AVIF_QUANTIZER_LOSSLESS)); + cfg.rc_min_quantizer = minQuantizer; + cfg.rc_max_quantizer = maxQuantizer; + + codec->internal->monochromeEnabled = AVIF_FALSE; + if (aomVersion > aomVersion_2_0_0) { + // There exists a bug in libaom's chroma_check() function where it will attempt to + // access nonexistent UV planes when encoding monochrome at faster libavif "speeds". It + // was fixed shortly after the 2.0.0 libaom release, and the fix exists in both the + // master and applejack branches. This ensures that the next version *after* 2.0.0 will + // have the fix, and we must avoid cfg.monochrome until then. + // + // Bugfix Change-Id: https://aomedia-review.googlesource.com/q/I26a39791f820b4d4e1d63ff7141f594c3c7181f5 + + if (alpha || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) { + codec->internal->monochromeEnabled = AVIF_TRUE; + cfg.monochrome = 1; + } + } - aom_codec_flags_t encoderFlags = 0; - if (image->depth > 8) { - encoderFlags |= AOM_CODEC_USE_HIGHBITDEPTH; - } - aom_codec_enc_init(&aomEncoder, encoder_interface, &cfg, encoderFlags); + aom_codec_flags_t encoderFlags = 0; + if (image->depth > 8) { + encoderFlags |= AOM_CODEC_USE_HIGHBITDEPTH; + } + aom_codec_enc_init(&codec->internal->encoder, encoderInterface, &cfg, encoderFlags); + codec->internal->encoderInitialized = AVIF_TRUE; - if (lossless) { - aom_codec_control(&aomEncoder, AV1E_SET_LOSSLESS, 1); - } - if (encoder->maxThreads > 1) { - aom_codec_control(&aomEncoder, AV1E_SET_ROW_MT, 1); - } - if (encoder->tileRowsLog2 != 0) { - int tileRowsLog2 = AVIF_CLAMP(encoder->tileRowsLog2, 0, 6); - aom_codec_control(&aomEncoder, AV1E_SET_TILE_ROWS, tileRowsLog2); - } - if (encoder->tileColsLog2 != 0) { - int tileColsLog2 = AVIF_CLAMP(encoder->tileColsLog2, 0, 6); - aom_codec_control(&aomEncoder, AV1E_SET_TILE_COLUMNS, tileColsLog2); - } - if (aomCpuUsed != -1) { - aom_codec_control(&aomEncoder, AOME_SET_CPUUSED, aomCpuUsed); + if (lossless) { + aom_codec_control(&codec->internal->encoder, AV1E_SET_LOSSLESS, 1); + } + if (encoder->maxThreads > 1) { + aom_codec_control(&codec->internal->encoder, AV1E_SET_ROW_MT, 1); + } + if (encoder->tileRowsLog2 != 0) { + int tileRowsLog2 = AVIF_CLAMP(encoder->tileRowsLog2, 0, 6); + aom_codec_control(&codec->internal->encoder, AV1E_SET_TILE_ROWS, tileRowsLog2); + } + if (encoder->tileColsLog2 != 0) { + int tileColsLog2 = AVIF_CLAMP(encoder->tileColsLog2, 0, 6); + aom_codec_control(&codec->internal->encoder, AV1E_SET_TILE_COLUMNS, tileColsLog2); + } + if (aomCpuUsed != -1) { + aom_codec_control(&codec->internal->encoder, AOME_SET_CPUUSED, aomCpuUsed); + } } + int yShift = codec->internal->formatInfo.chromaShiftY; uint32_t uvHeight = (image->height + yShift) >> yShift; - aom_image_t * aomImage = aom_img_alloc(NULL, aomFormat, image->width, image->height, 16); + aom_image_t * aomImage = aom_img_alloc(NULL, codec->internal->aomFormat, image->width, image->height, 16); + avifBool monochromeRequested = AVIF_FALSE; if (alpha) { aomImage->range = (image->alphaRange == AVIF_RANGE_FULL) ? AOM_CR_FULL_RANGE : AOM_CR_STUDIO_RANGE; - aom_codec_control(&aomEncoder, AV1E_SET_COLOR_RANGE, aomImage->range); - aomImage->monochrome = 1; + aom_codec_control(&codec->internal->encoder, AV1E_SET_COLOR_RANGE, aomImage->range); + monochromeRequested = AVIF_TRUE; for (uint32_t j = 0; j < image->height; ++j) { uint8_t * srcAlphaRow = &image->alphaPlane[j * image->alphaRowBytes]; uint8_t * dstAlphaRow = &aomImage->planes[0][j * aomImage->stride[0]]; memcpy(dstAlphaRow, srcAlphaRow, image->alphaRowBytes); } - // Zero out U and V - memset(aomImage->planes[1], 0, aomImage->stride[1] * uvHeight); - memset(aomImage->planes[2], 0, aomImage->stride[2] * uvHeight); + // Ignore UV planes when monochrome } else { aomImage->range = (image->yuvRange == AVIF_RANGE_FULL) ? AOM_CR_FULL_RANGE : AOM_CR_STUDIO_RANGE; - aom_codec_control(&aomEncoder, AV1E_SET_COLOR_RANGE, aomImage->range); - for (int yuvPlane = 0; yuvPlane < 3; ++yuvPlane) { - int aomPlaneIndex = yuvPlane; - int planeHeight = image->height; - if (yuvPlane == AVIF_CHAN_U) { - aomPlaneIndex = formatInfo.aomIndexU; - planeHeight = uvHeight; - } else if (yuvPlane == AVIF_CHAN_V) { - aomPlaneIndex = formatInfo.aomIndexV; - planeHeight = uvHeight; - } + aom_codec_control(&codec->internal->encoder, AV1E_SET_COLOR_RANGE, aomImage->range); + int yuvPlaneCount = 3; + if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) { + yuvPlaneCount = 1; // Ignore UV planes when monochrome + monochromeRequested = AVIF_TRUE; + } + for (int yuvPlane = 0; yuvPlane < yuvPlaneCount; ++yuvPlane) { + uint32_t planeHeight = (yuvPlane == AVIF_CHAN_Y) ? image->height : uvHeight; - for (int j = 0; j < planeHeight; ++j) { + for (uint32_t j = 0; j < planeHeight; ++j) { uint8_t * srcRow = &image->yuvPlanes[yuvPlane][j * image->yuvRowBytes[yuvPlane]]; - uint8_t * dstRow = &aomImage->planes[aomPlaneIndex][j * aomImage->stride[aomPlaneIndex]]; + uint8_t * dstRow = &aomImage->planes[yuvPlane][j * aomImage->stride[yuvPlane]]; memcpy(dstRow, srcRow, image->yuvRowBytes[yuvPlane]); } } @@ -364,35 +386,84 @@ static avifBool aomCodecEncodeImage(avifCodec * codec, avifImage * image, avifEn aomImage->cp = (aom_color_primaries_t)image->colorPrimaries; aomImage->tc = (aom_transfer_characteristics_t)image->transferCharacteristics; aomImage->mc = (aom_matrix_coefficients_t)image->matrixCoefficients; - aom_codec_control(&aomEncoder, AV1E_SET_COLOR_PRIMARIES, aomImage->cp); - aom_codec_control(&aomEncoder, AV1E_SET_TRANSFER_CHARACTERISTICS, aomImage->tc); - aom_codec_control(&aomEncoder, AV1E_SET_MATRIX_COEFFICIENTS, aomImage->mc); + aomImage->csp = (aom_chroma_sample_position_t)image->yuvChromaSamplePosition; + aom_codec_control(&codec->internal->encoder, AV1E_SET_COLOR_PRIMARIES, aomImage->cp); + aom_codec_control(&codec->internal->encoder, AV1E_SET_TRANSFER_CHARACTERISTICS, aomImage->tc); + aom_codec_control(&codec->internal->encoder, AV1E_SET_MATRIX_COEFFICIENTS, aomImage->mc); + aom_codec_control(&codec->internal->encoder, AV1E_SET_CHROMA_SAMPLE_POSITION, aomImage->csp); + } + + if (monochromeRequested && !codec->internal->monochromeEnabled) { + // The user requested monochrome (via alpha or YUV400) but libaom cannot currently support + // monochrome (see chroma_check comment above). Manually set UV planes to 0.5. + + // aomImage is always 420 when we're monochrome + uint32_t monoUVWidth = (image->width + 1) >> 1; + uint32_t monoUVHeight = (image->height + 1) >> 1; + + for (int yuvPlane = 1; yuvPlane < 3; ++yuvPlane) { + if (image->depth > 8) { + const uint16_t half = 1 << (image->depth - 1); + for (uint32_t j = 0; j < monoUVHeight; ++j) { + uint16_t * dstRow = (uint16_t *)&aomImage->planes[yuvPlane][j * aomImage->stride[yuvPlane]]; + for (uint32_t i = 0; i < monoUVWidth; ++i) { + dstRow[i] = half; + } + } + } else { + const uint8_t half = 128; + size_t planeSize = (size_t)monoUVHeight * aomImage->stride[yuvPlane]; + memset(aomImage->planes[yuvPlane], half, planeSize); + } + } } - aom_codec_encode(&aomEncoder, aomImage, 0, 1, 0); + aom_enc_frame_flags_t encodeFlags = 0; + if (addImageFlags & AVIF_ADD_IMAGE_FLAG_FORCE_KEYFRAME) { + encodeFlags |= AOM_EFLAG_FORCE_KF; + } + aom_codec_encode(&codec->internal->encoder, aomImage, 0, 1, encodeFlags); - avifBool flushed = AVIF_FALSE; aom_codec_iter_t iter = NULL; for (;;) { - const aom_codec_cx_pkt_t * pkt = aom_codec_get_cx_data(&aomEncoder, &iter); + const aom_codec_cx_pkt_t * pkt = aom_codec_get_cx_data(&codec->internal->encoder, &iter); if (pkt == NULL) { - if (flushed) - break; - - aom_codec_encode(&aomEncoder, NULL, 0, 1, 0); // flush - flushed = AVIF_TRUE; - continue; + break; } if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) { - avifRWDataSet(obu, pkt->data.frame.buf, pkt->data.frame.sz); - success = AVIF_TRUE; - break; + avifCodecEncodeOutputAddSample(output, pkt->data.frame.buf, pkt->data.frame.sz, (pkt->data.frame.flags & AOM_FRAME_IS_KEY)); } } aom_img_free(aomImage); - aom_codec_destroy(&aomEncoder); - return success; + return AVIF_TRUE; +} + +static avifBool aomCodecEncodeFinish(avifCodec * codec, avifCodecEncodeOutput * output) +{ + for (;;) { + // flush encoder + aom_codec_encode(&codec->internal->encoder, NULL, 0, 1, 0); + + avifBool gotPacket = AVIF_FALSE; + aom_codec_iter_t iter = NULL; + for (;;) { + const aom_codec_cx_pkt_t * pkt = aom_codec_get_cx_data(&codec->internal->encoder, &iter); + if (pkt == NULL) { + break; + } + if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) { + gotPacket = AVIF_TRUE; + avifCodecEncodeOutputAddSample( + output, pkt->data.frame.buf, pkt->data.frame.sz, (pkt->data.frame.flags & AOM_FRAME_IS_KEY)); + } + } + + if (!gotPacket) { + break; + } + } + return AVIF_TRUE; } const char * avifCodecVersionAOM(void) @@ -407,6 +478,7 @@ avifCodec * avifCodecCreateAOM(void) codec->open = aomCodecOpen; codec->getNextImage = aomCodecGetNextImage; codec->encodeImage = aomCodecEncodeImage; + codec->encodeFinish = aomCodecEncodeFinish; codec->destroyInternal = aomCodecDestroyInternal; codec->internal = (struct avifCodecInternal *)avifAlloc(sizeof(struct avifCodecInternal)); diff --git a/chromium/third_party/libavif/src/src/codec_dav1d.c b/chromium/third_party/libavif/src/src/codec_dav1d.c index a20a377a9a9..b1c9c4b279a 100644 --- a/chromium/third_party/libavif/src/src/codec_dav1d.c +++ b/chromium/third_party/libavif/src/src/codec_dav1d.c @@ -52,7 +52,7 @@ static avifBool dav1dFeedData(avifCodec * codec) { if (!codec->internal->dav1dData.sz) { if (codec->internal->inputSampleIndex < codec->decodeInput->samples.count) { - avifSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; + avifDecodeSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; ++codec->internal->inputSampleIndex; if (dav1d_data_wrap(&codec->internal->dav1dData, sample->data.data, sample->data.size, avifDav1dFreeCallback, NULL) != 0) { @@ -126,6 +126,8 @@ static avifBool dav1dCodecGetNextImage(avifCodec * codec, avifImage * image) avifPixelFormat yuvFormat = AVIF_PIXEL_FORMAT_NONE; switch (dav1dImage->p.layout) { case DAV1D_PIXEL_LAYOUT_I400: + yuvFormat = AVIF_PIXEL_FORMAT_YUV400; + break; case DAV1D_PIXEL_LAYOUT_I420: yuvFormat = AVIF_PIXEL_FORMAT_YUV420; break; @@ -159,11 +161,12 @@ static avifBool dav1dCodecGetNextImage(avifCodec * codec, avifImage * image) avifGetPixelFormatInfo(yuvFormat, &formatInfo); avifImageFreePlanes(image, AVIF_PLANES_YUV); - for (int yuvPlane = 0; yuvPlane < 3; ++yuvPlane) { + int yuvPlaneCount = (yuvFormat == AVIF_PIXEL_FORMAT_YUV400) ? 1 : 3; + for (int yuvPlane = 0; yuvPlane < yuvPlaneCount; ++yuvPlane) { image->yuvPlanes[yuvPlane] = dav1dImage->data[yuvPlane]; image->yuvRowBytes[yuvPlane] = (uint32_t)dav1dImage->stride[(yuvPlane == AVIF_CHAN_Y) ? 0 : 1]; } - image->decoderOwnsYUVPlanes = AVIF_TRUE; + image->imageOwnsYUVPlanes = AVIF_FALSE; } else { // Alpha plane - ensure image is correct size, fill color @@ -182,7 +185,7 @@ static avifBool dav1dCodecGetNextImage(avifCodec * codec, avifImage * image) image->alphaPlane = dav1dImage->data[0]; image->alphaRowBytes = (uint32_t)dav1dImage->stride[0]; image->alphaRange = codec->internal->colorRange; - image->decoderOwnsAlphaPlane = AVIF_TRUE; + image->imageOwnsAlphaPlane = AVIF_FALSE; } return AVIF_TRUE; } @@ -204,6 +207,6 @@ avifCodec * avifCodecCreateDav1d(void) memset(codec->internal, 0, sizeof(struct avifCodecInternal)); dav1d_default_settings(&codec->internal->dav1dSettings); // Set a maximum frame size limit to avoid OOM'ing fuzzers. - codec->internal->dav1dSettings.frame_size_limit = 16384 * 16384; + codec->internal->dav1dSettings.frame_size_limit = AVIF_MAX_IMAGE_SIZE; return codec; } diff --git a/chromium/third_party/libavif/src/src/codec_libgav1.c b/chromium/third_party/libavif/src/src/codec_libgav1.c index d7260c3d8a8..cb020caa40e 100644 --- a/chromium/third_party/libavif/src/src/codec_libgav1.c +++ b/chromium/third_party/libavif/src/src/codec_libgav1.c @@ -42,7 +42,7 @@ static avifBool gav1CodecGetNextImage(avifCodec * codec, avifImage * image) // Check if there are more samples to feed if (codec->internal->inputSampleIndex < codec->decodeInput->samples.count) { // Feed another sample - avifSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; + avifDecodeSample * sample = &codec->decodeInput->samples.sample[codec->internal->inputSampleIndex]; ++codec->internal->inputSampleIndex; if (Libgav1DecoderEnqueueFrame(codec->internal->gav1Decoder, sample->data.data, @@ -80,6 +80,8 @@ static avifBool gav1CodecGetNextImage(avifCodec * codec, avifImage * image) avifPixelFormat yuvFormat = AVIF_PIXEL_FORMAT_NONE; switch (gav1Image->image_format) { case kLibgav1ImageFormatMonochrome400: + yuvFormat = AVIF_PIXEL_FORMAT_YUV400; + break; case kLibgav1ImageFormatYuv420: yuvFormat = AVIF_PIXEL_FORMAT_YUV420; break; @@ -115,11 +117,12 @@ static avifBool gav1CodecGetNextImage(avifCodec * codec, avifImage * image) // Steal the pointers from the decoder's image directly avifImageFreePlanes(image, AVIF_PLANES_YUV); - for (int yuvPlane = 0; yuvPlane < 3; ++yuvPlane) { + int yuvPlaneCount = (yuvFormat == AVIF_PIXEL_FORMAT_YUV400) ? 1 : 3; + for (int yuvPlane = 0; yuvPlane < yuvPlaneCount; ++yuvPlane) { image->yuvPlanes[yuvPlane] = gav1Image->plane[yuvPlane]; image->yuvRowBytes[yuvPlane] = gav1Image->stride[yuvPlane]; } - image->decoderOwnsYUVPlanes = AVIF_TRUE; + image->imageOwnsYUVPlanes = AVIF_FALSE; } else { // Alpha plane - ensure image is correct size, fill color @@ -138,7 +141,7 @@ static avifBool gav1CodecGetNextImage(avifCodec * codec, avifImage * image) image->alphaPlane = gav1Image->plane[0]; image->alphaRowBytes = gav1Image->stride[0]; image->alphaRange = codec->internal->colorRange; - image->decoderOwnsAlphaPlane = AVIF_TRUE; + image->imageOwnsAlphaPlane = AVIF_FALSE; } return AVIF_TRUE; diff --git a/chromium/third_party/libavif/src/src/codec_rav1e.c b/chromium/third_party/libavif/src/src/codec_rav1e.c index 5c8b332b72f..6a7fb226f8e 100644 --- a/chromium/third_party/libavif/src/src/codec_rav1e.c +++ b/chromium/third_party/libavif/src/src/codec_rav1e.c @@ -9,162 +9,212 @@ struct avifCodecInternal { - uint32_t unused; // rav1e codec has no state + RaContext * rav1eContext; + RaChromaSampling chromaSampling; + int yShift; }; static void rav1eCodecDestroyInternal(avifCodec * codec) { + if (codec->internal->rav1eContext) { + rav1e_context_unref(codec->internal->rav1eContext); + codec->internal->rav1eContext = NULL; + } avifFree(codec->internal); } static avifBool rav1eCodecOpen(struct avifCodec * codec, uint32_t firstSampleIndex) { (void)firstSampleIndex; // Codec is encode-only, this isn't used - (void)codec; + + codec->internal->rav1eContext = NULL; return AVIF_TRUE; } -static avifBool rav1eCodecEncodeImage(avifCodec * codec, avifImage * image, avifEncoder * encoder, avifRWData * obu, avifBool alpha) +// Official support wasn't added until v0.4.0 +static avifBool rav1eSupports400(void) { - (void)codec; // unused + const char * rav1eVersionString = rav1e_version_short(); + + // Check major version > 0 + int majorVersion = atoi(rav1eVersionString); + if (majorVersion > 0) { + return AVIF_TRUE; + } + // Check minor version >= 4 + const char * minorVersionString = strchr(rav1eVersionString, '.'); + if (!minorVersionString) { + return AVIF_FALSE; + } + ++minorVersionString; + if (!(*minorVersionString)) { + return AVIF_FALSE; + } + int minorVersion = atoi(minorVersionString); + return minorVersion >= 4; +} + +static avifBool rav1eCodecEncodeImage(avifCodec * codec, + avifEncoder * encoder, + const avifImage * image, + avifBool alpha, + uint32_t addImageFlags, + avifCodecEncodeOutput * output) +{ avifBool success = AVIF_FALSE; RaConfig * rav1eConfig = NULL; - RaContext * rav1eContext = NULL; RaFrame * rav1eFrame = NULL; - RaPacket * pkt = NULL; - int yShift = 0; - RaChromaSampling chromaSampling; - RaPixelRange rav1eRange; - if (alpha) { - rav1eRange = (image->alphaRange == AVIF_RANGE_FULL) ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED; - chromaSampling = RA_CHROMA_SAMPLING_CS422; // I can't seem to get RA_CHROMA_SAMPLING_CS400 to work right now, unfortunately - } else { - rav1eRange = (image->yuvRange == AVIF_RANGE_FULL) ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED; - switch (image->yuvFormat) { - case AVIF_PIXEL_FORMAT_YUV444: - chromaSampling = RA_CHROMA_SAMPLING_CS444; - break; - case AVIF_PIXEL_FORMAT_YUV422: - chromaSampling = RA_CHROMA_SAMPLING_CS422; - break; - case AVIF_PIXEL_FORMAT_YUV420: - chromaSampling = RA_CHROMA_SAMPLING_CS420; - yShift = 1; - break; - case AVIF_PIXEL_FORMAT_YV12: - case AVIF_PIXEL_FORMAT_NONE: - default: - return AVIF_FALSE; + if (!codec->internal->rav1eContext) { + const avifBool supports400 = rav1eSupports400(); + RaPixelRange rav1eRange; + if (alpha) { + rav1eRange = (image->alphaRange == AVIF_RANGE_FULL) ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED; + codec->internal->chromaSampling = supports400 ? RA_CHROMA_SAMPLING_CS400 : RA_CHROMA_SAMPLING_CS420; + codec->internal->yShift = 1; + } else { + rav1eRange = (image->yuvRange == AVIF_RANGE_FULL) ? RA_PIXEL_RANGE_FULL : RA_PIXEL_RANGE_LIMITED; + codec->internal->yShift = 0; + switch (image->yuvFormat) { + case AVIF_PIXEL_FORMAT_YUV444: + codec->internal->chromaSampling = RA_CHROMA_SAMPLING_CS444; + break; + case AVIF_PIXEL_FORMAT_YUV422: + codec->internal->chromaSampling = RA_CHROMA_SAMPLING_CS422; + break; + case AVIF_PIXEL_FORMAT_YUV420: + codec->internal->chromaSampling = RA_CHROMA_SAMPLING_CS420; + codec->internal->yShift = 1; + break; + case AVIF_PIXEL_FORMAT_YUV400: + codec->internal->chromaSampling = supports400 ? RA_CHROMA_SAMPLING_CS400 : RA_CHROMA_SAMPLING_CS420; + codec->internal->yShift = 1; + break; + case AVIF_PIXEL_FORMAT_NONE: + default: + return AVIF_FALSE; + } } - } - rav1eConfig = rav1e_config_default(); - if (rav1e_config_set_pixel_format( - rav1eConfig, (uint8_t)image->depth, chromaSampling, RA_CHROMA_SAMPLE_POSITION_UNKNOWN, rav1eRange) < 0) { - goto cleanup; - } - - if (rav1e_config_parse(rav1eConfig, "still_picture", "true") == -1) { - goto cleanup; - } - if (rav1e_config_parse_int(rav1eConfig, "width", image->width) == -1) { - goto cleanup; - } - if (rav1e_config_parse_int(rav1eConfig, "height", image->height) == -1) { - goto cleanup; - } - if (rav1e_config_parse_int(rav1eConfig, "threads", encoder->maxThreads) == -1) { - goto cleanup; - } + rav1eConfig = rav1e_config_default(); + if (rav1e_config_set_pixel_format(rav1eConfig, + (uint8_t)image->depth, + codec->internal->chromaSampling, + (RaChromaSamplePosition)image->yuvChromaSamplePosition, + rav1eRange) < 0) { + goto cleanup; + } - int minQuantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63); - int maxQuantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63); - if (alpha) { - minQuantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63); - maxQuantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63); - } - minQuantizer = (minQuantizer * 255) / 63; // Rescale quantizer values as rav1e's QP range is [0,255] - maxQuantizer = (maxQuantizer * 255) / 63; - if (rav1e_config_parse_int(rav1eConfig, "min_quantizer", minQuantizer) == -1) { - goto cleanup; - } - if (rav1e_config_parse_int(rav1eConfig, "quantizer", maxQuantizer) == -1) { - goto cleanup; - } - if (encoder->tileRowsLog2 != 0) { - int tileRowsLog2 = AVIF_CLAMP(encoder->tileRowsLog2, 0, 6); - if (rav1e_config_parse_int(rav1eConfig, "tile_rows", 1 << tileRowsLog2) == -1) { + if (addImageFlags & AVIF_ADD_IMAGE_FLAG_SINGLE) { + if (rav1e_config_parse(rav1eConfig, "still_picture", "true") == -1) { + goto cleanup; + } + } + if (rav1e_config_parse_int(rav1eConfig, "width", image->width) == -1) { goto cleanup; } - } - if (encoder->tileColsLog2 != 0) { - int tileColsLog2 = AVIF_CLAMP(encoder->tileColsLog2, 0, 6); - if (rav1e_config_parse_int(rav1eConfig, "tile_cols", 1 << tileColsLog2) == -1) { + if (rav1e_config_parse_int(rav1eConfig, "height", image->height) == -1) { goto cleanup; } - } - if (encoder->speed != AVIF_SPEED_DEFAULT) { - int speed = AVIF_CLAMP(encoder->speed, 0, 10); - if (rav1e_config_parse_int(rav1eConfig, "speed", speed) == -1) { + if (rav1e_config_parse_int(rav1eConfig, "threads", encoder->maxThreads) == -1) { goto cleanup; } - } - rav1e_config_set_color_description(rav1eConfig, - (RaMatrixCoefficients)image->matrixCoefficients, - (RaColorPrimaries)image->colorPrimaries, - (RaTransferCharacteristics)image->transferCharacteristics); + int minQuantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63); + int maxQuantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63); + if (alpha) { + minQuantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63); + maxQuantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63); + } + minQuantizer = (minQuantizer * 255) / 63; // Rescale quantizer values as rav1e's QP range is [0,255] + maxQuantizer = (maxQuantizer * 255) / 63; + if (rav1e_config_parse_int(rav1eConfig, "min_quantizer", minQuantizer) == -1) { + goto cleanup; + } + if (rav1e_config_parse_int(rav1eConfig, "quantizer", maxQuantizer) == -1) { + goto cleanup; + } + if (encoder->tileRowsLog2 != 0) { + int tileRowsLog2 = AVIF_CLAMP(encoder->tileRowsLog2, 0, 6); + if (rav1e_config_parse_int(rav1eConfig, "tile_rows", 1 << tileRowsLog2) == -1) { + goto cleanup; + } + } + if (encoder->tileColsLog2 != 0) { + int tileColsLog2 = AVIF_CLAMP(encoder->tileColsLog2, 0, 6); + if (rav1e_config_parse_int(rav1eConfig, "tile_cols", 1 << tileColsLog2) == -1) { + goto cleanup; + } + } + if (encoder->speed != AVIF_SPEED_DEFAULT) { + int speed = AVIF_CLAMP(encoder->speed, 0, 10); + if (rav1e_config_parse_int(rav1eConfig, "speed", speed) == -1) { + goto cleanup; + } + } - rav1eContext = rav1e_context_new(rav1eConfig); - if (!rav1eContext) { - goto cleanup; + rav1e_config_set_color_description(rav1eConfig, + (RaMatrixCoefficients)image->matrixCoefficients, + (RaColorPrimaries)image->colorPrimaries, + (RaTransferCharacteristics)image->transferCharacteristics); + + codec->internal->rav1eContext = rav1e_context_new(rav1eConfig); + if (!codec->internal->rav1eContext) { + goto cleanup; + } } - rav1eFrame = rav1e_frame_new(rav1eContext); + + rav1eFrame = rav1e_frame_new(codec->internal->rav1eContext); int byteWidth = (image->depth > 8) ? 2 : 1; if (alpha) { rav1e_frame_fill_plane(rav1eFrame, 0, image->alphaPlane, image->alphaRowBytes * image->height, image->alphaRowBytes, byteWidth); } else { - uint32_t uvHeight = (image->height + yShift) >> yShift; rav1e_frame_fill_plane(rav1eFrame, 0, image->yuvPlanes[0], image->yuvRowBytes[0] * image->height, image->yuvRowBytes[0], byteWidth); - rav1e_frame_fill_plane(rav1eFrame, 1, image->yuvPlanes[1], image->yuvRowBytes[1] * uvHeight, image->yuvRowBytes[1], byteWidth); - rav1e_frame_fill_plane(rav1eFrame, 2, image->yuvPlanes[2], image->yuvRowBytes[2] * uvHeight, image->yuvRowBytes[2], byteWidth); + if (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV400) { + uint32_t uvHeight = (image->height + codec->internal->yShift) >> codec->internal->yShift; + rav1e_frame_fill_plane(rav1eFrame, 1, image->yuvPlanes[1], image->yuvRowBytes[1] * uvHeight, image->yuvRowBytes[1], byteWidth); + rav1e_frame_fill_plane(rav1eFrame, 2, image->yuvPlanes[2], image->yuvRowBytes[2] * uvHeight, image->yuvRowBytes[2], byteWidth); + } } - RaEncoderStatus encoderStatus = rav1e_send_frame(rav1eContext, rav1eFrame); - if (encoderStatus != 0) { - goto cleanup; - } - encoderStatus = rav1e_send_frame(rav1eContext, NULL); // flush - if (encoderStatus != 0) { - goto cleanup; + RaFrameTypeOverride frameType = RA_FRAME_TYPE_OVERRIDE_NO; + if (addImageFlags & AVIF_ADD_IMAGE_FLAG_FORCE_KEYFRAME) { + frameType = RA_FRAME_TYPE_OVERRIDE_KEY; } + rav1e_frame_set_type(rav1eFrame, frameType); - encoderStatus = rav1e_receive_packet(rav1eContext, &pkt); - if (encoderStatus != 0) { + RaEncoderStatus encoderStatus = rav1e_send_frame(codec->internal->rav1eContext, rav1eFrame); + if (encoderStatus != RA_ENCODER_STATUS_SUCCESS) { goto cleanup; } - if (pkt && pkt->data && (pkt->len > 0)) { - avifRWDataSet(obu, pkt->data, pkt->len); - success = AVIF_TRUE; + RaPacket * pkt = NULL; + for (;;) { + encoderStatus = rav1e_receive_packet(codec->internal->rav1eContext, &pkt); + if (encoderStatus == RA_ENCODER_STATUS_ENCODED) { + continue; + } + if ((encoderStatus != RA_ENCODER_STATUS_SUCCESS) && (encoderStatus != RA_ENCODER_STATUS_NEED_MORE_DATA)) { + goto cleanup; + } else if (pkt) { + if (pkt->data && (pkt->len > 0)) { + avifCodecEncodeOutputAddSample(output, pkt->data, pkt->len, (pkt->frame_type == RA_FRAME_TYPE_KEY)); + } + rav1e_packet_unref(pkt); + pkt = NULL; + } else { + break; + } } + success = AVIF_TRUE; cleanup: - if (pkt) { - rav1e_packet_unref(pkt); - pkt = NULL; - } if (rav1eFrame) { rav1e_frame_unref(rav1eFrame); rav1eFrame = NULL; } - if (rav1eContext) { - rav1e_context_unref(rav1eContext); - rav1eContext = NULL; - } if (rav1eConfig) { rav1e_config_unref(rav1eConfig); rav1eConfig = NULL; @@ -172,6 +222,43 @@ cleanup: return success; } +static avifBool rav1eCodecEncodeFinish(avifCodec * codec, avifCodecEncodeOutput * output) +{ + for (;;) { + RaEncoderStatus encoderStatus = rav1e_send_frame(codec->internal->rav1eContext, NULL); // flush + if (encoderStatus != RA_ENCODER_STATUS_SUCCESS) { + return AVIF_FALSE; + } + + avifBool gotPacket = AVIF_FALSE; + RaPacket * pkt = NULL; + for (;;) { + encoderStatus = rav1e_receive_packet(codec->internal->rav1eContext, &pkt); + if (encoderStatus == RA_ENCODER_STATUS_ENCODED) { + continue; + } + if ((encoderStatus != RA_ENCODER_STATUS_SUCCESS) && (encoderStatus != RA_ENCODER_STATUS_LIMIT_REACHED)) { + return AVIF_FALSE; + } + if (pkt) { + gotPacket = AVIF_TRUE; + if (pkt->data && (pkt->len > 0)) { + avifCodecEncodeOutputAddSample(output, pkt->data, pkt->len, (pkt->frame_type == RA_FRAME_TYPE_KEY)); + } + rav1e_packet_unref(pkt); + pkt = NULL; + } else { + break; + } + } + + if (!gotPacket) { + break; + } + } + return AVIF_TRUE; +} + const char * avifCodecVersionRav1e(void) { return rav1e_version_full(); @@ -183,6 +270,7 @@ avifCodec * avifCodecCreateRav1e(void) memset(codec, 0, sizeof(struct avifCodec)); codec->open = rav1eCodecOpen; codec->encodeImage = rav1eCodecEncodeImage; + codec->encodeFinish = rav1eCodecEncodeFinish; codec->destroyInternal = rav1eCodecDestroyInternal; codec->internal = (struct avifCodecInternal *)avifAlloc(sizeof(struct avifCodecInternal)); diff --git a/chromium/third_party/libavif/src/src/colr.c b/chromium/third_party/libavif/src/src/colr.c index 32862cde8ef..d09f485a691 100644 --- a/chromium/third_party/libavif/src/src/colr.c +++ b/chromium/third_party/libavif/src/src/colr.c @@ -52,7 +52,7 @@ static avifBool primariesMatch(const float p1[8], const float p2[8]) matchesTo3RoundedPlaces(p1[5], p2[5]) && matchesTo3RoundedPlaces(p1[6], p2[6]) && matchesTo3RoundedPlaces(p1[7], p2[7]); } -avifColorPrimaries avifColorPrimariesFind(float inPrimaries[8], const char ** outName) +avifColorPrimaries avifColorPrimariesFind(const float inPrimaries[8], const char ** outName) { if (outName) { *outName = NULL; @@ -94,7 +94,7 @@ static const struct avifMatrixCoefficientsTable matrixCoefficientsTables[] = { static const int avifMatrixCoefficientsTableSize = sizeof(matrixCoefficientsTables) / sizeof(matrixCoefficientsTables[0]); -static avifBool calcYUVInfoFromCICP(avifImage * image, float coeffs[3]) +static avifBool calcYUVInfoFromCICP(const avifImage * image, float coeffs[3]) { if (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL) { float primaries[8]; @@ -135,7 +135,7 @@ static avifBool calcYUVInfoFromCICP(avifImage * image, float coeffs[3]) return AVIF_FALSE; } -void avifCalcYUVCoefficients(avifImage * image, float * outR, float * outG, float * outB) +void avifCalcYUVCoefficients(const avifImage * image, float * outR, float * outG, float * outB) { // sRGB (BT.709) defaults, as explained here: // diff --git a/chromium/third_party/libavif/src/src/mem.c b/chromium/third_party/libavif/src/src/mem.c index 4ba8a8e5a75..5022d26c485 100644 --- a/chromium/third_party/libavif/src/src/mem.c +++ b/chromium/third_party/libavif/src/src/mem.c @@ -7,7 +7,11 @@ void * avifAlloc(size_t size) { - return malloc(size); + void * out = malloc(size); + if (out == NULL) { + abort(); + } + return out; } void avifFree(void * p) diff --git a/chromium/third_party/libavif/src/src/obu.c b/chromium/third_party/libavif/src/src/obu.c new file mode 100644 index 00000000000..d168f141aef --- /dev/null +++ b/chromium/third_party/libavif/src/src/obu.c @@ -0,0 +1,360 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +// OBU parsing and bit magic all originally from dav1d's obu.c and getbits.c, +// but heavily modified/reduced down to simply find the Sequence Header OBU +// and pull a few interesting pieces from it. +// +// Any other code in here is under this license: +// +// Copyright 2020 Joe Drago. All rights reserved. +// SPDX-License-Identifier: BSD-2-Clause + +#include "avif/internal.h" + +#include <string.h> + +// --------------------------------------------------------------------------- +// avifBits - Originally dav1d's GetBits struct (see dav1d's getbits.c) + +typedef struct avifBits +{ + int error, eof; + uint64_t state; + uint32_t bitsLeft; + const uint8_t *ptr, *start, *end; +} avifBits; + +static inline uint32_t avifBitsReadPos(const avifBits * bits) +{ + return (uint32_t)(bits->ptr - bits->start) * 8 - bits->bitsLeft; +} + +static void avifBitsInit(avifBits * const bits, const uint8_t * const data, const size_t size) +{ + bits->ptr = bits->start = data; + bits->end = &bits->start[size]; + bits->bitsLeft = 0; + bits->state = 0; + bits->error = 0; + bits->eof = 0; +} + +static void avifBitsRefill(avifBits * const bits, const uint32_t n) +{ + uint64_t state = 0; + do { + state <<= 8; + bits->bitsLeft += 8; + if (!bits->eof) + state |= *bits->ptr++; + if (bits->ptr >= bits->end) { + bits->error = bits->eof; + bits->eof = 1; + } + } while (n > bits->bitsLeft); + bits->state |= state << (64 - bits->bitsLeft); +} + +static uint32_t avifBitsRead(avifBits * const bits, const uint32_t n) +{ + if (n > bits->bitsLeft) + avifBitsRefill(bits, n); + + const uint64_t state = bits->state; + bits->bitsLeft -= n; + bits->state <<= n; + + return (uint32_t)(state >> (64 - n)); +} + +static uint32_t avifBitsReadUleb128(avifBits * bits) +{ + uint64_t val = 0; + uint32_t more; + uint32_t i = 0; + + do { + const uint32_t v = avifBitsRead(bits, 8); + more = v & 0x80; + val |= ((uint64_t)(v & 0x7F)) << i; + i += 7; + } while (more && i < 56); + + if (val > UINT32_MAX || more) { + bits->error = 1; + return 0; + } + + return (uint32_t)val; +} + +static uint32_t avifBitsReadVLC(avifBits * const bits) +{ + int numBits = 0; + while (!avifBitsRead(bits, 1)) + if (++numBits == 32) + return 0xFFFFFFFFU; + return numBits ? ((1U << numBits) - 1) + avifBitsRead(bits, numBits) : 0; +} + +// --------------------------------------------------------------------------- +// Variables in here use snake_case to self-document from the AV1 spec: +// +// https://aomediacodec.github.io/av1-spec/av1-spec.pdf + +// Originally dav1d's parse_seq_hdr() function (heavily modified) +static avifBool parseSequenceHeader(avifBits * bits, avifSequenceHeader * header) +{ + uint32_t seq_profile = avifBitsRead(bits, 3); + if (seq_profile > 2) { + return AVIF_FALSE; + } + + uint32_t still_picture = avifBitsRead(bits, 1); + uint32_t reduced_still_picture_header = avifBitsRead(bits, 1); + if (reduced_still_picture_header && !still_picture) { + return AVIF_FALSE; + } + + if (reduced_still_picture_header) { + avifBitsRead(bits, 5); // seq_level_idx + } else { + uint32_t timing_info_present_flag = avifBitsRead(bits, 1); + uint32_t decoder_model_info_present_flag = 0; + uint32_t buffer_delay_length = 0; + if (timing_info_present_flag) { // timing_info() + avifBitsRead(bits, 32); // num_units_in_display_tick + avifBitsRead(bits, 32); // time_scale + uint32_t equal_picture_interval = avifBitsRead(bits, 1); + if (equal_picture_interval) { + uint32_t num_ticks_per_picture_minus_1 = avifBitsReadVLC(bits); + if (num_ticks_per_picture_minus_1 == 0xFFFFFFFFU) + return AVIF_FALSE; + } + + decoder_model_info_present_flag = avifBitsRead(bits, 1); + if (decoder_model_info_present_flag) { // decoder_model_info() + buffer_delay_length = avifBitsRead(bits, 5) + 1; + avifBitsRead(bits, 32); // num_units_in_decoding_tick + avifBitsRead(bits, 10); // buffer_removal_time_length_minus_1, frame_presentation_time_length_minus_1 + } + } + + uint32_t initial_display_delay_present_flag = avifBitsRead(bits, 1); + uint32_t operating_points_cnt = avifBitsRead(bits, 5) + 1; + for (uint32_t i = 0; i < operating_points_cnt; i++) { + avifBitsRead(bits, 12); // operating_point_idc + uint32_t seq_level_idx = avifBitsRead(bits, 5); + if (seq_level_idx > 7) { + avifBitsRead(bits, 1); // seq_tier + } + if (decoder_model_info_present_flag) { + uint32_t decoder_model_present_for_this_op = avifBitsRead(bits, 1); + if (decoder_model_present_for_this_op) { // operating_parameters_info() + avifBitsRead(bits, buffer_delay_length); // decoder_buffer_delay + avifBitsRead(bits, buffer_delay_length); // encoder_buffer_delay + avifBitsRead(bits, 1); // low_delay_mode_flag + } + } + if (initial_display_delay_present_flag) { + uint32_t initial_display_delay_present_for_this_op = avifBitsRead(bits, 1); + if (initial_display_delay_present_for_this_op) { + avifBitsRead(bits, 4); // initial_display_delay_minus_1 + } + } + } + } + + uint32_t frame_width_bits = avifBitsRead(bits, 4) + 1; + uint32_t frame_height_bits = avifBitsRead(bits, 4) + 1; + header->maxWidth = avifBitsRead(bits, frame_width_bits) + 1; // max_frame_width + header->maxHeight = avifBitsRead(bits, frame_height_bits) + 1; // max_frame_height + uint32_t frame_id_numbers_present_flag = 0; + if (!reduced_still_picture_header) { + frame_id_numbers_present_flag = avifBitsRead(bits, 1); + } + if (frame_id_numbers_present_flag) { + avifBitsRead(bits, 7); // delta_frame_id_length_minus_2, additional_frame_id_length_minus_1 + } + + avifBitsRead(bits, 3); // use_128x128_superblock, enable_filter_intra, enable_intra_edge_filter + + if (!reduced_still_picture_header) { + avifBitsRead(bits, 4); // enable_interintra_compound, enable_masked_compound, enable_warped_motion, enable_dual_filter + uint32_t enable_order_hint = avifBitsRead(bits, 1); + if (enable_order_hint) { + avifBitsRead(bits, 2); // enable_jnt_comp, enable_ref_frame_mvs + } + + uint32_t seq_force_screen_content_tools = 0; + uint32_t seq_choose_screen_content_tools = avifBitsRead(bits, 1); + if (seq_choose_screen_content_tools) { + seq_force_screen_content_tools = 2; + } else { + seq_force_screen_content_tools = avifBitsRead(bits, 1); + } + if (seq_force_screen_content_tools > 0) { + uint32_t seq_choose_integer_mv = avifBitsRead(bits, 1); + if (!seq_choose_integer_mv) { + avifBitsRead(bits, 1); // seq_force_integer_mv + } + } + if (enable_order_hint) { + avifBitsRead(bits, 3); // order_hint_bits_minus_1 + } + } + + avifBitsRead(bits, 3); // enable_superres, enable_cdef, enable_restoration + + // color_config() + header->bitDepth = 8; + header->chromaSamplePosition = AVIF_CHROMA_SAMPLE_POSITION_UNKNOWN; + uint32_t high_bitdepth = avifBitsRead(bits, 1); + if ((seq_profile == 2) && high_bitdepth) { + uint32_t twelve_bit = avifBitsRead(bits, 1); + header->bitDepth = twelve_bit ? 12 : 10; + } else /* if (seq_profile <= 2) */ { + header->bitDepth = high_bitdepth ? 10 : 8; + } + uint32_t mono_chrome = 0; + if (seq_profile != 1) { + mono_chrome = avifBitsRead(bits, 1); + } + uint32_t color_description_present_flag = avifBitsRead(bits, 1); + if (color_description_present_flag) { + header->colorPrimaries = (avifColorPrimaries)avifBitsRead(bits, 8); // color_primaries + header->transferCharacteristics = (avifTransferCharacteristics)avifBitsRead(bits, 8); // transfer_characteristics + header->matrixCoefficients = (avifMatrixCoefficients)avifBitsRead(bits, 8); // matrix_coefficients + } else { + header->colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED; + header->transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED; + header->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED; + } + if (mono_chrome) { + header->range = avifBitsRead(bits, 1) ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; // color_range + // subsampling_x = 1; + // subsampling_y = 1; + header->yuvFormat = AVIF_PIXEL_FORMAT_YUV400; + } else if (header->colorPrimaries == AVIF_COLOR_PRIMARIES_BT709 && + header->transferCharacteristics == AVIF_TRANSFER_CHARACTERISTICS_SRGB && + header->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY) { + header->range = AVIF_RANGE_FULL; + // subsampling_x = 0; + // subsampling_y = 0; + header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; + } else { + uint32_t subsampling_x = 0; + uint32_t subsampling_y = 0; + header->range = avifBitsRead(bits, 1) ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; // color_range + switch (seq_profile) { + case 0: + subsampling_x = 1; + subsampling_y = 1; + header->yuvFormat = AVIF_PIXEL_FORMAT_YUV420; + break; + case 1: + subsampling_x = 0; + subsampling_y = 0; + header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; + break; + case 2: + if (header->bitDepth == 12) { + subsampling_x = avifBitsRead(bits, 1); + if (subsampling_x) { + subsampling_y = avifBitsRead(bits, 1); + } + } else { + subsampling_x = 1; + subsampling_y = 0; + } + if (subsampling_x) { + header->yuvFormat = subsampling_y ? AVIF_PIXEL_FORMAT_YUV420 : AVIF_PIXEL_FORMAT_YUV422; + } else { + header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; + } + break; + } + + if (subsampling_x && subsampling_y) { + header->chromaSamplePosition = (avifChromaSamplePosition)avifBitsRead(bits, 2); // chroma_sample_position + } + } + + if (!mono_chrome) { + avifBitsRead(bits, 1); // separate_uv_delta_q + } + avifBitsRead(bits, 1); // film_grain_params_present + + return !bits->error; +} + +avifBool avifSequenceHeaderParse(avifSequenceHeader * header, const avifROData * sample) +{ + avifROData obus = *sample; + + // Find the sequence header OBU + while (obus.size > 0) { + avifBits bits; + avifBitsInit(&bits, obus.data, obus.size); + + // obu_header() + avifBitsRead(&bits, 1); // obu_forbidden_bit + const uint32_t obu_type = avifBitsRead(&bits, 4); + const uint32_t obu_extension_flag = avifBitsRead(&bits, 1); + const uint32_t obu_has_size_field = avifBitsRead(&bits, 1); + avifBitsRead(&bits, 1); // obu_reserved_1bit + + if (obu_extension_flag) { // obu_extension_header() + avifBitsRead(&bits, 8); // temporal_id, spatial_id, extension_header_reserved_3bits + } + + uint32_t obu_size = 0; + if (obu_has_size_field) + obu_size = avifBitsReadUleb128(&bits); + else + obu_size = (int)obus.size - 1 - obu_extension_flag; + + if (bits.error) { + return AVIF_FALSE; + } + + const uint32_t init_bit_pos = avifBitsReadPos(&bits); + const uint32_t init_byte_pos = init_bit_pos >> 3; + if (obu_size > obus.size - init_byte_pos) + return AVIF_FALSE; + + if (obu_type == 1) { // Sequence Header + return parseSequenceHeader(&bits, header); + } + + // Skip this OBU + obus.data += obu_size + init_byte_pos; + obus.size -= obu_size + init_byte_pos; + } + return AVIF_FALSE; +} diff --git a/chromium/third_party/libavif/src/src/read.c b/chromium/third_party/libavif/src/src/read.c index 51daf439a94..bb0d39f4c84 100644 --- a/chromium/third_party/libavif/src/src/read.c +++ b/chromium/third_party/libavif/src/src/read.c @@ -7,7 +7,6 @@ #define AUXTYPE_SIZE 64 #define CONTENTTYPE_SIZE 64 -#define MAX_COMPATIBLE_BRANDS 32 // class VisualSampleEntry(codingname) extends SampleEntry(codingname) { // unsigned int(16) pre_defined = 0; @@ -39,7 +38,8 @@ typedef struct avifFileType { uint8_t majorBrand[4]; uint32_t minorVersion; - uint8_t compatibleBrands[4 * MAX_COMPATIBLE_BRANDS]; + // If not null, points to a memory block of 4 * compatibleBrandsCount bytes. + const uint8_t * compatibleBrands; int compatibleBrandsCount; } avifFileType; @@ -86,57 +86,57 @@ typedef struct avifPixelInformationProperty // --------------------------------------------------------------------------- // Top-level structures +struct avifMeta; + +// Temporary storage for ipco/stsd contents until they can be associated and memcpy'd to an avifDecoderItem +typedef struct avifProperty +{ + uint8_t type[4]; + union + { + avifImageSpatialExtents ispe; + avifAuxiliaryType auxC; + avifColourInformationBox colr; + avifCodecConfigurationBox av1C; + avifPixelAspectRatioBox pasp; + avifCleanApertureBox clap; + avifImageRotation irot; + avifImageMirror imir; + avifPixelInformationProperty pixi; + } u; +} avifProperty; +AVIF_ARRAY_DECLARE(avifPropertyArray, avifProperty, prop); + +static const avifProperty * avifPropertyArrayFind(const avifPropertyArray * properties, const char * type) +{ + for (uint32_t propertyIndex = 0; propertyIndex < properties->count; ++propertyIndex) { + avifProperty * prop = &properties->prop[propertyIndex]; + if (!memcmp(prop->type, type, 4)) { + return prop; + } + } + return NULL; +} + // one "item" worth for decoding (all iref, iloc, iprp, etc refer to one of these) typedef struct avifDecoderItem { uint32_t id; + struct avifMeta * meta; // Unowned; A back-pointer for convenience uint8_t type[4]; uint32_t offset; uint32_t size; uint32_t idatID; // If non-zero, offset is relative to this idat box (iloc construction_method==1) - avifBool ispePresent; - avifImageSpatialExtents ispe; - avifBool auxCPresent; - avifAuxiliaryType auxC; avifContentType contentType; - avifBool colrPresent; - avifColourInformationBox colr; - avifBool av1CPresent; - avifCodecConfigurationBox av1C; - avifBool paspPresent; - avifPixelAspectRatioBox pasp; - avifBool clapPresent; - avifCleanApertureBox clap; - avifBool irotPresent; - avifImageRotation irot; - avifBool imirPresent; - avifImageMirror imir; - avifBool pixiPresent; - avifPixelInformationProperty pixi; + avifPropertyArray properties; uint32_t thumbnailForID; // if non-zero, this item is a thumbnail for Item #{thumbnailForID} uint32_t auxForID; // if non-zero, this item is an auxC plane for Item #{auxForID} uint32_t descForID; // if non-zero, this item is a content description for Item #{descForID} uint32_t dimgForID; // if non-zero, this item is a derived image for Item #{dimgForID} - avifBool hasUnsupportedEssentialProperty; // If true, this file cites a property flagged as 'essential' that libavif doesn't support (yet). Ignore the item, if so. + avifBool hasUnsupportedEssentialProperty; // If true, this item cites a property flagged as 'essential' that libavif doesn't support (yet). Ignore the item, if so. } avifDecoderItem; AVIF_ARRAY_DECLARE(avifDecoderItemArray, avifDecoderItem, item); -// Temporary storage for ipco contents until they can be associated and memcpy'd to an avifDecoderItem -typedef struct avifProperty -{ - uint8_t type[4]; - avifImageSpatialExtents ispe; - avifAuxiliaryType auxC; - avifColourInformationBox colr; - avifCodecConfigurationBox av1C; - avifPixelAspectRatioBox pasp; - avifCleanApertureBox clap; - avifImageRotation irot; - avifImageMirror imir; - avifPixelInformationProperty pixi; -} avifProperty; -AVIF_ARRAY_DECLARE(avifPropertyArray, avifProperty, prop); - // idat storage typedef struct avifDecoderItemData { @@ -193,8 +193,7 @@ AVIF_ARRAY_DECLARE(avifSyncSampleArray, avifSyncSample, syncSample); typedef struct avifSampleDescription { uint8_t format[4]; - avifBool av1CPresent; - avifCodecConfigurationBox av1C; + avifPropertyArray properties; } avifSampleDescription; AVIF_ARRAY_DECLARE(avifSampleDescriptionArray, avifSampleDescription, description); @@ -225,6 +224,10 @@ static avifSampleTable * avifSampleTableCreate() static void avifSampleTableDestroy(avifSampleTable * sampleTable) { avifArrayDestroy(&sampleTable->chunks); + for (uint32_t i = 0; i < sampleTable->sampleDescriptions.count; ++i) { + avifSampleDescription * description = &sampleTable->sampleDescriptions.description[i]; + avifArrayDestroy(&description->properties); + } avifArrayDestroy(&sampleTable->sampleDescriptions); avifArrayDestroy(&sampleTable->sampleToChunks); avifArrayDestroy(&sampleTable->sampleSizes); @@ -268,15 +271,15 @@ static uint32_t avifCodecConfigurationBoxGetDepth(const avifCodecConfigurationBo return 8; } -static uint32_t avifSampleTableGetDepth(const avifSampleTable * sampleTable) +static const avifPropertyArray * avifSampleTableGetProperties(const avifSampleTable * sampleTable) { for (uint32_t i = 0; i < sampleTable->sampleDescriptions.count; ++i) { const avifSampleDescription * description = &sampleTable->sampleDescriptions.description[i]; - if (!memcmp(description->format, "av01", 4) && description->av1CPresent) { - return avifCodecConfigurationBoxGetDepth(&description->av1C); + if (!memcmp(description->format, "av01", 4)) { + return &description->properties; } } - return 0; + return NULL; } // one video track ("trak" contents) @@ -289,6 +292,7 @@ typedef struct avifTrack uint32_t width; uint32_t height; avifSampleTable * sampleTable; + struct avifMeta * meta; } avifTrack; AVIF_ARRAY_DECLARE(avifTrackArray, avifTrack, track); @@ -299,7 +303,7 @@ avifCodecDecodeInput * avifCodecDecodeInputCreate(void) { avifCodecDecodeInput * decodeInput = (avifCodecDecodeInput *)avifAlloc(sizeof(avifCodecDecodeInput)); memset(decodeInput, 0, sizeof(avifCodecDecodeInput)); - avifArrayCreate(&decodeInput->samples, sizeof(avifSample), 1); + avifArrayCreate(&decodeInput->samples, sizeof(avifDecodeSample), 1); return decodeInput; } @@ -341,7 +345,7 @@ static avifBool avifCodecDecodeInputGetSamples(avifCodecDecodeInput * decodeInpu sampleSize = sampleSizePtr->size; } - avifSample * sample = (avifSample *)avifArrayPushPtr(&decodeInput->samples); + avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&decodeInput->samples); sample->data.data = rawInput->data + sampleOffset; sample->data.size = sampleSize; sample->sync = AVIF_FALSE; // to potentially be set to true following the outer loop @@ -371,6 +375,16 @@ static avifBool avifCodecDecodeInputGetSamples(avifCodecDecodeInput * decodeInpu } // --------------------------------------------------------------------------- +// Helper macros + +#define BEGIN_STREAM(VARNAME, PTR, SIZE) \ + avifROStream VARNAME; \ + avifROData VARNAME##_roData; \ + VARNAME##_roData.data = PTR; \ + VARNAME##_roData.size = SIZE; \ + avifROStreamStart(&VARNAME, &VARNAME##_roData) + +// --------------------------------------------------------------------------- // avifDecoderData typedef struct avifTile @@ -381,12 +395,94 @@ typedef struct avifTile } avifTile; AVIF_ARRAY_DECLARE(avifTileArray, avifTile, tile); -typedef struct avifDecoderData -{ - avifFileType ftyp; +// This holds one "meta" box (from the BMFF and HEIF standards) worth of relevant-to-AVIF information. +// * If a meta box is parsed from the root level of the BMFF, it can contain the information about +// "items" which might be color planes, alpha planes, or EXIF or XMP metadata. +// * If a meta box is parsed from inside of a track ("trak") box, any metadata (EXIF/XMP) items inside +// of that box are implicitly associated with that track. +typedef struct avifMeta +{ + // Items (from HEIF) are the generic storage for any data that does not require timed processing + // (single image color planes, alpha planes, EXIF, XMP, etc). Each item has a unique integer ID >1, + // and is defined by a series of child boxes in a meta box: + // * iloc - location: byte offset to item data, item size in bytes + // * iinf - information: type of item (color planes, alpha plane, EXIF, XMP) + // * ipco - properties: dimensions, aspect ratio, image transformations, references to other items + // * ipma - associations: Attaches an item in the properties list to a given item + // + // Items are lazily created in this array when any of the above boxes refer to one by a new (unseen) ID, + // and are then further modified/updated as new information for an item's ID is parsed. avifDecoderItemArray items; + + // Any ipco boxes explained above are populated into this array as a staging area, which are + // then duplicated into the appropriate items upon encountering an item property association + // (ipma) box. avifPropertyArray properties; + + // Filled with the contents of "idat" boxes, which are raw data that an item can directly refer to in its + // item location box (iloc) instead of just giving an offset into the overall file. If all items' iloc boxes + // simply point at an offset/length in the file itself, this array will likely be empty. avifDecoderItemDataArray idats; + + // Ever-incrementing ID for uniquely identifying which 'meta' box contains an idat (when + // multiple meta boxes exist as BMFF siblings). Each time avifParseMetaBox() is called on an + // avifMeta struct, this value is incremented. Any time an additional meta box is detected at + // the same "level" (root level, trak level, etc), this ID helps distinguish which meta box's + // "idat" is which, as items implicitly reference idat boxes that exist in the same meta + // box. + uint32_t idatID; + + // Contents of a pitm box, which signal which of the items in this file is the main image. For + // AVIF, this should point at an av01 type item containing color planes, and all other items + // are ignored unless they refer to this item in some way (alpha plane, EXIF/XMP metadata). + uint32_t primaryItemID; +} avifMeta; + +static avifMeta * avifMetaCreate() +{ + avifMeta * meta = (avifMeta *)avifAlloc(sizeof(avifMeta)); + memset(meta, 0, sizeof(avifMeta)); + avifArrayCreate(&meta->items, sizeof(avifDecoderItem), 8); + avifArrayCreate(&meta->properties, sizeof(avifProperty), 16); + avifArrayCreate(&meta->idats, sizeof(avifDecoderItemData), 1); + return meta; +} + +static void avifMetaDestroy(avifMeta * meta) +{ + for (uint32_t i = 0; i < meta->items.count; ++i) { + avifDecoderItem * item = &meta->items.item[i]; + avifArrayDestroy(&item->properties); + } + avifArrayDestroy(&meta->items); + avifArrayDestroy(&meta->properties); + avifArrayDestroy(&meta->idats); + avifFree(meta); +} + +static avifDecoderItem * avifMetaFindItem(avifMeta * meta, uint32_t itemID) +{ + if (itemID == 0) { + return NULL; + } + + for (uint32_t i = 0; i < meta->items.count; ++i) { + if (meta->items.item[i].id == itemID) { + return &meta->items.item[i]; + } + } + + avifDecoderItem * item = (avifDecoderItem *)avifArrayPushPtr(&meta->items); + avifArrayCreate(&item->properties, sizeof(avifProperty), 16); + item->id = itemID; + item->meta = meta; + return item; +} + +typedef struct avifDecoderData +{ + avifFileType ftyp; + avifMeta * meta; // The root-level meta box avifTrackArray tracks; avifROData rawInput; avifTileArray tiles; @@ -396,23 +492,19 @@ typedef struct avifDecoderData avifImageGrid alphaGrid; avifDecoderSource source; const avifSampleTable * sourceSampleTable; // NULL unless (source == AVIF_DECODER_SOURCE_TRACKS), owned by an avifTrack - uint32_t primaryItemID; - uint32_t metaBoxID; // Ever-incrementing ID for uniquely identifying which 'meta' box contains an idat - avifBool cicpSet; // True if avifDecoder's image has had its CICP set correctly yet. - // This allows nclx colr boxes to override AV1 CICP, as specified in the MIAF - // standard (ISO/IEC 23000-22:2019), section 7.3.6.4: - // - // "The colour information property takes precedence over any colour information in the image - // bitstream, i.e. if the property is present, colour information in the bitstream shall be ignored." + avifBool cicpSet; // True if avifDecoder's image has had its CICP set correctly yet. + // This allows nclx colr boxes to override AV1 CICP, as specified in the MIAF + // standard (ISO/IEC 23000-22:2019), section 7.3.6.4: + // + // "The colour information property takes precedence over any colour information in the image + // bitstream, i.e. if the property is present, colour information in the bitstream shall be ignored." } avifDecoderData; static avifDecoderData * avifDecoderDataCreate() { avifDecoderData * data = (avifDecoderData *)avifAlloc(sizeof(avifDecoderData)); memset(data, 0, sizeof(avifDecoderData)); - avifArrayCreate(&data->items, sizeof(avifDecoderItem), 8); - avifArrayCreate(&data->properties, sizeof(avifProperty), 16); - avifArrayCreate(&data->idats, sizeof(avifDecoderItemData), 1); + data->meta = avifMetaCreate(); avifArrayCreate(&data->tracks, sizeof(avifTrack), 2); avifArrayCreate(&data->tiles, sizeof(avifTile), 8); return data; @@ -440,6 +532,13 @@ static avifTile * avifDecoderDataCreateTile(avifDecoderData * data) return tile; } +static avifTrack * avifDecoderDataCreateTrack(avifDecoderData * data) +{ + avifTrack * track = (avifTrack *)avifArrayPushPtr(&data->tracks); + track->meta = avifMetaCreate(); + return track; +} + static void avifDecoderDataClearTiles(avifDecoderData * data) { for (unsigned int i = 0; i < data->tiles.count; ++i) { @@ -464,12 +563,14 @@ static void avifDecoderDataClearTiles(avifDecoderData * data) static void avifDecoderDataDestroy(avifDecoderData * data) { - avifArrayDestroy(&data->items); - avifArrayDestroy(&data->properties); - avifArrayDestroy(&data->idats); + avifMetaDestroy(data->meta); for (uint32_t i = 0; i < data->tracks.count; ++i) { - if (data->tracks.track[i].sampleTable) { - avifSampleTableDestroy(data->tracks.track[i].sampleTable); + avifTrack * track = &data->tracks.track[i]; + if (track->sampleTable) { + avifSampleTableDestroy(track->sampleTable); + } + if (track->meta) { + avifMetaDestroy(track->meta); } } avifArrayDestroy(&data->tracks); @@ -478,23 +579,6 @@ static void avifDecoderDataDestroy(avifDecoderData * data) avifFree(data); } -static avifDecoderItem * avifDecoderDataFindItem(avifDecoderData * data, uint32_t itemID) -{ - if (itemID == 0) { - return NULL; - } - - for (uint32_t i = 0; i < data->items.count; ++i) { - if (data->items.item[i].id == itemID) { - return &data->items.item[i]; - } - } - - avifDecoderItem * item = (avifDecoderItem *)avifArrayPushPtr(&data->items); - item->id = itemID; - return item; -} - static const uint8_t * avifDecoderDataCalcItemPtr(avifDecoderData * data, avifDecoderItem * item) { avifROData * offsetBuffer = NULL; @@ -506,9 +590,9 @@ static const uint8_t * avifDecoderDataCalcItemPtr(avifDecoderData * data, avifDe // construction_method: idat(1) // Find associated idat block - for (uint32_t i = 0; i < data->idats.count; ++i) { - if (data->idats.idat[i].id == item->idatID) { - offsetBuffer = &data->idats.idat[i].data; + for (uint32_t i = 0; i < item->meta->idats.count; ++i) { + if (item->meta->idats.idat[i].id == item->idatID) { + offsetBuffer = &item->meta->idats.idat[i].data; break; } } @@ -535,15 +619,16 @@ static avifBool avifDecoderDataGenerateImageGridTiles(avifDecoderData * data, av // Count number of dimg for this item, bail out if it doesn't match perfectly unsigned int tilesAvailable = 0; - for (uint32_t i = 0; i < data->items.count; ++i) { - avifDecoderItem * item = &data->items.item[i]; + for (uint32_t i = 0; i < gridItem->meta->items.count; ++i) { + avifDecoderItem * item = &gridItem->meta->items.item[i]; if (item->dimgForID == gridItem->id) { if (memcmp(item->type, "av01", 4)) { continue; } if (item->hasUnsupportedEssentialProperty) { - // An essential property isn't supported by libavif; ignore the item. - continue; + // An essential property isn't supported by libavif; can't + // decode a grid image if any tile in the grid isn't supported. + return AVIF_FALSE; } ++tilesAvailable; @@ -554,23 +639,33 @@ static avifBool avifDecoderDataGenerateImageGridTiles(avifDecoderData * data, av return AVIF_FALSE; } - for (uint32_t i = 0; i < data->items.count; ++i) { - avifDecoderItem * item = &data->items.item[i]; + avifBool firstTile = AVIF_TRUE; + for (uint32_t i = 0; i < gridItem->meta->items.count; ++i) { + avifDecoderItem * item = &gridItem->meta->items.item[i]; if (item->dimgForID == gridItem->id) { if (memcmp(item->type, "av01", 4)) { continue; } - if (item->hasUnsupportedEssentialProperty) { - // An essential property isn't supported by libavif; ignore the item. - continue; - } avifTile * tile = avifDecoderDataCreateTile(data); - avifSample * sample = (avifSample *)avifArrayPushPtr(&tile->input->samples); + avifDecodeSample * sample = (avifDecodeSample *)avifArrayPushPtr(&tile->input->samples); sample->data.data = avifDecoderDataCalcItemPtr(data, item); sample->data.size = item->size; sample->sync = AVIF_TRUE; tile->input->alpha = alpha; + + if (firstTile) { + firstTile = AVIF_FALSE; + + // Adopt the av1C property of the first av01 tile, so that it can be queried from + // the top-level color/alpha item during avifDecoderReset(). + const avifProperty * srcProp = avifPropertyArrayFind(&item->properties, "av1C"); + if (!srcProp) { + return AVIF_FALSE; + } + avifProperty * dstProp = (avifProperty *)avifArrayPushPtr(&gridItem->properties); + memcpy(dstProp, srcProp, sizeof(avifProperty)); + } } } return AVIF_TRUE; @@ -626,6 +721,9 @@ static avifBool avifDecoderDataFillImageGrid(avifDecoderData * data, dstImage->matrixCoefficients = firstTile->image->matrixCoefficients; } } + if (alpha) { + dstImage->alphaRange = firstTile->image->alphaRange; + } avifImageAllocatePlanes(dstImage, alpha ? AVIF_PLANES_A : AVIF_PLANES_YUV); @@ -652,7 +750,13 @@ static avifBool avifDecoderDataFillImageGrid(avifDecoderData * data, // Y and A channels size_t yaColOffset = colIndex * firstTile->image->width; + if (yaColOffset >= grid->outputWidth) { + return AVIF_FALSE; + } size_t yaRowOffset = rowIndex * firstTile->image->height; + if (yaRowOffset >= grid->outputHeight) { + return AVIF_FALSE; + } size_t yaRowBytes = widthToCopy * pixelBytes; if (alpha) { @@ -698,10 +802,57 @@ static avifBool avifDecoderDataFillImageGrid(avifDecoderData * data, return AVIF_TRUE; } +// If colorId == 0 (a sentinel value as item IDs must be nonzero), accept any found EXIF/XMP metadata. Passing in 0 +// is used when finding metadata in a meta box embedded in a trak box, as any items inside of a meta box that is +// inside of a trak box are implicitly associated to the track. +static avifBool avifDecoderDataFindMetadata(avifDecoderData * data, avifMeta * meta, avifImage * image, uint32_t colorId) +{ + avifROData exifData = AVIF_DATA_EMPTY; + avifROData xmpData = AVIF_DATA_EMPTY; + + for (uint32_t itemIndex = 0; itemIndex < meta->items.count; ++itemIndex) { + avifDecoderItem * item = &meta->items.item[itemIndex]; + if (!item->size) { + continue; + } + if (item->hasUnsupportedEssentialProperty) { + // An essential property isn't supported by libavif; ignore the item. + continue; + } + + if ((colorId > 0) && (item->descForID != colorId)) { + // Not a content description (metadata) for the colorOBU, skip it + continue; + } + + if (!memcmp(item->type, "Exif", 4)) { + // Advance past Annex A.2.1's header + const uint8_t * boxPtr = avifDecoderDataCalcItemPtr(data, item); + BEGIN_STREAM(exifBoxStream, boxPtr, item->size); + uint32_t exifTiffHeaderOffset; + CHECK(avifROStreamReadU32(&exifBoxStream, &exifTiffHeaderOffset)); // unsigned int(32) exif_tiff_header_offset; + + exifData.data = avifROStreamCurrent(&exifBoxStream); + exifData.size = avifROStreamRemainingBytes(&exifBoxStream); + } else if (!memcmp(item->type, "mime", 4) && !memcmp(item->contentType.contentType, xmpContentType, xmpContentTypeSize)) { + xmpData.data = avifDecoderDataCalcItemPtr(data, item); + xmpData.size = item->size; + } + } + + if (exifData.data && exifData.size) { + avifImageSetMetadataExif(image, exifData.data, exifData.size); + } + if (xmpData.data && xmpData.size) { + avifImageSetMetadataXMP(image, xmpData.data, xmpData.size); + } + return AVIF_TRUE; +} + // --------------------------------------------------------------------------- // URN -static avifBool isAlphaURN(char * urn) +static avifBool isAlphaURN(const char * urn) { return !strcmp(urn, URN_ALPHA0) || !strcmp(urn, URN_ALPHA1); } @@ -709,20 +860,12 @@ static avifBool isAlphaURN(char * urn) // --------------------------------------------------------------------------- // BMFF Parsing -#define BEGIN_STREAM(VARNAME, PTR, SIZE) \ - avifROStream VARNAME; \ - avifROData VARNAME##_roData; \ - VARNAME##_roData.data = PTR; \ - VARNAME##_roData.size = SIZE; \ - avifROStreamStart(&VARNAME, &VARNAME##_roData) - -static avifBool avifParseItemLocationBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemLocationBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); uint8_t version; - uint8_t flags[3]; - CHECK(avifROStreamReadVersionAndFlags(&s, &version, flags)); + CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); if (version > 2) { return AVIF_FALSE; } @@ -773,7 +916,7 @@ static avifBool avifParseItemLocationBox(avifDecoderData * data, const uint8_t * return AVIF_FALSE; } if (constructionMethod == 1) { - idatID = data->metaBoxID; + idatID = meta->idatID; } } @@ -794,7 +937,7 @@ static avifBool avifParseItemLocationBox(avifDecoderData * data, const uint8_t * uint64_t extentLength; // unsigned int(offset_size*8) extent_length; CHECK(avifROStreamReadUX8(&s, &extentLength, lengthSize)); - avifDecoderItem * item = avifDecoderDataFindItem(data, itemID); + avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { return AVIF_FALSE; } @@ -840,58 +983,63 @@ static avifBool avifParseImageGridBox(avifImageGrid * grid, const uint8_t * raw, CHECK(avifROStreamReadU32(&s, &grid->outputWidth)); // unsigned int(FieldLength) output_width; CHECK(avifROStreamReadU32(&s, &grid->outputHeight)); // unsigned int(FieldLength) output_height; } + if (grid->outputWidth > AVIF_MAX_IMAGE_SIZE / grid->outputHeight) { + return AVIF_FALSE; + } return AVIF_TRUE; } -static avifBool avifParseImageSpatialExtentsProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseImageSpatialExtentsProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); - CHECK(avifROStreamReadU32(&s, &data->properties.prop[propertyIndex].ispe.width)); - CHECK(avifROStreamReadU32(&s, &data->properties.prop[propertyIndex].ispe.height)); + avifImageSpatialExtents * ispe = &prop->u.ispe; + CHECK(avifROStreamReadU32(&s, &ispe->width)); + CHECK(avifROStreamReadU32(&s, &ispe->height)); return AVIF_TRUE; } -static avifBool avifParseAuxiliaryTypeProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseAuxiliaryTypeProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); - CHECK(avifROStreamReadString(&s, data->properties.prop[propertyIndex].auxC.auxType, AUXTYPE_SIZE)); + CHECK(avifROStreamReadString(&s, prop->u.auxC.auxType, AUXTYPE_SIZE)); return AVIF_TRUE; } -static avifBool avifParseColourInformationBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseColourInformationBox(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - data->properties.prop[propertyIndex].colr.hasICC = AVIF_FALSE; - data->properties.prop[propertyIndex].colr.hasNCLX = AVIF_FALSE; + avifColourInformationBox * colr = &prop->u.colr; + colr->hasICC = AVIF_FALSE; + colr->hasNCLX = AVIF_FALSE; uint8_t colorType[4]; // unsigned int(32) colour_type; CHECK(avifROStreamRead(&s, colorType, 4)); if (!memcmp(colorType, "rICC", 4) || !memcmp(colorType, "prof", 4)) { - data->properties.prop[propertyIndex].colr.hasICC = AVIF_TRUE; - data->properties.prop[propertyIndex].colr.icc = avifROStreamCurrent(&s); - data->properties.prop[propertyIndex].colr.iccSize = avifROStreamRemainingBytes(&s); + colr->hasICC = AVIF_TRUE; + colr->icc = avifROStreamCurrent(&s); + colr->iccSize = avifROStreamRemainingBytes(&s); } else if (!memcmp(colorType, "nclx", 4)) { uint16_t tmp16; // unsigned int(16) colour_primaries; CHECK(avifROStreamReadU16(&s, &tmp16)); - data->properties.prop[propertyIndex].colr.colorPrimaries = (avifColorPrimaries)tmp16; + colr->colorPrimaries = (avifColorPrimaries)tmp16; // unsigned int(16) transfer_characteristics; CHECK(avifROStreamReadU16(&s, &tmp16)); - data->properties.prop[propertyIndex].colr.transferCharacteristics = (avifTransferCharacteristics)tmp16; + colr->transferCharacteristics = (avifTransferCharacteristics)tmp16; // unsigned int(16) matrix_coefficients; CHECK(avifROStreamReadU16(&s, &tmp16)); - data->properties.prop[propertyIndex].colr.matrixCoefficients = (avifMatrixCoefficients)tmp16; + colr->matrixCoefficients = (avifMatrixCoefficients)tmp16; // unsigned int(1) full_range_flag; // unsigned int(7) reserved = 0; uint8_t tmp8; CHECK(avifROStreamRead(&s, &tmp8, 1)); - data->properties.prop[propertyIndex].colr.range = (avifRange)(tmp8 & 0x80); - data->properties.prop[propertyIndex].colr.hasNCLX = AVIF_TRUE; + colr->range = (tmp8 & 0x80) ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; + colr->hasNCLX = AVIF_TRUE; } return AVIF_TRUE; } @@ -924,26 +1072,26 @@ static avifBool avifParseAV1CodecConfigurationBox(const uint8_t * raw, size_t ra return AVIF_TRUE; } -static avifBool avifParseAV1CodecConfigurationBoxProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseAV1CodecConfigurationBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { - return avifParseAV1CodecConfigurationBox(raw, rawLen, &data->properties.prop[propertyIndex].av1C); + return avifParseAV1CodecConfigurationBox(raw, rawLen, &prop->u.av1C); } -static avifBool avifParsePixelAspectRatioBoxProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParsePixelAspectRatioBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - avifPixelAspectRatioBox * pasp = &data->properties.prop[propertyIndex].pasp; + avifPixelAspectRatioBox * pasp = &prop->u.pasp; CHECK(avifROStreamReadU32(&s, &pasp->hSpacing)); // unsigned int(32) hSpacing; CHECK(avifROStreamReadU32(&s, &pasp->vSpacing)); // unsigned int(32) vSpacing; return AVIF_TRUE; } -static avifBool avifParseCleanApertureBoxProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseCleanApertureBoxProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - avifCleanApertureBox * clap = &data->properties.prop[propertyIndex].clap; + avifCleanApertureBox * clap = &prop->u.clap; CHECK(avifROStreamReadU32(&s, &clap->widthN)); // unsigned int(32) cleanApertureWidthN; CHECK(avifROStreamReadU32(&s, &clap->widthD)); // unsigned int(32) cleanApertureWidthD; CHECK(avifROStreamReadU32(&s, &clap->heightN)); // unsigned int(32) cleanApertureHeightN; @@ -955,11 +1103,11 @@ static avifBool avifParseCleanApertureBoxProperty(avifDecoderData * data, const return AVIF_TRUE; } -static avifBool avifParseImageRotationProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseImageRotationProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - avifImageRotation * irot = &data->properties.prop[propertyIndex].irot; + avifImageRotation * irot = &prop->u.irot; CHECK(avifROStreamRead(&s, &irot->angle, 1)); // unsigned int (6) reserved = 0; unsigned int (2) angle; if ((irot->angle & 0xfc) != 0) { // reserved bits must be 0 @@ -968,11 +1116,11 @@ static avifBool avifParseImageRotationProperty(avifDecoderData * data, const uin return AVIF_TRUE; } -static avifBool avifParseImageMirrorProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParseImageMirrorProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - avifImageMirror * imir = &data->properties.prop[propertyIndex].imir; + avifImageMirror * imir = &prop->u.imir; CHECK(avifROStreamRead(&s, &imir->axis, 1)); // unsigned int (7) reserved = 0; unsigned int (1) axis; if ((imir->axis & 0xfe) != 0) { // reserved bits must be 0 @@ -981,12 +1129,12 @@ static avifBool avifParseImageMirrorProperty(avifDecoderData * data, const uint8 return AVIF_TRUE; } -static avifBool avifParsePixelInformationProperty(avifDecoderData * data, const uint8_t * raw, size_t rawLen, int propertyIndex) +static avifBool avifParsePixelInformationProperty(avifProperty * prop, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); - avifPixelInformationProperty * pixi = &data->properties.prop[propertyIndex].pixi; + avifPixelInformationProperty * pixi = &prop->u.pixi; CHECK(avifROStreamRead(&s, &pixi->planeCount, 1)); // unsigned int (8) num_channels; if (pixi->planeCount > MAX_PIXI_PLANE_DEPTHS) { return AVIF_FALSE; @@ -997,7 +1145,7 @@ static avifBool avifParsePixelInformationProperty(avifDecoderData * data, const return AVIF_TRUE; } -static avifBool avifParseItemPropertyContainerBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemPropertyContainerBox(avifPropertyArray * properties, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1005,34 +1153,27 @@ static avifBool avifParseItemPropertyContainerBox(avifDecoderData * data, const avifBoxHeader header; CHECK(avifROStreamReadBoxHeader(&s, &header)); - int propertyIndex = avifArrayPushIndex(&data->properties); - memcpy(data->properties.prop[propertyIndex].type, header.type, 4); + int propertyIndex = avifArrayPushIndex(properties); + avifProperty * prop = &properties->prop[propertyIndex]; + memcpy(prop->type, header.type, 4); if (!memcmp(header.type, "ispe", 4)) { - CHECK(avifParseImageSpatialExtentsProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "auxC", 4)) { - CHECK(avifParseAuxiliaryTypeProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "colr", 4)) { - CHECK(avifParseColourInformationBox(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "av1C", 4)) { - CHECK(avifParseAV1CodecConfigurationBoxProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "pasp", 4)) { - CHECK(avifParsePixelAspectRatioBoxProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "clap", 4)) { - CHECK(avifParseCleanApertureBoxProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "irot", 4)) { - CHECK(avifParseImageRotationProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "imir", 4)) { - CHECK(avifParseImageMirrorProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); - } - if (!memcmp(header.type, "pixi", 4)) { - CHECK(avifParsePixelInformationProperty(data, avifROStreamCurrent(&s), header.size, propertyIndex)); + CHECK(avifParseImageSpatialExtentsProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "auxC", 4)) { + CHECK(avifParseAuxiliaryTypeProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "colr", 4)) { + CHECK(avifParseColourInformationBox(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "av1C", 4)) { + CHECK(avifParseAV1CodecConfigurationBoxProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "pasp", 4)) { + CHECK(avifParsePixelAspectRatioBoxProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "clap", 4)) { + CHECK(avifParseCleanApertureBoxProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "irot", 4)) { + CHECK(avifParseImageRotationProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "imir", 4)) { + CHECK(avifParseImageMirrorProperty(prop, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "pixi", 4)) { + CHECK(avifParsePixelInformationProperty(prop, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1040,14 +1181,14 @@ static avifBool avifParseItemPropertyContainerBox(avifDecoderData * data, const return AVIF_TRUE; } -static avifBool avifParseItemPropertyAssociation(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemPropertyAssociation(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); uint8_t version; - uint8_t flags[3]; - CHECK(avifROStreamReadVersionAndFlags(&s, &version, flags)); - avifBool propertyIndexIsU16 = ((flags[2] & 0x1) != 0); + uint32_t flags; + CHECK(avifROStreamReadVersionAndFlags(&s, &version, &flags)); + avifBool propertyIndexIsU16 = ((flags & 0x1) != 0); uint32_t entryCount; CHECK(avifROStreamReadU32(&s, &entryCount)); @@ -1082,44 +1223,30 @@ static avifBool avifParseItemPropertyAssociation(avifDecoderData * data, const u } --propertyIndex; // 1-indexed - if (propertyIndex >= data->properties.count) { + if (propertyIndex >= meta->properties.count) { return AVIF_FALSE; } - avifDecoderItem * item = avifDecoderDataFindItem(data, itemID); + avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { return AVIF_FALSE; } - // Associate property with item - avifProperty * prop = &data->properties.prop[propertyIndex]; - if (!memcmp(prop->type, "ispe", 4)) { - item->ispePresent = AVIF_TRUE; - memcpy(&item->ispe, &prop->ispe, sizeof(avifImageSpatialExtents)); - } else if (!memcmp(prop->type, "auxC", 4)) { - item->auxCPresent = AVIF_TRUE; - memcpy(&item->auxC, &prop->auxC, sizeof(avifAuxiliaryType)); - } else if (!memcmp(prop->type, "colr", 4)) { - item->colrPresent = AVIF_TRUE; - memcpy(&item->colr, &prop->colr, sizeof(avifColourInformationBox)); - } else if (!memcmp(prop->type, "av1C", 4)) { - item->av1CPresent = AVIF_TRUE; - memcpy(&item->av1C, &prop->av1C, sizeof(avifCodecConfigurationBox)); - } else if (!memcmp(prop->type, "pasp", 4)) { - item->paspPresent = AVIF_TRUE; - memcpy(&item->pasp, &prop->pasp, sizeof(avifPixelAspectRatioBox)); - } else if (!memcmp(prop->type, "clap", 4)) { - item->clapPresent = AVIF_TRUE; - memcpy(&item->clap, &prop->clap, sizeof(avifCleanApertureBox)); - } else if (!memcmp(prop->type, "irot", 4)) { - item->irotPresent = AVIF_TRUE; - memcpy(&item->irot, &prop->irot, sizeof(avifImageRotation)); - } else if (!memcmp(prop->type, "imir", 4)) { - item->imirPresent = AVIF_TRUE; - memcpy(&item->imir, &prop->imir, sizeof(avifImageMirror)); - } else if (!memcmp(prop->type, "pixi", 4)) { - item->pixiPresent = AVIF_TRUE; - memcpy(&item->pixi, &prop->pixi, sizeof(avifPixelInformationProperty)); + // Copy property to item + avifProperty * srcProp = &meta->properties.prop[propertyIndex]; + + static const char * supportedTypes[] = { "ispe", "auxC", "colr", "av1C", "pasp", "clap", "irot", "imir", "pixi" }; + size_t supportedTypesCount = sizeof(supportedTypes) / sizeof(supportedTypes[0]); + avifBool supportedType = AVIF_FALSE; + for (size_t i = 0; i < supportedTypesCount; ++i) { + if (!memcmp(srcProp->type, supportedTypes[i], 4)) { + supportedType = AVIF_TRUE; + break; + } + } + if (supportedType) { + avifProperty * dstProp = (avifProperty *)avifArrayPushPtr(&item->properties); + memcpy(dstProp, srcProp, sizeof(avifProperty)); } else { if (essential) { // Discovered an essential item property that libavif doesn't support! @@ -1133,9 +1260,9 @@ static avifBool avifParseItemPropertyAssociation(avifDecoderData * data, const u return AVIF_TRUE; } -static avifBool avifParsePrimaryItemBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParsePrimaryItemBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { - if (data->primaryItemID > 0) { + if (meta->primaryItemID > 0) { // Illegal to have multiple pitm boxes, bail out return AVIF_FALSE; } @@ -1148,33 +1275,31 @@ static avifBool avifParsePrimaryItemBox(avifDecoderData * data, const uint8_t * if (version == 0) { uint16_t tmp16; CHECK(avifROStreamReadU16(&s, &tmp16)); // unsigned int(16) item_ID; - data->primaryItemID = tmp16; + meta->primaryItemID = tmp16; } else { - CHECK(avifROStreamReadU32(&s, &data->primaryItemID)); // unsigned int(32) item_ID; + CHECK(avifROStreamReadU32(&s, &meta->primaryItemID)); // unsigned int(32) item_ID; } return AVIF_TRUE; } -static avifBool avifParseItemDataBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemDataBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { - uint32_t idatID = data->metaBoxID; - // Check to see if we've already seen an idat box for this meta box. If so, bail out - for (uint32_t i = 0; i < data->idats.count; ++i) { - if (data->idats.idat[i].id == idatID) { + for (uint32_t i = 0; i < meta->idats.count; ++i) { + if (meta->idats.idat[i].id == meta->idatID) { return AVIF_FALSE; } } - int index = avifArrayPushIndex(&data->idats); - avifDecoderItemData * idat = &data->idats.idat[index]; - idat->id = idatID; + int index = avifArrayPushIndex(&meta->idats); + avifDecoderItemData * idat = &meta->idats.idat[index]; + idat->id = meta->idatID; idat->data.data = raw; idat->data.size = rawLen; return AVIF_TRUE; } -static avifBool avifParseItemPropertiesBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemPropertiesBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1185,7 +1310,7 @@ static avifBool avifParseItemPropertiesBox(avifDecoderData * data, const uint8_t } // Read all item properties inside of ItemPropertyContainerBox - CHECK(avifParseItemPropertyContainerBox(data, avifROStreamCurrent(&s), ipcoHeader.size)); + CHECK(avifParseItemPropertyContainerBox(&meta->properties, avifROStreamCurrent(&s), ipcoHeader.size)); CHECK(avifROStreamSkip(&s, ipcoHeader.size)); // Now read all ItemPropertyAssociation until the end of the box, and make associations @@ -1194,7 +1319,7 @@ static avifBool avifParseItemPropertiesBox(avifDecoderData * data, const uint8_t CHECK(avifROStreamReadBoxHeader(&s, &ipmaHeader)); if (!memcmp(ipmaHeader.type, "ipma", 4)) { - CHECK(avifParseItemPropertyAssociation(data, avifROStreamCurrent(&s), ipmaHeader.size)); + CHECK(avifParseItemPropertyAssociation(meta, avifROStreamCurrent(&s), ipmaHeader.size)); } else { // These must all be type ipma return AVIF_FALSE; @@ -1205,7 +1330,7 @@ static avifBool avifParseItemPropertiesBox(avifDecoderData * data, const uint8_t return AVIF_TRUE; } -static avifBool avifParseItemInfoEntry(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemInfoEntry(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1226,7 +1351,7 @@ static avifBool avifParseItemInfoEntry(avifDecoderData * data, const uint8_t * r memset(&contentType, 0, sizeof(contentType)); } - avifDecoderItem * item = avifDecoderDataFindItem(data, itemID); + avifDecoderItem * item = avifMetaFindItem(meta, itemID); if (!item) { return AVIF_FALSE; } @@ -1236,7 +1361,7 @@ static avifBool avifParseItemInfoEntry(avifDecoderData * data, const uint8_t * r return AVIF_TRUE; } -static avifBool avifParseItemInfoBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemInfoBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1258,7 +1383,7 @@ static avifBool avifParseItemInfoBox(avifDecoderData * data, const uint8_t * raw CHECK(avifROStreamReadBoxHeader(&s, &infeHeader)); if (!memcmp(infeHeader.type, "infe", 4)) { - CHECK(avifParseItemInfoEntry(data, avifROStreamCurrent(&s), infeHeader.size)); + CHECK(avifParseItemInfoEntry(meta, avifROStreamCurrent(&s), infeHeader.size)); } else { // These must all be type ipma return AVIF_FALSE; @@ -1270,7 +1395,7 @@ static avifBool avifParseItemInfoBox(avifDecoderData * data, const uint8_t * raw return AVIF_TRUE; } -static avifBool avifParseItemReferenceBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseItemReferenceBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1311,7 +1436,7 @@ static avifBool avifParseItemReferenceBox(avifDecoderData * data, const uint8_t // Read this reference as "{fromID} is a {irefType} for {toID}" if (fromID && toID) { - avifDecoderItem * item = avifDecoderDataFindItem(data, fromID); + avifDecoderItem * item = avifMetaFindItem(meta, fromID); if (!item) { return AVIF_FALSE; } @@ -1327,7 +1452,7 @@ static avifBool avifParseItemReferenceBox(avifDecoderData * data, const uint8_t } if (!memcmp(irefHeader.type, "dimg", 4)) { // derived images refer in the opposite direction - avifDecoderItem * dimg = avifDecoderDataFindItem(data, toID); + avifDecoderItem * dimg = avifMetaFindItem(meta, toID); if (!dimg) { return AVIF_FALSE; } @@ -1341,30 +1466,30 @@ static avifBool avifParseItemReferenceBox(avifDecoderData * data, const uint8_t return AVIF_TRUE; } -static avifBool avifParseMetaBox(avifDecoderData * data, const uint8_t * raw, size_t rawLen) +static avifBool avifParseMetaBox(avifMeta * meta, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); - ++data->metaBoxID; // for tracking idat + ++meta->idatID; // for tracking idat while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "iloc", 4)) { - CHECK(avifParseItemLocationBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseItemLocationBox(meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "pitm", 4)) { - CHECK(avifParsePrimaryItemBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParsePrimaryItemBox(meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "idat", 4)) { - CHECK(avifParseItemDataBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseItemDataBox(meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "iprp", 4)) { - CHECK(avifParseItemPropertiesBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseItemPropertiesBox(meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "iinf", 4)) { - CHECK(avifParseItemInfoBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseItemInfoBox(meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "iref", 4)) { - CHECK(avifParseItemReferenceBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseItemReferenceBox(meta, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1372,14 +1497,12 @@ static avifBool avifParseMetaBox(avifDecoderData * data, const uint8_t * raw, si return AVIF_TRUE; } -static avifBool avifParseTrackHeaderBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifParseTrackHeaderBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; uint8_t version; - uint8_t flags[3]; - CHECK(avifROStreamReadVersionAndFlags(&s, &version, flags)); + CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); uint32_t ignored32, trackID; uint64_t ignored64; @@ -1422,14 +1545,12 @@ static avifBool avifParseTrackHeaderBox(avifDecoderData * data, avifTrack * trac return AVIF_TRUE; } -static avifBool avifParseMediaHeaderBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifParseMediaHeaderBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; uint8_t version; - uint8_t flags[3]; - CHECK(avifROStreamReadVersionAndFlags(&s, &version, flags)); + CHECK(avifROStreamReadVersionAndFlags(&s, &version, NULL)); uint32_t ignored32, mediaTimescale, mediaDuration32; uint64_t ignored64, mediaDuration64; @@ -1454,10 +1575,9 @@ static avifBool avifParseMediaHeaderBox(avifDecoderData * data, avifTrack * trac return AVIF_TRUE; } -static avifBool avifParseChunkOffsetBox(avifDecoderData * data, avifSampleTable * sampleTable, avifBool largeOffsets, const uint8_t * raw, size_t rawLen) +static avifBool avifParseChunkOffsetBox(avifSampleTable * sampleTable, avifBool largeOffsets, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1479,10 +1599,9 @@ static avifBool avifParseChunkOffsetBox(avifDecoderData * data, avifSampleTable return AVIF_TRUE; } -static avifBool avifParseSampleToChunkBox(avifDecoderData * data, avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) +static avifBool avifParseSampleToChunkBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1497,10 +1616,9 @@ static avifBool avifParseSampleToChunkBox(avifDecoderData * data, avifSampleTabl return AVIF_TRUE; } -static avifBool avifParseSampleSizeBox(avifDecoderData * data, avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) +static avifBool avifParseSampleSizeBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1519,10 +1637,9 @@ static avifBool avifParseSampleSizeBox(avifDecoderData * data, avifSampleTable * return AVIF_TRUE; } -static avifBool avifParseSyncSampleBox(avifDecoderData * data, avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) +static avifBool avifParseSyncSampleBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1538,10 +1655,9 @@ static avifBool avifParseSyncSampleBox(avifDecoderData * data, avifSampleTable * return AVIF_TRUE; } -static avifBool avifParseTimeToSampleBox(avifDecoderData * data, avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) +static avifBool avifParseTimeToSampleBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1556,10 +1672,9 @@ static avifBool avifParseTimeToSampleBox(avifDecoderData * data, avifSampleTable return AVIF_TRUE; } -static avifBool avifParseSampleDescriptionBox(avifDecoderData * data, avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) +static avifBool avifParseSampleDescriptionBox(avifSampleTable * sampleTable, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; CHECK(avifROStreamReadAndEnforceVersion(&s, 0)); @@ -1571,21 +1686,12 @@ static avifBool avifParseSampleDescriptionBox(avifDecoderData * data, avifSample CHECK(avifROStreamReadBoxHeader(&s, &sampleEntryHeader)); avifSampleDescription * description = (avifSampleDescription *)avifArrayPushPtr(&sampleTable->sampleDescriptions); + avifArrayCreate(&description->properties, sizeof(avifProperty), 16); memcpy(description->format, sampleEntryHeader.type, sizeof(description->format)); size_t remainingBytes = avifROStreamRemainingBytes(&s); if (!memcmp(description->format, "av01", 4) && (remainingBytes > VISUALSAMPLEENTRY_SIZE)) { - BEGIN_STREAM(av01Stream, avifROStreamCurrent(&s) + VISUALSAMPLEENTRY_SIZE, remainingBytes - VISUALSAMPLEENTRY_SIZE); - while (avifROStreamHasBytesLeft(&av01Stream, 1)) { - avifBoxHeader av01ChildHeader; - CHECK(avifROStreamReadBoxHeader(&av01Stream, &av01ChildHeader)); - - if (!memcmp(av01ChildHeader.type, "av1C", 4)) { - CHECK(avifParseAV1CodecConfigurationBox(avifROStreamCurrent(&av01Stream), av01ChildHeader.size, &description->av1C)); - description->av1CPresent = AVIF_TRUE; - } - - CHECK(avifROStreamSkip(&av01Stream, av01ChildHeader.size)); - } + CHECK(avifParseItemPropertyContainerBox( + &description->properties, avifROStreamCurrent(&s) + VISUALSAMPLEENTRY_SIZE, remainingBytes - VISUALSAMPLEENTRY_SIZE)); } CHECK(avifROStreamSkip(&s, sampleEntryHeader.size)); @@ -1593,7 +1699,7 @@ static avifBool avifParseSampleDescriptionBox(avifDecoderData * data, avifSample return AVIF_TRUE; } -static avifBool avifParseSampleTableBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifParseSampleTableBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { if (track->sampleTable) { // A TrackBox may only have one SampleTable @@ -1608,19 +1714,19 @@ static avifBool avifParseSampleTableBox(avifDecoderData * data, avifTrack * trac CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "stco", 4)) { - CHECK(avifParseChunkOffsetBox(data, track->sampleTable, AVIF_FALSE, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseChunkOffsetBox(track->sampleTable, AVIF_FALSE, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "co64", 4)) { - CHECK(avifParseChunkOffsetBox(data, track->sampleTable, AVIF_TRUE, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseChunkOffsetBox(track->sampleTable, AVIF_TRUE, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "stsc", 4)) { - CHECK(avifParseSampleToChunkBox(data, track->sampleTable, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseSampleToChunkBox(track->sampleTable, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "stsz", 4)) { - CHECK(avifParseSampleSizeBox(data, track->sampleTable, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseSampleSizeBox(track->sampleTable, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "stss", 4)) { - CHECK(avifParseSyncSampleBox(data, track->sampleTable, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseSyncSampleBox(track->sampleTable, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "stts", 4)) { - CHECK(avifParseTimeToSampleBox(data, track->sampleTable, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseTimeToSampleBox(track->sampleTable, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "stsd", 4)) { - CHECK(avifParseSampleDescriptionBox(data, track->sampleTable, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseSampleDescriptionBox(track->sampleTable, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1628,7 +1734,7 @@ static avifBool avifParseSampleTableBox(avifDecoderData * data, avifTrack * trac return AVIF_TRUE; } -static avifBool avifParseMediaInformationBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifParseMediaInformationBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1637,7 +1743,7 @@ static avifBool avifParseMediaInformationBox(avifDecoderData * data, avifTrack * CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "stbl", 4)) { - CHECK(avifParseSampleTableBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseSampleTableBox(track, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1645,7 +1751,7 @@ static avifBool avifParseMediaInformationBox(avifDecoderData * data, avifTrack * return AVIF_TRUE; } -static avifBool avifParseMediaBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifParseMediaBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); @@ -1654,9 +1760,9 @@ static avifBool avifParseMediaBox(avifDecoderData * data, avifTrack * track, con CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "mdhd", 4)) { - CHECK(avifParseMediaHeaderBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseMediaHeaderBox(track, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "minf", 4)) { - CHECK(avifParseMediaInformationBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseMediaInformationBox(track, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1664,10 +1770,9 @@ static avifBool avifParseMediaBox(avifDecoderData * data, avifTrack * track, con return AVIF_TRUE; } -static avifBool avifTrackReferenceBox(avifDecoderData * data, avifTrack * track, const uint8_t * raw, size_t rawLen) +static avifBool avifTrackReferenceBox(avifTrack * track, const uint8_t * raw, size_t rawLen) { BEGIN_STREAM(s, raw, rawLen); - (void)data; while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; @@ -1689,18 +1794,20 @@ static avifBool avifParseTrackBox(avifDecoderData * data, const uint8_t * raw, s { BEGIN_STREAM(s, raw, rawLen); - avifTrack * track = (avifTrack *)avifArrayPushPtr(&data->tracks); + avifTrack * track = avifDecoderDataCreateTrack(data); while (avifROStreamHasBytesLeft(&s, 1)) { avifBoxHeader header; CHECK(avifROStreamReadBoxHeader(&s, &header)); if (!memcmp(header.type, "tkhd", 4)) { - CHECK(avifParseTrackHeaderBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseTrackHeaderBox(track, avifROStreamCurrent(&s), header.size)); + } else if (!memcmp(header.type, "meta", 4)) { + CHECK(avifParseMetaBox(track->meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "mdia", 4)) { - CHECK(avifParseMediaBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseMediaBox(track, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "tref", 4)) { - CHECK(avifTrackReferenceBox(data, track, avifROStreamCurrent(&s), header.size)); + CHECK(avifTrackReferenceBox(track, avifROStreamCurrent(&s), header.size)); } CHECK(avifROStreamSkip(&s, header.size)); @@ -1736,11 +1843,8 @@ static avifBool avifParseFileTypeBox(avifFileType * ftyp, const uint8_t * raw, s if ((compatibleBrandsBytes % 4) != 0) { return AVIF_FALSE; } - if (compatibleBrandsBytes > (4 * MAX_COMPATIBLE_BRANDS)) { - // TODO: stop clamping and resize this - compatibleBrandsBytes = (4 * MAX_COMPATIBLE_BRANDS); - } - CHECK(avifROStreamRead(&s, ftyp->compatibleBrands, compatibleBrandsBytes)); + ftyp->compatibleBrands = avifROStreamCurrent(&s); + CHECK(avifROStreamSkip(&s, compatibleBrandsBytes)); ftyp->compatibleBrandsCount = (int)compatibleBrandsBytes / 4; return AVIF_TRUE; @@ -1757,7 +1861,7 @@ static avifBool avifParse(avifDecoderData * data, const uint8_t * raw, size_t ra if (!memcmp(header.type, "ftyp", 4)) { CHECK(avifParseFileTypeBox(&data->ftyp, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "meta", 4)) { - CHECK(avifParseMetaBox(data, avifROStreamCurrent(&s), header.size)); + CHECK(avifParseMetaBox(data->meta, avifROStreamCurrent(&s), header.size)); } else if (!memcmp(header.type, "moov", 4)) { CHECK(avifParseMoovBox(data, avifROStreamCurrent(&s), header.size)); } @@ -1771,25 +1875,11 @@ static avifBool avifParse(avifDecoderData * data, const uint8_t * raw, size_t ra static avifBool avifFileTypeIsCompatible(avifFileType * ftyp) { - avifBool avifCompatible = (memcmp(ftyp->majorBrand, "avif", 4) == 0); - if (!avifCompatible) { - avifCompatible = (memcmp(ftyp->majorBrand, "avis", 4) == 0); - } - if (!avifCompatible) { - avifCompatible = (memcmp(ftyp->majorBrand, "av01", 4) == 0); - } + avifBool avifCompatible = (memcmp(ftyp->majorBrand, "avif", 4) == 0 || memcmp(ftyp->majorBrand, "avis", 4) == 0); if (!avifCompatible) { for (int compatibleBrandIndex = 0; compatibleBrandIndex < ftyp->compatibleBrandsCount; ++compatibleBrandIndex) { - uint8_t * compatibleBrand = &ftyp->compatibleBrands[4 * compatibleBrandIndex]; - if (!memcmp(compatibleBrand, "avif", 4)) { - avifCompatible = AVIF_TRUE; - break; - } - if (!memcmp(compatibleBrand, "avis", 4)) { - avifCompatible = AVIF_TRUE; - break; - } - if (!memcmp(compatibleBrand, "av01", 4)) { + const uint8_t * compatibleBrand = &ftyp->compatibleBrands[4 * compatibleBrandIndex]; + if (!memcmp(compatibleBrand, "avif", 4) || !memcmp(compatibleBrand, "avis", 4)) { avifCompatible = AVIF_TRUE; break; } @@ -1798,7 +1888,7 @@ static avifBool avifFileTypeIsCompatible(avifFileType * ftyp) return avifCompatible; } -avifBool avifPeekCompatibleFileType(avifROData * input) +avifBool avifPeekCompatibleFileType(const avifROData * input) { BEGIN_STREAM(s, input->data, input->size); @@ -1851,7 +1941,7 @@ avifResult avifDecoderSetSource(avifDecoder * decoder, avifDecoderSource source) return avifDecoderReset(decoder); } -avifResult avifDecoderParse(avifDecoder * decoder, avifROData * rawInput) +avifResult avifDecoderParse(avifDecoder * decoder, const avifROData * rawInput) { // Cleanup anything lingering in the decoder avifDecoderCleanup(decoder); @@ -1874,8 +1964,8 @@ avifResult avifDecoderParse(avifDecoder * decoder, avifROData * rawInput) } // Sanity check items - for (uint32_t itemIndex = 0; itemIndex < decoder->data->items.count; ++itemIndex) { - avifDecoderItem * item = &decoder->data->items.item[itemIndex]; + for (uint32_t itemIndex = 0; itemIndex < decoder->data->meta->items.count; ++itemIndex) { + avifDecoderItem * item = &decoder->data->meta->items.item[itemIndex]; if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; ignore the item. continue; @@ -1964,6 +2054,7 @@ avifResult avifDecoderReset(avifDecoder * decoder) data->source = decoder->requestedSource; } + const avifPropertyArray * colorProperties = NULL; if (data->source == AVIF_DECODER_SOURCE_TRACKS) { avifTrack * colorTrack = NULL; avifTrack * alphaTrack = NULL; @@ -1975,6 +2066,9 @@ avifResult avifDecoderReset(avifDecoder * decoder) if (!track->sampleTable) { continue; } + if (!track->id) { // trak box might be missing a tkhd box inside, skip it + continue; + } if (!track->sampleTable->chunks.count) { continue; } @@ -1993,12 +2087,28 @@ avifResult avifDecoderReset(avifDecoder * decoder) } colorTrack = &decoder->data->tracks.track[colorTrackIndex]; + colorProperties = avifSampleTableGetProperties(colorTrack->sampleTable); + if (!colorProperties) { + return AVIF_RESULT_BMFF_PARSE_FAILED; + } + + // Find Exif and/or XMP metadata, if any + if (colorTrack->meta) { + // See the comment above avifDecoderDataFindMetadata() for the explanation of using 0 here + if (!avifDecoderDataFindMetadata(data, colorTrack->meta, decoder->image, 0)) { + return AVIF_RESULT_BMFF_PARSE_FAILED; + } + } + uint32_t alphaTrackIndex = 0; for (; alphaTrackIndex < decoder->data->tracks.count; ++alphaTrackIndex) { avifTrack * track = &decoder->data->tracks.track[alphaTrackIndex]; if (!track->sampleTable) { continue; } + if (!track->id) { + continue; + } if (!track->sampleTable->chunks.count) { continue; } @@ -2045,24 +2155,22 @@ avifResult avifDecoderReset(avifDecoder * decoder) } memset(&decoder->imageTiming, 0, sizeof(decoder->imageTiming)); // to be set in avifDecoderNextImage() - decoder->containerWidth = colorTrack->width; - decoder->containerHeight = colorTrack->height; - decoder->containerDepth = avifSampleTableGetDepth(colorTrack->sampleTable); + decoder->image->width = colorTrack->width; + decoder->image->height = colorTrack->height; + decoder->alphaPresent = (alphaTrack != NULL); } else { // Create from items avifROData colorOBU = AVIF_DATA_EMPTY; avifROData alphaOBU = AVIF_DATA_EMPTY; - avifROData exifData = AVIF_DATA_EMPTY; - avifROData xmpData = AVIF_DATA_EMPTY; avifDecoderItem * colorOBUItem = NULL; avifDecoderItem * alphaOBUItem = NULL; // Find the colorOBU (primary) item - for (uint32_t itemIndex = 0; itemIndex < data->items.count; ++itemIndex) { - avifDecoderItem * item = &data->items.item[itemIndex]; - if (!item->id || !item->size) { - break; + for (uint32_t itemIndex = 0; itemIndex < data->meta->items.count; ++itemIndex) { + avifDecoderItem * item = &data->meta->items.item[itemIndex]; + if (!item->size) { + continue; } if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; ignore the item. @@ -2077,12 +2185,15 @@ avifResult avifDecoderReset(avifDecoder * decoder) // It's a thumbnail, skip it continue; } - if ((data->primaryItemID > 0) && (item->id != data->primaryItemID)) { + if ((data->meta->primaryItemID > 0) && (item->id != data->meta->primaryItemID)) { // a primary item ID was specified, require it continue; } if (isGrid) { + if (decoder->disableGridImages) { + return AVIF_RESULT_BMFF_PARSE_FAILED; + } const uint8_t * itemPtr = avifDecoderDataCalcItemPtr(data, item); if (itemPtr == NULL) { return AVIF_RESULT_BMFF_PARSE_FAILED; @@ -2102,12 +2213,13 @@ avifResult avifDecoderReset(avifDecoder * decoder) if (!colorOBUItem) { return AVIF_RESULT_NO_AV1_ITEMS_FOUND; } + colorProperties = &colorOBUItem->properties; // Find the alphaOBU item, if any - for (uint32_t itemIndex = 0; itemIndex < data->items.count; ++itemIndex) { - avifDecoderItem * item = &data->items.item[itemIndex]; - if (!item->id || !item->size) { - break; + for (uint32_t itemIndex = 0; itemIndex < data->meta->items.count; ++itemIndex) { + avifDecoderItem * item = &data->meta->items.item[itemIndex]; + if (!item->size) { + continue; } if (item->hasUnsupportedEssentialProperty) { // An essential property isn't supported by libavif; ignore the item. @@ -2123,8 +2235,12 @@ avifResult avifDecoderReset(avifDecoder * decoder) continue; } - if (isAlphaURN(item->auxC.auxType) && (item->auxForID == colorOBUItem->id)) { + const avifProperty * auxCProp = avifPropertyArrayFind(&item->properties, "auxC"); + if (auxCProp && isAlphaURN(auxCProp->u.auxC.auxType) && (item->auxForID == colorOBUItem->id)) { if (isGrid) { + if (decoder->disableGridImages) { + return AVIF_RESULT_BMFF_PARSE_FAILED; + } const uint8_t * itemPtr = avifDecoderDataCalcItemPtr(data, item); if (itemPtr == NULL) { return AVIF_RESULT_BMFF_PARSE_FAILED; @@ -2143,36 +2259,8 @@ avifResult avifDecoderReset(avifDecoder * decoder) } // Find Exif and/or XMP metadata, if any - for (uint32_t itemIndex = 0; itemIndex < data->items.count; ++itemIndex) { - avifDecoderItem * item = &data->items.item[itemIndex]; - if (!item->id || !item->size) { - break; - } - if (item->hasUnsupportedEssentialProperty) { - // An essential property isn't supported by libavif; ignore the item. - continue; - } - - if (item->descForID != colorOBUItem->id) { - // Not a content description (metadata) for the colorOBU, skip it - continue; - } - - if (!memcmp(item->type, "Exif", 4)) { - // Advance past Annex A.2.1's header - const uint8_t * boxPtr = avifDecoderDataCalcItemPtr(data, item); - BEGIN_STREAM(exifBoxStream, boxPtr, item->size); - uint32_t exifTiffHeaderOffset; - CHECK(avifROStreamReadU32(&exifBoxStream, &exifTiffHeaderOffset)); // unsigned int(32) exif_tiff_header_offset; - - exifData.data = avifROStreamCurrent(&exifBoxStream); - exifData.size = avifROStreamRemainingBytes(&exifBoxStream); - } - - if (!memcmp(item->type, "mime", 4) && !memcmp(item->contentType.contentType, xmpContentType, xmpContentTypeSize)) { - xmpData.data = avifDecoderDataCalcItemPtr(data, item); - xmpData.size = item->size; - } + if (!avifDecoderDataFindMetadata(data, data->meta, decoder->image, colorOBUItem->id)) { + return AVIF_RESULT_BMFF_PARSE_FAILED; } if ((data->colorGrid.rows > 0) && (data->colorGrid.columns > 0)) { @@ -2186,14 +2274,14 @@ avifResult avifDecoderReset(avifDecoder * decoder) } avifTile * colorTile = avifDecoderDataCreateTile(decoder->data); - avifSample * colorSample = (avifSample *)avifArrayPushPtr(&colorTile->input->samples); + avifDecodeSample * colorSample = (avifDecodeSample *)avifArrayPushPtr(&colorTile->input->samples); memcpy(&colorSample->data, &colorOBU, sizeof(avifROData)); colorSample->sync = AVIF_TRUE; decoder->data->colorTileCount = 1; } if ((data->alphaGrid.rows > 0) && (data->alphaGrid.columns > 0) && alphaOBUItem) { - if (!avifDecoderDataGenerateImageGridTiles(data, &data->alphaGrid, alphaOBUItem, AVIF_FALSE)) { + if (!avifDecoderDataGenerateImageGridTiles(data, &data->alphaGrid, alphaOBUItem, AVIF_TRUE)) { return AVIF_RESULT_INVALID_IMAGE_GRID; } data->alphaTileCount = data->tiles.count - data->colorTileCount; @@ -2202,7 +2290,7 @@ avifResult avifDecoderReset(avifDecoder * decoder) if (alphaOBU.size > 0) { alphaTile = avifDecoderDataCreateTile(decoder->data); - avifSample * alphaSample = (avifSample *)avifArrayPushPtr(&alphaTile->input->samples); + avifDecodeSample * alphaSample = (avifDecodeSample *)avifArrayPushPtr(&alphaTile->input->samples); memcpy(&alphaSample->data, &alphaOBU, sizeof(avifROData)); alphaSample->sync = AVIF_TRUE; alphaTile->input->alpha = AVIF_TRUE; @@ -2210,43 +2298,6 @@ avifResult avifDecoderReset(avifDecoder * decoder) } } - if (colorOBUItem->colrPresent) { - if (colorOBUItem->colr.hasICC) { - avifImageSetProfileICC(decoder->image, colorOBUItem->colr.icc, colorOBUItem->colr.iccSize); - } else if (colorOBUItem->colr.hasNCLX) { - data->cicpSet = AVIF_TRUE; - decoder->image->colorPrimaries = colorOBUItem->colr.colorPrimaries; - decoder->image->transferCharacteristics = colorOBUItem->colr.transferCharacteristics; - decoder->image->matrixCoefficients = colorOBUItem->colr.matrixCoefficients; - decoder->image->yuvRange = colorOBUItem->colr.range; - } - } - - // Transformations - if (colorOBUItem->paspPresent) { - decoder->image->transformFlags |= AVIF_TRANSFORM_PASP; - memcpy(&decoder->image->pasp, &colorOBUItem->pasp, sizeof(avifPixelAspectRatioBox)); - } - if (colorOBUItem->clapPresent) { - decoder->image->transformFlags |= AVIF_TRANSFORM_CLAP; - memcpy(&decoder->image->clap, &colorOBUItem->clap, sizeof(avifCleanApertureBox)); - } - if (colorOBUItem->irotPresent) { - decoder->image->transformFlags |= AVIF_TRANSFORM_IROT; - memcpy(&decoder->image->irot, &colorOBUItem->irot, sizeof(avifImageRotation)); - } - if (colorOBUItem->imirPresent) { - decoder->image->transformFlags |= AVIF_TRANSFORM_IMIR; - memcpy(&decoder->image->imir, &colorOBUItem->imir, sizeof(avifImageMirror)); - } - - if (exifData.data && exifData.size) { - avifImageSetMetadataExif(decoder->image, exifData.data, exifData.size); - } - if (xmpData.data && xmpData.size) { - avifImageSetMetadataXMP(decoder->image, xmpData.data, xmpData.size); - } - // Set all counts and timing to safe-but-uninteresting values decoder->imageIndex = -1; decoder->imageCount = 1; @@ -2262,18 +2313,98 @@ avifResult avifDecoderReset(avifDecoder * decoder) decoder->ioStats.colorOBUSize = colorOBU.size; decoder->ioStats.alphaOBUSize = alphaOBU.size; - if (colorOBUItem->ispePresent) { - decoder->containerWidth = colorOBUItem->ispe.width; - decoder->containerHeight = colorOBUItem->ispe.height; + const avifProperty * ispeProp = avifPropertyArrayFind(colorProperties, "ispe"); + if (ispeProp) { + decoder->image->width = ispeProp->u.ispe.width; + decoder->image->height = ispeProp->u.ispe.height; } else { - decoder->containerWidth = 0; - decoder->containerHeight = 0; + decoder->image->width = 0; + decoder->image->height = 0; } - if (colorOBUItem->av1CPresent) { - decoder->containerDepth = avifCodecConfigurationBoxGetDepth(&colorOBUItem->av1C); + decoder->alphaPresent = (alphaOBUItem != NULL); + } + + // Sanity check tiles + for (uint32_t tileIndex = 0; tileIndex < data->tiles.count; ++tileIndex) { + avifTile * tile = &data->tiles.tile[tileIndex]; + for (uint32_t sampleIndex = 0; sampleIndex < tile->input->samples.count; ++sampleIndex) { + avifDecodeSample * sample = &tile->input->samples.sample[sampleIndex]; + if (!sample->data.data || !sample->data.size) { + // Every sample must have some data + return AVIF_RESULT_BMFF_PARSE_FAILED; + } + } + } + + const avifProperty * colrProp = avifPropertyArrayFind(colorProperties, "colr"); + if (colrProp) { + if (colrProp->u.colr.hasICC) { + avifImageSetProfileICC(decoder->image, colrProp->u.colr.icc, colrProp->u.colr.iccSize); + } else if (colrProp->u.colr.hasNCLX) { + data->cicpSet = AVIF_TRUE; + decoder->image->colorPrimaries = colrProp->u.colr.colorPrimaries; + decoder->image->transferCharacteristics = colrProp->u.colr.transferCharacteristics; + decoder->image->matrixCoefficients = colrProp->u.colr.matrixCoefficients; + decoder->image->yuvRange = colrProp->u.colr.range; + } + } + + // Transformations + const avifProperty * paspProp = avifPropertyArrayFind(colorProperties, "pasp"); + if (paspProp) { + decoder->image->transformFlags |= AVIF_TRANSFORM_PASP; + memcpy(&decoder->image->pasp, &paspProp->u.pasp, sizeof(avifPixelAspectRatioBox)); + } + const avifProperty * clapProp = avifPropertyArrayFind(colorProperties, "clap"); + if (clapProp) { + decoder->image->transformFlags |= AVIF_TRANSFORM_CLAP; + memcpy(&decoder->image->clap, &clapProp->u.clap, sizeof(avifCleanApertureBox)); + } + const avifProperty * irotProp = avifPropertyArrayFind(colorProperties, "irot"); + if (irotProp) { + decoder->image->transformFlags |= AVIF_TRANSFORM_IROT; + memcpy(&decoder->image->irot, &irotProp->u.irot, sizeof(avifImageRotation)); + } + const avifProperty * imirProp = avifPropertyArrayFind(colorProperties, "imir"); + if (imirProp) { + decoder->image->transformFlags |= AVIF_TRANSFORM_IMIR; + memcpy(&decoder->image->imir, &imirProp->u.imir, sizeof(avifImageMirror)); + } + + if (!decoder->data->cicpSet && (data->tiles.count > 0)) { + avifTile * firstTile = &data->tiles.tile[0]; + if (firstTile->input->samples.count > 0) { + avifDecodeSample * sample = &firstTile->input->samples.sample[0]; + avifSequenceHeader sequenceHeader; + if (avifSequenceHeaderParse(&sequenceHeader, &sample->data)) { + decoder->data->cicpSet = AVIF_TRUE; + decoder->image->colorPrimaries = sequenceHeader.colorPrimaries; + decoder->image->transferCharacteristics = sequenceHeader.transferCharacteristics; + decoder->image->matrixCoefficients = sequenceHeader.matrixCoefficients; + decoder->image->yuvRange = sequenceHeader.range; + } + } + } + + const avifProperty * av1CProp = avifPropertyArrayFind(colorProperties, "av1C"); + if (av1CProp) { + decoder->image->depth = avifCodecConfigurationBoxGetDepth(&av1CProp->u.av1C); + if (av1CProp->u.av1C.monochrome) { + decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV400; } else { - decoder->containerDepth = 0; + if (av1CProp->u.av1C.chromaSubsamplingX && av1CProp->u.av1C.chromaSubsamplingY) { + decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV420; + } else if (av1CProp->u.av1C.chromaSubsamplingX) { + decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV422; + + } else { + decoder->image->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; + } } + decoder->image->yuvChromaSamplePosition = (avifChromaSamplePosition)av1CProp->u.av1C.chromaSamplePosition; + } else { + // An av1C box is mandatory in all valid AVIF configurations. Bail out. + return AVIF_RESULT_BMFF_PARSE_FAILED; } return avifDecoderFlush(decoder); @@ -2323,14 +2454,17 @@ avifResult avifDecoderNextImage(avifDecoder * decoder) decoder->image->width = srcColor->width; decoder->image->height = srcColor->height; decoder->image->depth = srcColor->depth; + } - if (!decoder->data->cicpSet) { - decoder->data->cicpSet = AVIF_TRUE; - decoder->image->colorPrimaries = srcColor->colorPrimaries; - decoder->image->transferCharacteristics = srcColor->transferCharacteristics; - decoder->image->matrixCoefficients = srcColor->matrixCoefficients; - } +#if 0 + // This code is currently unnecessary as the CICP is always set by the end of avifDecoderParse(). + if (!decoder->data->cicpSet) { + decoder->data->cicpSet = AVIF_TRUE; + decoder->image->colorPrimaries = srcColor->colorPrimaries; + decoder->image->transferCharacteristics = srcColor->transferCharacteristics; + decoder->image->matrixCoefficients = srcColor->matrixCoefficients; } +#endif avifImageStealPlanes(decoder->image, srcColor, AVIF_PLANES_YUV); } @@ -2372,7 +2506,7 @@ avifResult avifDecoderNextImage(avifDecoder * decoder) return AVIF_RESULT_OK; } -avifResult avifDecoderNthImageTiming(avifDecoder * decoder, uint32_t frameIndex, avifImageTiming * outTiming) +avifResult avifDecoderNthImageTiming(const avifDecoder * decoder, uint32_t frameIndex, avifImageTiming * outTiming) { if (!decoder->data) { // Nothing has been parsed yet @@ -2442,7 +2576,7 @@ avifResult avifDecoderNthImage(avifDecoder * decoder, uint32_t frameIndex) return AVIF_RESULT_OK; } -avifBool avifDecoderIsKeyframe(avifDecoder * decoder, uint32_t frameIndex) +avifBool avifDecoderIsKeyframe(const avifDecoder * decoder, uint32_t frameIndex) { if ((decoder->data->tiles.count > 0) && decoder->data->tiles.tile[0].input) { if (frameIndex < decoder->data->tiles.tile[0].input->samples.count) { @@ -2452,7 +2586,7 @@ avifBool avifDecoderIsKeyframe(avifDecoder * decoder, uint32_t frameIndex) return AVIF_FALSE; } -uint32_t avifDecoderNearestKeyframe(avifDecoder * decoder, uint32_t frameIndex) +uint32_t avifDecoderNearestKeyframe(const avifDecoder * decoder, uint32_t frameIndex) { for (; frameIndex != 0; --frameIndex) { if (avifDecoderIsKeyframe(decoder, frameIndex)) { @@ -2462,7 +2596,7 @@ uint32_t avifDecoderNearestKeyframe(avifDecoder * decoder, uint32_t frameIndex) return frameIndex; } -avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, avifROData * input) +avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, const avifROData * input) { avifResult result = avifDecoderParse(decoder, input); if (result != AVIF_RESULT_OK) { @@ -2472,6 +2606,6 @@ avifResult avifDecoderRead(avifDecoder * decoder, avifImage * image, avifROData if (result != AVIF_RESULT_OK) { return result; } - avifImageCopy(image, decoder->image); + avifImageCopy(image, decoder->image, AVIF_PLANES_ALL); return AVIF_RESULT_OK; } diff --git a/chromium/third_party/libavif/src/src/reformat.c b/chromium/third_party/libavif/src/src/reformat.c index 616f6a12061..ee1906562b0 100644 --- a/chromium/third_party/libavif/src/src/reformat.c +++ b/chromium/third_party/libavif/src/src/reformat.c @@ -13,7 +13,7 @@ struct YUVBlock float v; }; -avifBool avifPrepareReformatState(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +avifBool avifPrepareReformatState(const avifImage * image, const avifRGBImage * rgb, avifReformatState * state) { if ((image->depth != 8) && (image->depth != 10) && (image->depth != 12)) { return AVIF_FALSE; @@ -122,7 +122,7 @@ static int yuvToUNorm(int chan, avifRange range, int depth, float maxChannel, fl return unorm; } -avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) +avifResult avifImageRGBToYUV(avifImage * image, const avifRGBImage * rgb) { if (!rgb->pixels) { return AVIF_RESULT_REFORMAT_FAILED; @@ -134,7 +134,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) } avifImageAllocatePlanes(image, AVIF_PLANES_YUV); - if (avifRGBFormatHasAlpha(rgb->format)) { + if (avifRGBFormatHasAlpha(rgb->format) && !rgb->ignoreAlpha) { avifImageAllocatePlanes(image, AVIF_PLANES_A); } @@ -198,7 +198,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) uint16_t * pY = (uint16_t *)&yuvPlanes[AVIF_CHAN_Y][(i * 2) + (j * yuvRowBytes[AVIF_CHAN_Y])]; *pY = (uint16_t)yuvToUNorm( AVIF_CHAN_Y, image->yuvRange, image->depth, yuvMaxChannel, yuvBlock[bI][bJ].y, state.mode); - if (!state.formatInfo.chromaShiftX && !state.formatInfo.chromaShiftY) { + if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) { // YUV444, full chroma uint16_t * pU = (uint16_t *)&yuvPlanes[AVIF_CHAN_U][(i * 2) + (j * yuvRowBytes[AVIF_CHAN_U])]; *pU = (uint16_t)yuvToUNorm( @@ -210,7 +210,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) } else { yuvPlanes[AVIF_CHAN_Y][i + (j * yuvRowBytes[AVIF_CHAN_Y])] = (uint8_t)yuvToUNorm( AVIF_CHAN_Y, image->yuvRange, image->depth, yuvMaxChannel, yuvBlock[bI][bJ].y, state.mode); - if (!state.formatInfo.chromaShiftX && !state.formatInfo.chromaShiftY) { + if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) { // YUV444, full chroma yuvPlanes[AVIF_CHAN_U][i + (j * yuvRowBytes[AVIF_CHAN_U])] = (uint8_t)yuvToUNorm( AVIF_CHAN_U, image->yuvRange, image->depth, yuvMaxChannel, yuvBlock[bI][bJ].u, state.mode); @@ -222,7 +222,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) } // Populate any subsampled channels with averages from the 2x2 block - if (state.formatInfo.chromaShiftX && state.formatInfo.chromaShiftY) { + if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) { // YUV420, average 4 samples (2x2) float sumU = 0.0f; @@ -237,8 +237,10 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) float avgU = sumU / totalSamples; float avgV = sumV / totalSamples; - int uvI = outerI >> state.formatInfo.chromaShiftX; - int uvJ = outerJ >> state.formatInfo.chromaShiftY; + const int chromaShiftX = 1; + const int chromaShiftY = 1; + int uvI = outerI >> chromaShiftX; + int uvJ = outerJ >> chromaShiftY; if (state.yuvChannelBytes > 1) { uint16_t * pU = (uint16_t *)&yuvPlanes[AVIF_CHAN_U][(uvI * 2) + (uvJ * yuvRowBytes[AVIF_CHAN_U])]; *pU = (uint16_t)yuvToUNorm(AVIF_CHAN_U, image->yuvRange, image->depth, yuvMaxChannel, avgU, state.mode); @@ -250,7 +252,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) yuvPlanes[AVIF_CHAN_V][uvI + (uvJ * yuvRowBytes[AVIF_CHAN_V])] = (uint8_t)yuvToUNorm(AVIF_CHAN_V, image->yuvRange, image->depth, yuvMaxChannel, avgV, state.mode); } - } else if (state.formatInfo.chromaShiftX && !state.formatInfo.chromaShiftY) { + } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422) { // YUV422, average 2 samples (1x2), twice for (int bJ = 0; bJ < blockH; ++bJ) { @@ -264,7 +266,8 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) float avgU = sumU / totalSamples; float avgV = sumV / totalSamples; - int uvI = outerI >> state.formatInfo.chromaShiftX; + const int chromaShiftX = 1; + int uvI = outerI >> chromaShiftX; int uvJ = outerJ + bJ; if (state.yuvChannelBytes > 1) { uint16_t * pU = (uint16_t *)&yuvPlanes[AVIF_CHAN_U][(uvI * 2) + (uvJ * yuvRowBytes[AVIF_CHAN_U])]; @@ -294,7 +297,7 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) params.dstOffsetBytes = 0; params.dstPixelBytes = state.yuvChannelBytes; - if (avifRGBFormatHasAlpha(rgb->format)) { + if (avifRGBFormatHasAlpha(rgb->format) && !rgb->ignoreAlpha) { params.srcDepth = rgb->depth; params.srcRange = AVIF_RANGE_FULL; params.srcPlane = rgb->pixels; @@ -310,83 +313,199 @@ avifResult avifImageRGBToYUV(avifImage * image, avifRGBImage * rgb) return AVIF_RESULT_OK; } -static avifResult avifImageYUVAnyToRGBAnySlow(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUVAnyToRGBAnySlow(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { + // Aliases for some state const float kr = state->kr; const float kg = state->kg; const float kb = state->kb; - const uint32_t rgbPixelBytes = state->rgbPixelBytes; const float * const unormFloatTableY = state->unormFloatTableY; const float * const unormFloatTableUV = state->unormFloatTableUV; - const uint32_t maxUVI = ((image->width + state->formatInfo.chromaShiftX) >> state->formatInfo.chromaShiftX) - 1; - const uint32_t maxUVJ = ((image->height + state->formatInfo.chromaShiftY) >> state->formatInfo.chromaShiftY) - 1; - const avifBool hasColor = (image->yuvPlanes[AVIF_CHAN_U] && image->yuvPlanes[AVIF_CHAN_V]); + const uint32_t yuvChannelBytes = state->yuvChannelBytes; + const uint32_t rgbPixelBytes = state->rgbPixelBytes; + + // Aliases for plane data + const uint8_t * yPlane = image->yuvPlanes[AVIF_CHAN_Y]; + const uint8_t * uPlane = image->yuvPlanes[AVIF_CHAN_U]; + const uint8_t * vPlane = image->yuvPlanes[AVIF_CHAN_V]; + const uint32_t yRowBytes = image->yuvRowBytes[AVIF_CHAN_Y]; + const uint32_t uRowBytes = image->yuvRowBytes[AVIF_CHAN_U]; + const uint32_t vRowBytes = image->yuvRowBytes[AVIF_CHAN_V]; + // Various observations and limits + const avifBool hasColor = (uPlane && vPlane && (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV400)); const uint16_t yuvMaxChannel = (uint16_t)((1 << image->depth) - 1); const float rgbMaxChannel = (float)((1 << rgb->depth) - 1); + for (uint32_t j = 0; j < image->height; ++j) { - const uint32_t uvJ = AVIF_MIN(j >> state->formatInfo.chromaShiftY, maxUVJ); - uint8_t * ptrY8 = &image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])]; - uint8_t * ptrU8 = NULL; - uint8_t * ptrV8 = NULL; - if (hasColor) { - ptrU8 = &image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])]; - ptrV8 = &image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])]; - } - uint16_t * ptrY16 = (uint16_t *)ptrY8; - uint16_t * ptrU16 = (uint16_t *)ptrU8; - uint16_t * ptrV16 = (uint16_t *)ptrV8; + const uint32_t uvJ = j >> state->formatInfo.chromaShiftY; + const uint8_t * ptrY8 = &yPlane[j * yRowBytes]; + const uint8_t * ptrU8 = &uPlane[(uvJ * uRowBytes)]; + const uint8_t * ptrV8 = &vPlane[(uvJ * vRowBytes)]; + const uint16_t * ptrY16 = (const uint16_t *)ptrY8; + const uint16_t * ptrU16 = (const uint16_t *)ptrU8; + const uint16_t * ptrV16 = (const uint16_t *)ptrV8; + uint8_t * ptrR = &rgb->pixels[state->rgbOffsetBytesR + (j * rgb->rowBytes)]; uint8_t * ptrG = &rgb->pixels[state->rgbOffsetBytesG + (j * rgb->rowBytes)]; uint8_t * ptrB = &rgb->pixels[state->rgbOffsetBytesB + (j * rgb->rowBytes)]; for (uint32_t i = 0; i < image->width; ++i) { - uint32_t uvI = AVIF_MIN(i >> state->formatInfo.chromaShiftX, maxUVI); - uint16_t unormY, unormU, unormV; + uint32_t uvI = i >> state->formatInfo.chromaShiftX; + float Y, Cb = 0.5f, Cr = 0.5f; - // clamp incoming data to protect against bad LUT lookups + // Calculate Y + uint16_t unormY; if (image->depth == 8) { - unormY = (uint16_t)AVIF_MIN(ptrY8[i], yuvMaxChannel); - if (hasColor) { - unormU = (uint16_t)AVIF_MIN(ptrU8[uvI], yuvMaxChannel); - unormV = (uint16_t)AVIF_MIN(ptrV8[uvI], yuvMaxChannel); - } else { - unormU = 0; - unormV = 0; - } + unormY = ptrY8[i]; } else { + // clamp incoming data to protect against bad LUT lookups unormY = AVIF_MIN(ptrY16[i], yuvMaxChannel); - if (hasColor) { - unormU = AVIF_MIN(ptrU16[uvI], yuvMaxChannel); - unormV = AVIF_MIN(ptrV16[uvI], yuvMaxChannel); + } + Y = unormFloatTableY[unormY]; + + // Calculate Cb and Cr + if (hasColor) { + if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) { + uint16_t unormU, unormV; + + if (image->depth == 8) { + unormU = ptrU8[uvI]; + unormV = ptrV8[uvI]; + } else { + // clamp incoming data to protect against bad LUT lookups + unormU = AVIF_MIN(ptrU16[uvI], yuvMaxChannel); + unormV = AVIF_MIN(ptrV16[uvI], yuvMaxChannel); + } + + Cb = unormFloatTableUV[unormU]; + Cr = unormFloatTableUV[unormV]; } else { - unormU = 0; - unormV = 0; + // Upsample to 444: + // + // * * * * + // A B + // * 1 2 * + // + // * 3 4 * + // C D + // * * * * + // + // When converting from YUV420 to RGB, for any given "high-resolution" RGB + // coordinate (1,2,3,4,*), there are up to four "low-resolution" UV samples + // (A,B,C,D) that are "nearest" to the pixel. For RGB pixel #1, A is the closest + // UV sample, B and C are "adjacent" to it on the same row and column, and D is + // the diagonal. For RGB pixel 3, C is the closest UV sample, A and D are + // adjacent, and B is the diagonal. Sometimes the adjacent pixel on the same row + // is to the left or right, and sometimes the adjacent pixel on the same column + // is up or down. For any edge or corner, there might only be only one or two + // samples nearby, so they'll be duplicated. + // + // The following code attempts to find all four nearest UV samples and put them + // in the following unormU and unormV grid as follows: + // + // unorm[0][0] = closest ( weights: bilinear: 9/16, nearest: 1 ) + // unorm[1][0] = adjacent col ( weights: bilinear: 3/16, nearest: 0 ) + // unorm[0][1] = adjacent row ( weights: bilinear: 3/16, nearest: 0 ) + // unorm[1][1] = diagonal ( weights: bilinear: 1/16, nearest: 0 ) + // + // It then weights them according to the requested upsampling set in avifRGBImage. + + uint16_t unormU[2][2], unormV[2][2]; + + // How many bytes to add to a uint8_t pointer index to get to the adjacent (lesser) sample in a given direction + int uAdjCol, vAdjCol, uAdjRow, vAdjRow; + if ((i == 0) || ((i == (image->width - 1)) && ((i % 2) != 0))) { + uAdjCol = 0; + vAdjCol = 0; + } else { + if ((i % 2) != 0) { + uAdjCol = yuvChannelBytes; + vAdjCol = yuvChannelBytes; + } else { + uAdjCol = -1 * yuvChannelBytes; + vAdjCol = -1 * yuvChannelBytes; + } + } + + // For YUV422, uvJ will always be a fresh value (always corresponds to j), so + // we'll simply duplicate the sample as if we were on the top or bottom row and + // it'll behave as plain old linear (1D) upsampling, which is all we want. + if ((j == 0) || ((j == (image->height - 1)) && ((j % 2) != 0)) || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422)) { + uAdjRow = 0; + vAdjRow = 0; + } else { + if ((j % 2) != 0) { + uAdjRow = (int)uRowBytes; + vAdjRow = (int)vRowBytes; + } else { + uAdjRow = -1 * (int)uRowBytes; + vAdjRow = -1 * (int)vRowBytes; + } + } + + if (image->depth == 8) { + unormU[0][0] = uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes)]; + unormV[0][0] = vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes)]; + unormU[1][0] = uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjCol]; + unormV[1][0] = vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjCol]; + unormU[0][1] = uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjRow]; + unormV[0][1] = vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjRow]; + unormU[1][1] = uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjCol + uAdjRow]; + unormV[1][1] = vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjCol + vAdjRow]; + } else { + unormU[0][0] = *((const uint16_t *)&uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes)]); + unormV[0][0] = *((const uint16_t *)&vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes)]); + unormU[1][0] = *((const uint16_t *)&uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjCol]); + unormV[1][0] = *((const uint16_t *)&vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjCol]); + unormU[0][1] = *((const uint16_t *)&uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjRow]); + unormV[0][1] = *((const uint16_t *)&vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjRow]); + unormU[1][1] = *((const uint16_t *)&uPlane[(uvJ * uRowBytes) + (uvI * yuvChannelBytes) + uAdjCol + uAdjRow]); + unormV[1][1] = *((const uint16_t *)&vPlane[(uvJ * vRowBytes) + (uvI * yuvChannelBytes) + vAdjCol + vAdjRow]); + + // clamp incoming data to protect against bad LUT lookups + for (int bJ = 0; bJ < 2; ++bJ) { + for (int bI = 0; bI < 2; ++bI) { + unormU[bI][bJ] = AVIF_MIN(unormU[bI][bJ], yuvMaxChannel); + unormV[bI][bJ] = AVIF_MIN(unormV[bI][bJ], yuvMaxChannel); + } + } + } + + if (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_BILINEAR) { + // Bilinear filtering with weights + Cb = (unormFloatTableUV[unormU[0][0]] * (9.0f / 16.0f)) + (unormFloatTableUV[unormU[1][0]] * (3.0f / 16.0f)) + + (unormFloatTableUV[unormU[0][1]] * (3.0f / 16.0f)) + (unormFloatTableUV[unormU[1][1]] * (1.0f / 16.0f)); + Cr = (unormFloatTableUV[unormV[0][0]] * (9.0f / 16.0f)) + (unormFloatTableUV[unormV[1][0]] * (3.0f / 16.0f)) + + (unormFloatTableUV[unormV[0][1]] * (3.0f / 16.0f)) + (unormFloatTableUV[unormV[1][1]] * (1.0f / 16.0f)); + } else { + // Nearest neighbor; ignore all UVs but the closest one + Cb = unormFloatTableUV[unormU[0][0]]; + Cr = unormFloatTableUV[unormV[0][0]]; + } } } - // Convert unorm to float - const float Y = unormFloatTableY[unormY]; - const float Cb = unormFloatTableUV[unormU]; - const float Cr = unormFloatTableUV[unormV]; - float R, G, B; - if (state->mode == AVIF_REFORMAT_MODE_IDENTITY) { - // Formulas 41,42,43 from https://www.itu.int/rec/T-REC-H.273-201612-I/en - if (hasColor) { + if (hasColor) { + if (state->mode == AVIF_REFORMAT_MODE_IDENTITY) { + // Identity (GBR): Formulas 41,42,43 from https://www.itu.int/rec/T-REC-H.273-201612-I/en G = Y; B = Cb; R = Cr; } else { - G = Y; - B = Y; - R = Y; + // Normal YUV + R = Y + (2 * (1 - kr)) * Cr; + B = Y + (2 * (1 - kb)) * Cb; + G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg); } } else { - R = Y + (2 * (1 - kr)) * Cr; - B = Y + (2 * (1 - kb)) * Cb; - G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg); + // Monochrome: just populate all channels with luma (identity mode is irrelevant) + R = Y; + G = Y; + B = Y; } + const float Rc = AVIF_CLAMP(R, 0.0f, 1.0f); const float Gc = AVIF_CLAMP(G, 0.0f, 1.0f); const float Bc = AVIF_CLAMP(B, 0.0f, 1.0f); @@ -408,7 +527,7 @@ static avifResult avifImageYUVAnyToRGBAnySlow(avifImage * image, avifRGBImage * return AVIF_RESULT_OK; } -static avifResult avifImageYUV16ToRGB16Color(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV16ToRGB16Color(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -416,13 +535,11 @@ static avifResult avifImageYUV16ToRGB16Color(avifImage * image, avifRGBImage * r const uint32_t rgbPixelBytes = state->rgbPixelBytes; const float * const unormFloatTableY = state->unormFloatTableY; const float * const unormFloatTableUV = state->unormFloatTableUV; - const uint32_t maxUVI = ((image->width + state->formatInfo.chromaShiftX) >> state->formatInfo.chromaShiftX) - 1; - const uint32_t maxUVJ = ((image->height + state->formatInfo.chromaShiftY) >> state->formatInfo.chromaShiftY) - 1; const uint16_t yuvMaxChannel = (uint16_t)((1 << image->depth) - 1); const float rgbMaxChannel = (float)((1 << rgb->depth) - 1); for (uint32_t j = 0; j < image->height; ++j) { - const uint32_t uvJ = AVIF_MIN(j >> state->formatInfo.chromaShiftY, maxUVJ); + const uint32_t uvJ = j >> state->formatInfo.chromaShiftY; const uint16_t * const ptrY = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])]; const uint16_t * const ptrU = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])]; const uint16_t * const ptrV = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])]; @@ -431,7 +548,7 @@ static avifResult avifImageYUV16ToRGB16Color(avifImage * image, avifRGBImage * r uint8_t * ptrB = &rgb->pixels[state->rgbOffsetBytesB + (j * rgb->rowBytes)]; for (uint32_t i = 0; i < image->width; ++i) { - uint32_t uvI = AVIF_MIN(i >> state->formatInfo.chromaShiftX, maxUVI); + uint32_t uvI = i >> state->formatInfo.chromaShiftX; // clamp incoming data to protect against bad LUT lookups const uint16_t unormY = AVIF_MIN(ptrY[i], yuvMaxChannel); @@ -462,7 +579,7 @@ static avifResult avifImageYUV16ToRGB16Color(avifImage * image, avifRGBImage * r return AVIF_RESULT_OK; } -static avifResult avifImageYUV16ToRGB16Mono(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV16ToRGB16Mono(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -505,7 +622,8 @@ static avifResult avifImageYUV16ToRGB16Mono(avifImage * image, avifRGBImage * rg } return AVIF_RESULT_OK; } -static avifResult avifImageYUV16ToRGB8Color(avifImage * image, avifRGBImage * rgb, avifReformatState * state) + +static avifResult avifImageYUV16ToRGB8Color(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -513,13 +631,11 @@ static avifResult avifImageYUV16ToRGB8Color(avifImage * image, avifRGBImage * rg const uint32_t rgbPixelBytes = state->rgbPixelBytes; const float * const unormFloatTableY = state->unormFloatTableY; const float * const unormFloatTableUV = state->unormFloatTableUV; - const uint32_t maxUVI = ((image->width + state->formatInfo.chromaShiftX) >> state->formatInfo.chromaShiftX) - 1; - const uint32_t maxUVJ = ((image->height + state->formatInfo.chromaShiftY) >> state->formatInfo.chromaShiftY) - 1; const uint16_t yuvMaxChannel = (uint16_t)((1 << image->depth) - 1); const float rgbMaxChannel = (float)((1 << rgb->depth) - 1); for (uint32_t j = 0; j < image->height; ++j) { - const uint32_t uvJ = AVIF_MIN(j >> state->formatInfo.chromaShiftY, maxUVJ); + const uint32_t uvJ = j >> state->formatInfo.chromaShiftY; const uint16_t * const ptrY = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])]; const uint16_t * const ptrU = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])]; const uint16_t * const ptrV = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])]; @@ -528,7 +644,7 @@ static avifResult avifImageYUV16ToRGB8Color(avifImage * image, avifRGBImage * rg uint8_t * ptrB = &rgb->pixels[state->rgbOffsetBytesB + (j * rgb->rowBytes)]; for (uint32_t i = 0; i < image->width; ++i) { - uint32_t uvI = AVIF_MIN(i >> state->formatInfo.chromaShiftX, maxUVI); + uint32_t uvI = i >> state->formatInfo.chromaShiftX; // clamp incoming data to protect against bad LUT lookups const uint16_t unormY = AVIF_MIN(ptrY[i], yuvMaxChannel); @@ -559,7 +675,7 @@ static avifResult avifImageYUV16ToRGB8Color(avifImage * image, avifRGBImage * rg return AVIF_RESULT_OK; } -static avifResult avifImageYUV16ToRGB8Mono(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV16ToRGB8Mono(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -591,9 +707,9 @@ static avifResult avifImageYUV16ToRGB8Mono(avifImage * image, avifRGBImage * rgb const float Gc = AVIF_CLAMP(G, 0.0f, 1.0f); const float Bc = AVIF_CLAMP(B, 0.0f, 1.0f); - *((uint16_t *)ptrR) = (uint16_t)(0.5f + (Rc * rgbMaxChannel)); - *((uint16_t *)ptrG) = (uint16_t)(0.5f + (Gc * rgbMaxChannel)); - *((uint16_t *)ptrB) = (uint16_t)(0.5f + (Bc * rgbMaxChannel)); + *ptrR = (uint8_t)(0.5f + (Rc * rgbMaxChannel)); + *ptrG = (uint8_t)(0.5f + (Gc * rgbMaxChannel)); + *ptrB = (uint8_t)(0.5f + (Bc * rgbMaxChannel)); ptrR += rgbPixelBytes; ptrG += rgbPixelBytes; @@ -603,7 +719,7 @@ static avifResult avifImageYUV16ToRGB8Mono(avifImage * image, avifRGBImage * rgb return AVIF_RESULT_OK; } -static avifResult avifImageYUV8ToRGB16Color(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV8ToRGB16Color(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -611,12 +727,10 @@ static avifResult avifImageYUV8ToRGB16Color(avifImage * image, avifRGBImage * rg const uint32_t rgbPixelBytes = state->rgbPixelBytes; const float * const unormFloatTableY = state->unormFloatTableY; const float * const unormFloatTableUV = state->unormFloatTableUV; - const uint32_t maxUVI = ((image->width + state->formatInfo.chromaShiftX) >> state->formatInfo.chromaShiftX) - 1; - const uint32_t maxUVJ = ((image->height + state->formatInfo.chromaShiftY) >> state->formatInfo.chromaShiftY) - 1; const float rgbMaxChannel = (float)((1 << rgb->depth) - 1); for (uint32_t j = 0; j < image->height; ++j) { - const uint32_t uvJ = AVIF_MIN(j >> state->formatInfo.chromaShiftY, maxUVJ); + const uint32_t uvJ = j >> state->formatInfo.chromaShiftY; const uint8_t * const ptrY = &image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])]; const uint8_t * const ptrU = &image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])]; const uint8_t * const ptrV = &image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])]; @@ -625,7 +739,7 @@ static avifResult avifImageYUV8ToRGB16Color(avifImage * image, avifRGBImage * rg uint8_t * ptrB = &rgb->pixels[state->rgbOffsetBytesB + (j * rgb->rowBytes)]; for (uint32_t i = 0; i < image->width; ++i) { - uint32_t uvI = AVIF_MIN(i >> state->formatInfo.chromaShiftX, maxUVI); + uint32_t uvI = i >> state->formatInfo.chromaShiftX; // Convert unorm to float (no clamp necessary, the full uint8_t range is a legal lookup) const float Y = unormFloatTableY[ptrY[i]]; @@ -651,7 +765,7 @@ static avifResult avifImageYUV8ToRGB16Color(avifImage * image, avifRGBImage * rg return AVIF_RESULT_OK; } -static avifResult avifImageYUV8ToRGB16Mono(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV8ToRGB16Mono(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -679,9 +793,9 @@ static avifResult avifImageYUV8ToRGB16Mono(avifImage * image, avifRGBImage * rgb const float Gc = AVIF_CLAMP(G, 0.0f, 1.0f); const float Bc = AVIF_CLAMP(B, 0.0f, 1.0f); - *ptrR = (uint8_t)(0.5f + (Rc * rgbMaxChannel)); - *ptrG = (uint8_t)(0.5f + (Gc * rgbMaxChannel)); - *ptrB = (uint8_t)(0.5f + (Bc * rgbMaxChannel)); + *((uint16_t *)ptrR) = (uint16_t)(0.5f + (Rc * rgbMaxChannel)); + *((uint16_t *)ptrG) = (uint16_t)(0.5f + (Gc * rgbMaxChannel)); + *((uint16_t *)ptrB) = (uint16_t)(0.5f + (Bc * rgbMaxChannel)); ptrR += rgbPixelBytes; ptrG += rgbPixelBytes; @@ -691,7 +805,7 @@ static avifResult avifImageYUV8ToRGB16Mono(avifImage * image, avifRGBImage * rgb return AVIF_RESULT_OK; } -static avifResult avifImageIdentity8ToRGB8ColorFullRange(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageIdentity8ToRGB8ColorFullRange(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const uint32_t rgbPixelBytes = state->rgbPixelBytes; for (uint32_t j = 0; j < image->height; ++j) { @@ -715,7 +829,7 @@ static avifResult avifImageIdentity8ToRGB8ColorFullRange(avifImage * image, avif return AVIF_RESULT_OK; } -static avifResult avifImageYUV8ToRGB8Color(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV8ToRGB8Color(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -723,12 +837,10 @@ static avifResult avifImageYUV8ToRGB8Color(avifImage * image, avifRGBImage * rgb const uint32_t rgbPixelBytes = state->rgbPixelBytes; const float * const unormFloatTableY = state->unormFloatTableY; const float * const unormFloatTableUV = state->unormFloatTableUV; - const uint32_t maxUVI = ((image->width + state->formatInfo.chromaShiftX) >> state->formatInfo.chromaShiftX) - 1; - const uint32_t maxUVJ = ((image->height + state->formatInfo.chromaShiftY) >> state->formatInfo.chromaShiftY) - 1; const float rgbMaxChannel = (float)((1 << rgb->depth) - 1); for (uint32_t j = 0; j < image->height; ++j) { - const uint32_t uvJ = AVIF_MIN(j >> state->formatInfo.chromaShiftY, maxUVJ); + const uint32_t uvJ = j >> state->formatInfo.chromaShiftY; const uint8_t * const ptrY = &image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])]; const uint8_t * const ptrU = &image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])]; const uint8_t * const ptrV = &image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])]; @@ -737,7 +849,7 @@ static avifResult avifImageYUV8ToRGB8Color(avifImage * image, avifRGBImage * rgb uint8_t * ptrB = &rgb->pixels[state->rgbOffsetBytesB + (j * rgb->rowBytes)]; for (uint32_t i = 0; i < image->width; ++i) { - uint32_t uvI = AVIF_MIN(i >> state->formatInfo.chromaShiftX, maxUVI); + uint32_t uvI = i >> state->formatInfo.chromaShiftX; // Convert unorm to float (no clamp necessary, the full uint8_t range is a legal lookup) const float Y = unormFloatTableY[ptrY[i]]; @@ -763,7 +875,7 @@ static avifResult avifImageYUV8ToRGB8Color(avifImage * image, avifRGBImage * rgb return AVIF_RESULT_OK; } -static avifResult avifImageYUV8ToRGB8Mono(avifImage * image, avifRGBImage * rgb, avifReformatState * state) +static avifResult avifImageYUV8ToRGB8Mono(const avifImage * image, avifRGBImage * rgb, avifReformatState * state) { const float kr = state->kr; const float kg = state->kg; @@ -803,7 +915,7 @@ static avifResult avifImageYUV8ToRGB8Mono(avifImage * image, avifRGBImage * rgb, return AVIF_RESULT_OK; } -avifResult avifImageYUVToRGB(avifImage * image, avifRGBImage * rgb) +avifResult avifImageYUVToRGB(const avifImage * image, avifRGBImage * rgb) { if (!image->yuvPlanes[AVIF_CHAN_Y]) { return AVIF_RESULT_REFORMAT_FAILED; @@ -814,7 +926,7 @@ avifResult avifImageYUVToRGB(avifImage * image, avifRGBImage * rgb) return AVIF_RESULT_REFORMAT_FAILED; } - if (avifRGBFormatHasAlpha(rgb->format)) { + if (avifRGBFormatHasAlpha(rgb->format) && !rgb->ignoreAlpha) { avifAlphaParams params; params.width = rgb->width; @@ -840,49 +952,57 @@ avifResult avifImageYUVToRGB(avifImage * image, avifRGBImage * rgb) } } - if (state.mode == AVIF_REFORMAT_MODE_IDENTITY) { - if ((image->depth == 8) && (rgb->depth == 8) && image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V] && - (image->yuvRange == AVIF_RANGE_FULL)) { - return avifImageIdentity8ToRGB8ColorFullRange(image, rgb, &state); - } - - // TODO: Add more fast paths for identity - } else { - if (image->depth > 8) { - // yuv:u16 + const avifBool hasColor = + (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V] && (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV400)); - if (rgb->depth > 8) { - // yuv:u16, rgb:u16 - - if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) { - return avifImageYUV16ToRGB16Color(image, rgb, &state); - } - return avifImageYUV16ToRGB16Mono(image, rgb, &state); - } else { - // yuv:u16, rgb:u8 + if (!hasColor || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) || (rgb->chromaUpsampling == AVIF_CHROMA_UPSAMPLING_NEAREST)) { + // None of these fast paths currently support bilinear upsampling, so avoid all of them + // unless the YUV data isn't subsampled or they explicitly requested AVIF_CHROMA_UPSAMPLING_NEAREST. - if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) { - return avifImageYUV16ToRGB8Color(image, rgb, &state); - } - return avifImageYUV16ToRGB8Mono(image, rgb, &state); + if (state.mode == AVIF_REFORMAT_MODE_IDENTITY) { + if ((image->depth == 8) && (rgb->depth == 8) && (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) && + (image->yuvRange == AVIF_RANGE_FULL)) { + return avifImageIdentity8ToRGB8ColorFullRange(image, rgb, &state); } + + // TODO: Add more fast paths for identity } else { - // yuv:u8 + if (image->depth > 8) { + // yuv:u16 + + if (rgb->depth > 8) { + // yuv:u16, rgb:u16 - if (rgb->depth > 8) { - // yuv:u8, rgb:u16 + if (hasColor) { + return avifImageYUV16ToRGB16Color(image, rgb, &state); + } + return avifImageYUV16ToRGB16Mono(image, rgb, &state); + } else { + // yuv:u16, rgb:u8 - if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) { - return avifImageYUV8ToRGB16Color(image, rgb, &state); + if (hasColor) { + return avifImageYUV16ToRGB8Color(image, rgb, &state); + } + return avifImageYUV16ToRGB8Mono(image, rgb, &state); } - return avifImageYUV8ToRGB16Mono(image, rgb, &state); } else { - // yuv:u8, rgb:u8 + // yuv:u8 + + if (rgb->depth > 8) { + // yuv:u8, rgb:u16 - if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) { - return avifImageYUV8ToRGB8Color(image, rgb, &state); + if (hasColor) { + return avifImageYUV8ToRGB16Color(image, rgb, &state); + } + return avifImageYUV8ToRGB16Mono(image, rgb, &state); + } else { + // yuv:u8, rgb:u8 + + if (hasColor) { + return avifImageYUV8ToRGB8Color(image, rgb, &state); + } + return avifImageYUV8ToRGB8Mono(image, rgb, &state); } - return avifImageYUV8ToRGB8Mono(image, rgb, &state); } } } diff --git a/chromium/third_party/libavif/src/src/stream.c b/chromium/third_party/libavif/src/src/stream.c index 0acafe9bae9..32700610e54 100644 --- a/chromium/third_party/libavif/src/src/stream.c +++ b/chromium/third_party/libavif/src/src/stream.c @@ -3,6 +3,7 @@ #include "avif/internal.h" +#include <stdint.h> #include <string.h> // --------------------------------------------------------------------------- @@ -19,17 +20,17 @@ void avifROStreamStart(avifROStream * stream, avifROData * raw) stream->offset = 0; } -avifBool avifROStreamHasBytesLeft(avifROStream * stream, size_t byteCount) +avifBool avifROStreamHasBytesLeft(const avifROStream * stream, size_t byteCount) { return (stream->offset + byteCount) <= stream->raw->size; } -size_t avifROStreamRemainingBytes(avifROStream * stream) +size_t avifROStreamRemainingBytes(const avifROStream * stream) { return stream->raw->size - stream->offset; } -size_t avifROStreamOffset(avifROStream * stream) +size_t avifROStreamOffset(const avifROStream * stream) { return stream->offset; } @@ -159,7 +160,11 @@ avifBool avifROStreamReadBoxHeader(avifROStream * stream, avifBoxHeader * header CHECK(avifROStreamSkip(stream, 16)); } - header->size = (size_t)(size - (stream->offset - startOffset)); + size_t bytesRead = stream->offset - startOffset; + if ((size < bytesRead) || ((size - bytesRead) > SIZE_MAX)) { + return AVIF_FALSE; + } + header->size = (size_t)(size - bytesRead); // Make the assumption here that this box's contents must fit in the remaining portion of the parent stream if (header->size > avifROStreamRemainingBytes(stream)) { @@ -168,7 +173,7 @@ avifBool avifROStreamReadBoxHeader(avifROStream * stream, avifBoxHeader * header return AVIF_TRUE; } -avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * version, uint8_t * flags) +avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * version, uint32_t * flags) { uint8_t versionAndFlags[4]; CHECK(avifROStreamRead(stream, versionAndFlags, 4)); @@ -176,7 +181,7 @@ avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * versio *version = versionAndFlags[0]; } if (flags) { - memcpy(flags, &versionAndFlags[1], 3); + *flags = (versionAndFlags[1] << 16) + (versionAndFlags[2] << 8) + (versionAndFlags[3] << 0); } return AVIF_TRUE; } @@ -210,7 +215,7 @@ void avifRWStreamStart(avifRWStream * stream, avifRWData * raw) stream->offset = 0; } -size_t avifRWStreamOffset(avifRWStream * stream) +size_t avifRWStreamOffset(const avifRWStream * stream) { return stream->offset; } @@ -234,7 +239,7 @@ void avifRWStreamFinishWrite(avifRWStream * stream) } } -void avifRWStreamWrite(avifRWStream * stream, const uint8_t * data, size_t size) +void avifRWStreamWrite(avifRWStream * stream, const void * data, size_t size) { if (!size) { return; @@ -247,10 +252,10 @@ void avifRWStreamWrite(avifRWStream * stream, const uint8_t * data, size_t size) void avifRWStreamWriteChars(avifRWStream * stream, const char * chars, size_t size) { - avifRWStreamWrite(stream, (const uint8_t *)chars, size); + avifRWStreamWrite(stream, chars, size); } -avifBoxMarker avifRWStreamWriteBox(avifRWStream * stream, const char * type, int version, size_t contentSize) +avifBoxMarker avifRWStreamWriteFullBox(avifRWStream * stream, const char * type, size_t contentSize, int version, uint32_t flags) { avifBoxMarker marker = stream->offset; size_t headerSize = sizeof(uint32_t) + 4 /* size of type */; @@ -260,17 +265,25 @@ avifBoxMarker avifRWStreamWriteBox(avifRWStream * stream, const char * type, int makeRoom(stream, headerSize); memset(stream->raw->data + stream->offset, 0, headerSize); + uint32_t noSize = avifHTONL((uint32_t)(headerSize + contentSize)); + memcpy(stream->raw->data + stream->offset, &noSize, sizeof(uint32_t)); + memcpy(stream->raw->data + stream->offset + 4, type, 4); if (version != -1) { stream->raw->data[stream->offset + 8] = (uint8_t)version; + stream->raw->data[stream->offset + 9] = (uint8_t)((flags >> 16) & 0xff); + stream->raw->data[stream->offset + 10] = (uint8_t)((flags >> 8) & 0xff); + stream->raw->data[stream->offset + 11] = (uint8_t)((flags >> 0) & 0xff); } - uint32_t noSize = avifNTOHL((uint32_t)(headerSize + contentSize)); - memcpy(stream->raw->data + stream->offset, &noSize, sizeof(uint32_t)); - memcpy(stream->raw->data + stream->offset + 4, type, 4); stream->offset += headerSize; return marker; } +avifBoxMarker avifRWStreamWriteBox(avifRWStream * stream, const char * type, size_t contentSize) +{ + return avifRWStreamWriteFullBox(stream, type, contentSize, -1, 0); +} + void avifRWStreamFinishBox(avifRWStream * stream, avifBoxMarker marker) { uint32_t noSize = avifNTOHL((uint32_t)(stream->offset - marker)); @@ -303,6 +316,15 @@ void avifRWStreamWriteU32(avifRWStream * stream, uint32_t v) stream->offset += size; } +void avifRWStreamWriteU64(avifRWStream * stream, uint64_t v) +{ + size_t size = sizeof(uint64_t); + v = avifHTON64(v); + makeRoom(stream, size); + memcpy(stream->raw->data + stream->offset, &v, size); + stream->offset += size; +} + void avifRWStreamWriteZeros(avifRWStream * stream, size_t byteCount) { makeRoom(stream, byteCount); diff --git a/chromium/third_party/libavif/src/src/write.c b/chromium/third_party/libavif/src/src/write.c index 37f9a9d5118..d3ac127ea7f 100644 --- a/chromium/third_party/libavif/src/src/write.c +++ b/chromium/third_party/libavif/src/src/write.c @@ -4,6 +4,7 @@ #include "avif/internal.h" #include <string.h> +#include <time.h> #define MAX_ASSOCIATIONS 16 struct ipmaArray @@ -19,17 +20,53 @@ static void ipmaPush(struct ipmaArray * ipma, uint8_t assoc, avifBool essential) ++ipma->count; } +// Used to store offsets in meta boxes which need to point at mdat offsets that +// aren't known yet. When an item's mdat payload is written, all registered fixups +// will have this now-known offset "fixed up". +typedef struct avifOffsetFixup +{ + size_t offset; +} avifOffsetFixup; +AVIF_ARRAY_DECLARE(avifOffsetFixupArray, avifOffsetFixup, fixup); + static const char alphaURN[] = URN_ALPHA0; static const size_t alphaURNSize = sizeof(alphaURN); static const char xmpContentType[] = CONTENT_TYPE_XMP; static const size_t xmpContentTypeSize = sizeof(xmpContentType); -static avifBool avifImageIsOpaque(avifImage * image); -static void fillConfigBox(avifCodec * codec, avifImage * image, avifBool alpha); +static avifBool avifImageIsOpaque(const avifImage * image); +static void fillConfigBox(avifCodec * codec, const avifImage * image, avifBool alpha); static void writeConfigBox(avifRWStream * s, avifCodecConfigurationBox * cfg); // --------------------------------------------------------------------------- +// avifCodecEncodeOutput + +avifCodecEncodeOutput * avifCodecEncodeOutputCreate(void) +{ + avifCodecEncodeOutput * encodeOutput = (avifCodecEncodeOutput *)avifAlloc(sizeof(avifCodecEncodeOutput)); + memset(encodeOutput, 0, sizeof(avifCodecEncodeOutput)); + avifArrayCreate(&encodeOutput->samples, sizeof(avifEncodeSample), 1); + return encodeOutput; +} + +void avifCodecEncodeOutputAddSample(avifCodecEncodeOutput * encodeOutput, const uint8_t * data, size_t len, avifBool sync) +{ + avifEncodeSample * sample = (avifEncodeSample *)avifArrayPushPtr(&encodeOutput->samples); + avifRWDataSet(&sample->data, data, len); + sample->sync = sync; +} + +void avifCodecEncodeOutputDestroy(avifCodecEncodeOutput * encodeOutput) +{ + for (uint32_t sampleIndex = 0; sampleIndex < encodeOutput->samples.count; ++sampleIndex) { + avifRWDataFree(&encodeOutput->samples.sample[sampleIndex].data); + } + avifArrayDestroy(&encodeOutput->samples); + avifFree(encodeOutput); +} + +// --------------------------------------------------------------------------- // avifEncoderItem // one "item" worth for encoder @@ -37,16 +74,16 @@ typedef struct avifEncoderItem { uint16_t id; uint8_t type[4]; - avifImage * image; // avifImage* to use when encoding or populating ipma for this item (unowned) - avifCodec * codec; // only present on type==av01 - avifRWData content; // OBU data on av01, metadata payload for Exif/XMP + avifCodec * codec; // only present on type==av01 + avifCodecEncodeOutput * encodeOutput; // AV1 sample data + avifRWData metadataPayload; // Exif/XMP data avifBool alpha; const char * infeName; size_t infeNameSize; const char * infeContentType; size_t infeContentTypeSize; - size_t infeOffsetOffset; // Stream offset where infe offset was written, so it can be properly set after mdat is written + avifOffsetFixupArray mdatFixups; uint16_t irefToID; // if non-zero, make an iref from this id -> irefToID const char * irefType; @@ -56,11 +93,24 @@ typedef struct avifEncoderItem AVIF_ARRAY_DECLARE(avifEncoderItemArray, avifEncoderItem, item); // --------------------------------------------------------------------------- +// avifEncoderFrame + +typedef struct avifEncoderFrame +{ + uint64_t durationInTimescales; +} avifEncoderFrame; +AVIF_ARRAY_DECLARE(avifEncoderFrameArray, avifEncoderFrame, frame); + +// --------------------------------------------------------------------------- // avifEncoderData typedef struct avifEncoderData { avifEncoderItemArray items; + avifEncoderFrameArray frames; + avifImage * imageMetadata; + avifEncoderItem * colorItem; + avifEncoderItem * alphaItem; uint16_t lastItemID; uint16_t primaryItemID; } avifEncoderData; @@ -69,7 +119,9 @@ static avifEncoderData * avifEncoderDataCreate() { avifEncoderData * data = (avifEncoderData *)avifAlloc(sizeof(avifEncoderData)); memset(data, 0, sizeof(avifEncoderData)); + data->imageMetadata = avifImageCreateEmpty(); avifArrayCreate(&data->items, sizeof(avifEncoderItem), 8); + avifArrayCreate(&data->frames, sizeof(avifEncoderFrame), 1); return data; } @@ -81,6 +133,8 @@ static avifEncoderItem * avifEncoderDataCreateItem(avifEncoderData * data, const memcpy(item->type, type, sizeof(item->type)); item->infeName = infeName; item->infeNameSize = infeNameSize; + item->encodeOutput = avifCodecEncodeOutputCreate(); + avifArrayCreate(&item->mdatFixups, sizeof(avifOffsetFixup), 4); return item; } @@ -91,12 +145,22 @@ static void avifEncoderDataDestroy(avifEncoderData * data) if (item->codec) { avifCodecDestroy(item->codec); } - avifRWDataFree(&item->content); + avifCodecEncodeOutputDestroy(item->encodeOutput); + avifRWDataFree(&item->metadataPayload); + avifArrayDestroy(&item->mdatFixups); } + avifImageDestroy(data->imageMetadata); avifArrayDestroy(&data->items); + avifArrayDestroy(&data->frames); avifFree(data); } +static void avifEncoderItemAddMdatFixup(avifEncoderItem * item, const avifRWStream * s) +{ + avifOffsetFixup * fixup = (avifOffsetFixup *)avifArrayPushPtr(&item->mdatFixups); + fixup->offset = avifRWStreamOffset(s); +} + // --------------------------------------------------------------------------- avifEncoder * avifEncoderCreate(void) @@ -112,6 +176,8 @@ avifEncoder * avifEncoderCreate(void) encoder->tileColsLog2 = 0; encoder->speed = AVIF_SPEED_DEFAULT; encoder->data = avifEncoderDataCreate(); + encoder->timescale = 1; + encoder->keyframeInterval = 0; return encoder; } @@ -121,43 +187,214 @@ void avifEncoderDestroy(avifEncoder * encoder) avifFree(encoder); } -avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData * output) +static void avifEncoderWriteColorProperties(avifRWStream * s, const avifImage * imageMetadata, struct ipmaArray * ipma, uint8_t * itemPropertyIndex) +{ + if (imageMetadata->icc.size > 0) { + avifBoxMarker colr = avifRWStreamWriteBox(s, "colr", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteChars(s, "prof", 4); // unsigned int(32) colour_type; + avifRWStreamWrite(s, imageMetadata->icc.data, imageMetadata->icc.size); + avifRWStreamFinishBox(s, colr); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_FALSE); + } + } else { + avifBoxMarker colr = avifRWStreamWriteBox(s, "colr", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteChars(s, "nclx", 4); // unsigned int(32) colour_type; + avifRWStreamWriteU16(s, (uint16_t)imageMetadata->colorPrimaries); // unsigned int(16) colour_primaries; + avifRWStreamWriteU16(s, (uint16_t)imageMetadata->transferCharacteristics); // unsigned int(16) transfer_characteristics; + avifRWStreamWriteU16(s, (uint16_t)imageMetadata->matrixCoefficients); // unsigned int(16) matrix_coefficients; + avifRWStreamWriteU8(s, (imageMetadata->yuvRange == AVIF_RANGE_FULL) ? 0x80 : 0); // unsigned int(1) full_range_flag; + // unsigned int(7) reserved = 0; + avifRWStreamFinishBox(s, colr); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_FALSE); + } + } + + // Write (Optional) Transformations + if (imageMetadata->transformFlags & AVIF_TRANSFORM_PASP) { + avifBoxMarker pasp = avifRWStreamWriteBox(s, "pasp", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteU32(s, imageMetadata->pasp.hSpacing); // unsigned int(32) hSpacing; + avifRWStreamWriteU32(s, imageMetadata->pasp.vSpacing); // unsigned int(32) vSpacing; + avifRWStreamFinishBox(s, pasp); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_FALSE); + } + } + if (imageMetadata->transformFlags & AVIF_TRANSFORM_CLAP) { + avifBoxMarker clap = avifRWStreamWriteBox(s, "clap", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteU32(s, imageMetadata->clap.widthN); // unsigned int(32) cleanApertureWidthN; + avifRWStreamWriteU32(s, imageMetadata->clap.widthD); // unsigned int(32) cleanApertureWidthD; + avifRWStreamWriteU32(s, imageMetadata->clap.heightN); // unsigned int(32) cleanApertureHeightN; + avifRWStreamWriteU32(s, imageMetadata->clap.heightD); // unsigned int(32) cleanApertureHeightD; + avifRWStreamWriteU32(s, imageMetadata->clap.horizOffN); // unsigned int(32) horizOffN; + avifRWStreamWriteU32(s, imageMetadata->clap.horizOffD); // unsigned int(32) horizOffD; + avifRWStreamWriteU32(s, imageMetadata->clap.vertOffN); // unsigned int(32) vertOffN; + avifRWStreamWriteU32(s, imageMetadata->clap.vertOffD); // unsigned int(32) vertOffD; + avifRWStreamFinishBox(s, clap); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_TRUE); + } + } + if (imageMetadata->transformFlags & AVIF_TRANSFORM_IROT) { + avifBoxMarker irot = avifRWStreamWriteBox(s, "irot", AVIF_BOX_SIZE_TBD); + uint8_t angle = imageMetadata->irot.angle & 0x3; + avifRWStreamWrite(s, &angle, 1); // unsigned int (6) reserved = 0; unsigned int (2) angle; + avifRWStreamFinishBox(s, irot); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_TRUE); + } + } + if (imageMetadata->transformFlags & AVIF_TRANSFORM_IMIR) { + avifBoxMarker imir = avifRWStreamWriteBox(s, "imir", AVIF_BOX_SIZE_TBD); + uint8_t axis = imageMetadata->imir.axis & 0x1; + avifRWStreamWrite(s, &axis, 1); // unsigned int (7) reserved = 0; unsigned int (1) axis; + avifRWStreamFinishBox(s, imir); + if (ipma && itemPropertyIndex) { + ipmaPush(ipma, ++(*itemPropertyIndex), AVIF_TRUE); + } + } +} + +// Write unassociated metadata items (EXIF, XMP) to a small meta box inside of a trak box. +// These items are implicitly associated with the track they are contained within. +static void avifEncoderWriteTrackMetaBox(avifEncoder * encoder, avifRWStream * s) +{ + // Count how many non-av01 items (such as EXIF/XMP) are being written + uint32_t metadataItemCount = 0; + for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { + avifEncoderItem * item = &encoder->data->items.item[itemIndex]; + if (memcmp(item->type, "av01", 4) != 0) { + ++metadataItemCount; + } + } + if (metadataItemCount == 0) { + // Don't even bother writing the trak meta box + return; + } + + avifBoxMarker meta = avifRWStreamWriteFullBox(s, "meta", AVIF_BOX_SIZE_TBD, 0, 0); + + avifBoxMarker hdlr = avifRWStreamWriteFullBox(s, "hdlr", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(s, 0); // unsigned int(32) pre_defined = 0; + avifRWStreamWriteChars(s, "pict", 4); // unsigned int(32) handler_type; + avifRWStreamWriteZeros(s, 12); // const unsigned int(32)[3] reserved = 0; + avifRWStreamWriteChars(s, "libavif", 8); // string name; (writing null terminator) + avifRWStreamFinishBox(s, hdlr); + + avifBoxMarker iloc = avifRWStreamWriteFullBox(s, "iloc", AVIF_BOX_SIZE_TBD, 0, 0); + uint8_t offsetSizeAndLengthSize = (4 << 4) + (4 << 0); // unsigned int(4) offset_size; + // unsigned int(4) length_size; + avifRWStreamWrite(s, &offsetSizeAndLengthSize, 1); // + avifRWStreamWriteZeros(s, 1); // unsigned int(4) base_offset_size; + // unsigned int(4) reserved; + avifRWStreamWriteU16(s, (uint16_t)metadataItemCount); // unsigned int(16) item_count; + for (uint32_t trakItemIndex = 0; trakItemIndex < encoder->data->items.count; ++trakItemIndex) { + avifEncoderItem * item = &encoder->data->items.item[trakItemIndex]; + if (memcmp(item->type, "av01", 4) == 0) { + // Skip over all non-metadata items + continue; + } + + avifRWStreamWriteU16(s, item->id); // unsigned int(16) item_ID; + avifRWStreamWriteU16(s, 0); // unsigned int(16) data_reference_index; + avifRWStreamWriteU16(s, 1); // unsigned int(16) extent_count; + avifEncoderItemAddMdatFixup(item, s); // + avifRWStreamWriteU32(s, 0 /* set later */); // unsigned int(offset_size*8) extent_offset; + avifRWStreamWriteU32(s, (uint32_t)item->metadataPayload.size); // unsigned int(length_size*8) extent_length; + } + avifRWStreamFinishBox(s, iloc); + + avifBoxMarker iinf = avifRWStreamWriteFullBox(s, "iinf", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU16(s, (uint16_t)metadataItemCount); // unsigned int(16) entry_count; + for (uint32_t trakItemIndex = 0; trakItemIndex < encoder->data->items.count; ++trakItemIndex) { + avifEncoderItem * item = &encoder->data->items.item[trakItemIndex]; + if (memcmp(item->type, "av01", 4) == 0) { + continue; + } + + avifBoxMarker infe = avifRWStreamWriteFullBox(s, "infe", AVIF_BOX_SIZE_TBD, 2, 0); + avifRWStreamWriteU16(s, item->id); // unsigned int(16) item_ID; + avifRWStreamWriteU16(s, 0); // unsigned int(16) item_protection_index; + avifRWStreamWrite(s, item->type, 4); // unsigned int(32) item_type; + avifRWStreamWriteChars(s, item->infeName, item->infeNameSize); // string item_name; (writing null terminator) + if (item->infeContentType && item->infeContentTypeSize) { // string content_type; (writing null terminator) + avifRWStreamWriteChars(s, item->infeContentType, item->infeContentTypeSize); + } + avifRWStreamFinishBox(s, infe); + } + avifRWStreamFinishBox(s, iinf); + + avifRWStreamFinishBox(s, meta); +} + +avifResult avifEncoderAddImage(avifEncoder * encoder, const avifImage * image, uint64_t durationInTimescales, uint32_t addImageFlags) { + // ----------------------------------------------------------------------- + // Validate image + if ((image->depth != 8) && (image->depth != 10) && (image->depth != 12)) { return AVIF_RESULT_UNSUPPORTED_DEPTH; } - avifResult result = AVIF_RESULT_UNKNOWN_ERROR; + if (!image->width || !image->height || !image->yuvPlanes[AVIF_CHAN_Y]) { + return AVIF_RESULT_NO_CONTENT; + } + + if (image->yuvFormat == AVIF_PIXEL_FORMAT_NONE) { + return AVIF_RESULT_NO_YUV_FORMAT_SELECTED; + } + + // ----------------------------------------------------------------------- - avifEncoderItem * colorItem = avifEncoderDataCreateItem(encoder->data, "av01", "Color", 6); - colorItem->image = image; - colorItem->codec = avifCodecCreate(encoder->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE); - if (!colorItem->codec) { - // Just bail out early, we're not surviving this function without an encoder compiled in - return AVIF_RESULT_NO_CODEC_AVAILABLE; + if (durationInTimescales == 0) { + durationInTimescales = 1; } - encoder->data->primaryItemID = colorItem->id; - avifBool imageIsOpaque = avifImageIsOpaque(image); - if (!imageIsOpaque) { - avifEncoderItem * alphaItem = avifEncoderDataCreateItem(encoder->data, "av01", "Alpha", 6); - alphaItem->image = image; - alphaItem->codec = avifCodecCreate(encoder->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE); - if (!alphaItem->codec) { + if (encoder->data->items.count == 0) { + // Make a copy of the first image's metadata (sans pixels) for future writing/validation + avifImageCopy(encoder->data->imageMetadata, image, 0); + + // Prepare all AV1 items + + encoder->data->colorItem = avifEncoderDataCreateItem(encoder->data, "av01", "Color", 6); + encoder->data->colorItem->codec = avifCodecCreate(encoder->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE); + if (!encoder->data->colorItem->codec) { + // Just bail out early, we're not surviving this function without an encoder compiled in return AVIF_RESULT_NO_CODEC_AVAILABLE; } - alphaItem->alpha = AVIF_TRUE; - alphaItem->irefToID = encoder->data->primaryItemID; - alphaItem->irefType = "auxl"; - } + encoder->data->primaryItemID = encoder->data->colorItem->id; + + avifBool needsAlpha = (image->alphaPlane != NULL); + if (addImageFlags & AVIF_ADD_IMAGE_FLAG_SINGLE) { + // If encoding a single image in which the alpha plane exists but is entirely opaque, + // simply skip writing an alpha AV1 payload entirely, as it'll be interpreted as opaque + // and is less bytes. + // + // However, if encoding an image sequence, the first frame's alpha plane being entirely + // opaque could be a false positive for removing the alpha AV1 payload, as it might simply + // be a fade out later in the sequence. This is why avifImageIsOpaque() is only called + // when encoding a single image. + + needsAlpha = !avifImageIsOpaque(image); + } + if (needsAlpha) { + encoder->data->alphaItem = avifEncoderDataCreateItem(encoder->data, "av01", "Alpha", 6); + encoder->data->alphaItem->codec = avifCodecCreate(encoder->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE); + if (!encoder->data->alphaItem->codec) { + return AVIF_RESULT_NO_CODEC_AVAILABLE; + } + encoder->data->alphaItem->alpha = AVIF_TRUE; + encoder->data->alphaItem->irefToID = encoder->data->primaryItemID; + encoder->data->alphaItem->irefType = "auxl"; + } - // ----------------------------------------------------------------------- - // Create metadata items (Exif, XMP) + // ----------------------------------------------------------------------- + // Create metadata items (Exif, XMP) - if (image->exif.size > 0) { - // Validate Exif payload (if any) and find TIFF header offset - uint32_t exifTiffHeaderOffset = 0; if (image->exif.size > 0) { + // Validate Exif payload (if any) and find TIFF header offset + uint32_t exifTiffHeaderOffset = 0; if (image->exif.size < 4) { // Can't even fit the TIFF header, something is wrong return AVIF_RESULT_INVALID_EXIF_PAYLOAD; @@ -178,91 +415,134 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData // Couldn't find the TIFF header return AVIF_RESULT_INVALID_EXIF_PAYLOAD; } + + avifEncoderItem * exifItem = avifEncoderDataCreateItem(encoder->data, "Exif", "Exif", 5); + exifItem->irefToID = encoder->data->primaryItemID; + exifItem->irefType = "cdsc"; + + avifRWDataRealloc(&exifItem->metadataPayload, sizeof(uint32_t) + image->exif.size); + exifTiffHeaderOffset = avifHTONL(exifTiffHeaderOffset); + memcpy(exifItem->metadataPayload.data, &exifTiffHeaderOffset, sizeof(uint32_t)); + memcpy(exifItem->metadataPayload.data + sizeof(uint32_t), image->exif.data, image->exif.size); } - avifEncoderItem * exifItem = avifEncoderDataCreateItem(encoder->data, "Exif", "Exif", 5); - exifItem->irefToID = encoder->data->primaryItemID; - exifItem->irefType = "cdsc"; + if (image->xmp.size > 0) { + avifEncoderItem * xmpItem = avifEncoderDataCreateItem(encoder->data, "mime", "XMP", 4); + xmpItem->irefToID = encoder->data->primaryItemID; + xmpItem->irefType = "cdsc"; - avifRWDataRealloc(&exifItem->content, sizeof(uint32_t) + image->exif.size); - exifTiffHeaderOffset = avifHTONL(exifTiffHeaderOffset); - memcpy(exifItem->content.data, &exifTiffHeaderOffset, sizeof(uint32_t)); - memcpy(exifItem->content.data + sizeof(uint32_t), image->exif.data, image->exif.size); - } + xmpItem->infeContentType = xmpContentType; + xmpItem->infeContentTypeSize = xmpContentTypeSize; + avifRWDataSet(&xmpItem->metadataPayload, image->xmp.data, image->xmp.size); + } - if (image->xmp.size > 0) { - avifEncoderItem * xmpItem = avifEncoderDataCreateItem(encoder->data, "mime", "XMP", 4); - xmpItem->irefToID = encoder->data->primaryItemID; - xmpItem->irefType = "cdsc"; + // ----------------------------------------------------------------------- + // Pre-fill config boxes based on image (codec can query/update later) - xmpItem->infeContentType = xmpContentType; - xmpItem->infeContentTypeSize = xmpContentTypeSize; - avifRWDataSet(&xmpItem->content, image->xmp.data, image->xmp.size); + for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { + avifEncoderItem * item = &encoder->data->items.item[itemIndex]; + if (item->codec) { + fillConfigBox(item->codec, image, item->alpha); + } + } + } else { + // Another frame in an image sequence + + if (encoder->data->alphaItem && !image->alphaPlane) { + // If the first image in the sequence had an alpha plane (even if fully opaque), all + // subsequence images must have alpha as well. + return AVIF_RESULT_ENCODE_ALPHA_FAILED; + } } // ----------------------------------------------------------------------- - // Pre-fill config boxes based on image (codec can query/update later) + // Encode AV1 OBUs + + if (encoder->keyframeInterval && ((encoder->data->frames.count % encoder->keyframeInterval) == 0)) { + addImageFlags |= AVIF_ADD_IMAGE_FLAG_FORCE_KEYFRAME; + } for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; - if (item->codec && item->image) { - fillConfigBox(item->codec, item->image, item->alpha); + if (item->codec) { + if (!item->codec->encodeImage(item->codec, encoder, image, item->alpha, addImageFlags, item->encodeOutput)) { + return item->alpha ? AVIF_RESULT_ENCODE_ALPHA_FAILED : AVIF_RESULT_ENCODE_COLOR_FAILED; + } } } - // ----------------------------------------------------------------------- - // Begin write stream - - avifRWStream s; - avifRWStreamStart(&s, output); - - // ----------------------------------------------------------------------- - // Validate image - - if (!image->width || !image->height || !image->yuvPlanes[AVIF_CHAN_Y]) { - result = AVIF_RESULT_NO_CONTENT; - goto writeCleanup; - } + avifEncoderFrame * frame = (avifEncoderFrame *)avifArrayPushPtr(&encoder->data->frames); + frame->durationInTimescales = durationInTimescales; + return AVIF_RESULT_OK; +} - if (image->yuvFormat == AVIF_PIXEL_FORMAT_NONE) { - result = AVIF_RESULT_NO_YUV_FORMAT_SELECTED; - goto writeCleanup; +avifResult avifEncoderFinish(avifEncoder * encoder, avifRWData * output) +{ + if (encoder->data->items.count == 0) { + return AVIF_RESULT_NO_CONTENT; } // ----------------------------------------------------------------------- - // Encode AV1 OBUs + // Finish up AV1 encoding for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; - if (item->codec && item->image) { - if (!item->codec->encodeImage(item->codec, item->image, encoder, &item->content, item->alpha)) { - result = item->alpha ? AVIF_RESULT_ENCODE_ALPHA_FAILED : AVIF_RESULT_ENCODE_COLOR_FAILED; - goto writeCleanup; + if (item->codec) { + if (!item->codec->encodeFinish(item->codec, item->encodeOutput)) { + return item->alpha ? AVIF_RESULT_ENCODE_ALPHA_FAILED : AVIF_RESULT_ENCODE_COLOR_FAILED; + } + + if (item->encodeOutput->samples.count != encoder->data->frames.count) { + return item->alpha ? AVIF_RESULT_ENCODE_ALPHA_FAILED : AVIF_RESULT_ENCODE_COLOR_FAILED; } - // TODO: rethink this if/when image grid encoding support is added + size_t obuSize = 0; + for (uint32_t sampleIndex = 0; sampleIndex < item->encodeOutput->samples.count; ++sampleIndex) { + obuSize += item->encodeOutput->samples.sample[sampleIndex].data.size; + } if (item->alpha) { - encoder->ioStats.alphaOBUSize = item->content.size; + encoder->ioStats.alphaOBUSize = obuSize; } else { - encoder->ioStats.colorOBUSize = item->content.size; + encoder->ioStats.colorOBUSize = obuSize; } } } // ----------------------------------------------------------------------- + // Begin write stream + + const avifImage * imageMetadata = encoder->data->imageMetadata; + // The epoch for creation_time and modification_time is midnight, Jan. 1, + // 1904, in UTC time. Add the number of seconds between that epoch and the + // Unix epoch. + uint64_t now = (uint64_t)time(NULL) + 2082844800; + + avifRWStream s; + avifRWStreamStart(&s, output); + + // ----------------------------------------------------------------------- // Write ftyp - avifBoxMarker ftyp = avifRWStreamWriteBox(&s, "ftyp", -1, 0); - avifRWStreamWriteChars(&s, "avif", 4); // unsigned int(32) major_brand; - avifRWStreamWriteU32(&s, 0); // unsigned int(32) minor_version; - avifRWStreamWriteChars(&s, "avif", 4); // unsigned int(32) compatible_brands[]; - avifRWStreamWriteChars(&s, "mif1", 4); // ... compatible_brands[] - avifRWStreamWriteChars(&s, "miaf", 4); // ... compatible_brands[] - if ((image->depth == 8) || (image->depth == 10)) { // - if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) { // - avifRWStreamWriteChars(&s, "MA1B", 4); // ... compatible_brands[] - } else if (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) { // - avifRWStreamWriteChars(&s, "MA1A", 4); // ... compatible_brands[] + const char * majorBrand = "avif"; + if (encoder->data->frames.count > 1) { + majorBrand = "avis"; + } + + avifBoxMarker ftyp = avifRWStreamWriteBox(&s, "ftyp", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteChars(&s, majorBrand, 4); // unsigned int(32) major_brand; + avifRWStreamWriteU32(&s, 0); // unsigned int(32) minor_version; + avifRWStreamWriteChars(&s, "avif", 4); // unsigned int(32) compatible_brands[]; + if (encoder->data->frames.count > 1) { // + avifRWStreamWriteChars(&s, "avis", 4); // ... compatible_brands[] + avifRWStreamWriteChars(&s, "msf1", 4); // ... compatible_brands[] + } // + avifRWStreamWriteChars(&s, "mif1", 4); // ... compatible_brands[] + avifRWStreamWriteChars(&s, "miaf", 4); // ... compatible_brands[] + if ((imageMetadata->depth == 8) || (imageMetadata->depth == 10)) { // + if (imageMetadata->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) { // + avifRWStreamWriteChars(&s, "MA1B", 4); // ... compatible_brands[] + } else if (imageMetadata->yuvFormat == AVIF_PIXEL_FORMAT_YUV444) { // + avifRWStreamWriteChars(&s, "MA1A", 4); // ... compatible_brands[] } } avifRWStreamFinishBox(&s, ftyp); @@ -270,12 +550,12 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData // ----------------------------------------------------------------------- // Start meta - avifBoxMarker meta = avifRWStreamWriteBox(&s, "meta", 0, 0); + avifBoxMarker meta = avifRWStreamWriteFullBox(&s, "meta", AVIF_BOX_SIZE_TBD, 0, 0); // ----------------------------------------------------------------------- // Write hdlr - avifBoxMarker hdlr = avifRWStreamWriteBox(&s, "hdlr", 0, 0); + avifBoxMarker hdlr = avifRWStreamWriteFullBox(&s, "hdlr", AVIF_BOX_SIZE_TBD, 0, 0); avifRWStreamWriteU32(&s, 0); // unsigned int(32) pre_defined = 0; avifRWStreamWriteChars(&s, "pict", 4); // unsigned int(32) handler_type; avifRWStreamWriteZeros(&s, 12); // const unsigned int(32)[3] reserved = 0; @@ -286,14 +566,14 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData // Write pitm if (encoder->data->primaryItemID != 0) { - avifRWStreamWriteBox(&s, "pitm", 0, sizeof(uint16_t)); + avifRWStreamWriteFullBox(&s, "pitm", sizeof(uint16_t), 0, 0); avifRWStreamWriteU16(&s, encoder->data->primaryItemID); // unsigned int(16) item_ID; } // ----------------------------------------------------------------------- // Write iloc - avifBoxMarker iloc = avifRWStreamWriteBox(&s, "iloc", 0, 0); + avifBoxMarker iloc = avifRWStreamWriteFullBox(&s, "iloc", AVIF_BOX_SIZE_TBD, 0, 0); uint8_t offsetSizeAndLengthSize = (4 << 4) + (4 << 0); // unsigned int(4) offset_size; // unsigned int(4) length_size; @@ -304,12 +584,26 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; - avifRWStreamWriteU16(&s, item->id); // unsigned int(16) item_ID; - avifRWStreamWriteU16(&s, 0); // unsigned int(16) data_reference_index; - avifRWStreamWriteU16(&s, 1); // unsigned int(16) extent_count; - item->infeOffsetOffset = avifRWStreamOffset(&s); // - avifRWStreamWriteU32(&s, 0 /* set later */); // unsigned int(offset_size*8) extent_offset; - avifRWStreamWriteU32(&s, (uint32_t)item->content.size); // unsigned int(length_size*8) extent_length; + + uint32_t contentSize = (uint32_t)item->metadataPayload.size; + if (item->encodeOutput->samples.count > 0) { + // This is choosing sample 0's size as there are two cases here: + // * This is a single image, in which case this is correct + // * This is an image sequence, but this file should still be a valid single-image avif, + // so there must still be a primary item pointing at a sync sample. Since the first + // frame of the image sequence is guaranteed to be a sync sample, it is chosen here. + // + // TODO: Offer the ability for a user to specify which frame in the sequence should + // become the primary item's image, and force that frame to be a keyframe. + contentSize = (uint32_t)item->encodeOutput->samples.sample[0].data.size; + } + + avifRWStreamWriteU16(&s, item->id); // unsigned int(16) item_ID; + avifRWStreamWriteU16(&s, 0); // unsigned int(16) data_reference_index; + avifRWStreamWriteU16(&s, 1); // unsigned int(16) extent_count; + avifEncoderItemAddMdatFixup(item, &s); // + avifRWStreamWriteU32(&s, 0 /* set later */); // unsigned int(offset_size*8) extent_offset; + avifRWStreamWriteU32(&s, (uint32_t)contentSize); // unsigned int(length_size*8) extent_length; } avifRWStreamFinishBox(&s, iloc); @@ -317,13 +611,13 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData // ----------------------------------------------------------------------- // Write iinf - avifBoxMarker iinf = avifRWStreamWriteBox(&s, "iinf", 0, 0); + avifBoxMarker iinf = avifRWStreamWriteFullBox(&s, "iinf", AVIF_BOX_SIZE_TBD, 0, 0); avifRWStreamWriteU16(&s, (uint16_t)encoder->data->items.count); // unsigned int(16) entry_count; for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; - avifBoxMarker infe = avifRWStreamWriteBox(&s, "infe", 2, 0); + avifBoxMarker infe = avifRWStreamWriteFullBox(&s, "infe", AVIF_BOX_SIZE_TBD, 2, 0); avifRWStreamWriteU16(&s, item->id); // unsigned int(16) item_ID; avifRWStreamWriteU16(&s, 0); // unsigned int(16) item_protection_index; avifRWStreamWrite(&s, item->type, 4); // unsigned int(32) item_type; @@ -339,47 +633,52 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData // ----------------------------------------------------------------------- // Write iref boxes + avifBoxMarker iref = 0; for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; if (item->irefToID != 0) { - avifBoxMarker iref = avifRWStreamWriteBox(&s, "iref", 0, 0); - avifBoxMarker refType = avifRWStreamWriteBox(&s, item->irefType, -1, 0); + if (!iref) { + iref = avifRWStreamWriteFullBox(&s, "iref", AVIF_BOX_SIZE_TBD, 0, 0); + } + avifBoxMarker refType = avifRWStreamWriteBox(&s, item->irefType, AVIF_BOX_SIZE_TBD); avifRWStreamWriteU16(&s, item->id); // unsigned int(16) from_item_ID; avifRWStreamWriteU16(&s, 1); // unsigned int(16) reference_count; avifRWStreamWriteU16(&s, item->irefToID); // unsigned int(16) to_item_ID; avifRWStreamFinishBox(&s, refType); - avifRWStreamFinishBox(&s, iref); } } + if (iref) { + avifRWStreamFinishBox(&s, iref); + } // ----------------------------------------------------------------------- // Write iprp -> ipco/ipma - avifBoxMarker iprp = avifRWStreamWriteBox(&s, "iprp", -1, 0); + avifBoxMarker iprp = avifRWStreamWriteBox(&s, "iprp", AVIF_BOX_SIZE_TBD); uint8_t itemPropertyIndex = 0; - avifBoxMarker ipco = avifRWStreamWriteBox(&s, "ipco", -1, 0); + avifBoxMarker ipco = avifRWStreamWriteBox(&s, "ipco", AVIF_BOX_SIZE_TBD); for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; memset(&item->ipma, 0, sizeof(item->ipma)); - if (!item->image || !item->codec) { + if (!item->codec) { // No ipma to write for this item continue; } // Properties all av01 items need - avifBoxMarker ispe = avifRWStreamWriteBox(&s, "ispe", 0, 0); - avifRWStreamWriteU32(&s, item->image->width); // unsigned int(32) image_width; - avifRWStreamWriteU32(&s, item->image->height); // unsigned int(32) image_height; + avifBoxMarker ispe = avifRWStreamWriteFullBox(&s, "ispe", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, imageMetadata->width); // unsigned int(32) image_width; + avifRWStreamWriteU32(&s, imageMetadata->height); // unsigned int(32) image_height; avifRWStreamFinishBox(&s, ispe); ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); // ipma is 1-indexed, doing this afterwards is correct - uint8_t channelCount = item->alpha ? 1 : 3; // TODO: write the correct value here when adding monochrome support - avifBoxMarker pixi = avifRWStreamWriteBox(&s, "pixi", 0, 0); + uint8_t channelCount = (item->alpha || (imageMetadata->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)) ? 1 : 3; + avifBoxMarker pixi = avifRWStreamWriteFullBox(&s, "pixi", AVIF_BOX_SIZE_TBD, 0, 0); avifRWStreamWriteU8(&s, channelCount); // unsigned int (8) num_channels; for (uint8_t chan = 0; chan < channelCount; ++chan) { - avifRWStreamWriteU8(&s, (uint8_t)item->image->depth); // unsigned int (8) bits_per_channel; + avifRWStreamWriteU8(&s, (uint8_t)imageMetadata->depth); // unsigned int (8) bits_per_channel; } avifRWStreamFinishBox(&s, pixi); ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); @@ -390,71 +689,19 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData if (item->alpha) { // Alpha specific properties - avifBoxMarker auxC = avifRWStreamWriteBox(&s, "auxC", 0, 0); + avifBoxMarker auxC = avifRWStreamWriteFullBox(&s, "auxC", AVIF_BOX_SIZE_TBD, 0, 0); avifRWStreamWriteChars(&s, alphaURN, alphaURNSize); // string aux_type; avifRWStreamFinishBox(&s, auxC); ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); } else { // Color specific properties - if (item->image->icc.data && (item->image->icc.size > 0)) { - avifBoxMarker colr = avifRWStreamWriteBox(&s, "colr", -1, 0); - avifRWStreamWriteChars(&s, "prof", 4); // unsigned int(32) colour_type; - avifRWStreamWrite(&s, item->image->icc.data, item->image->icc.size); - avifRWStreamFinishBox(&s, colr); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); - } else { - avifBoxMarker colr = avifRWStreamWriteBox(&s, "colr", -1, 0); - avifRWStreamWriteChars(&s, "nclx", 4); // unsigned int(32) colour_type; - avifRWStreamWriteU16(&s, (uint16_t)item->image->colorPrimaries); // unsigned int(16) colour_primaries; - avifRWStreamWriteU16(&s, (uint16_t)item->image->transferCharacteristics); // unsigned int(16) transfer_characteristics; - avifRWStreamWriteU16(&s, (uint16_t)item->image->matrixCoefficients); // unsigned int(16) matrix_coefficients; - avifRWStreamWriteU8(&s, item->image->yuvRange & 0x80); // unsigned int(1) full_range_flag; - // unsigned int(7) reserved = 0; - avifRWStreamFinishBox(&s, colr); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); - } - - // Write (Optional) Transformations - if (item->image->transformFlags & AVIF_TRANSFORM_PASP) { - avifBoxMarker pasp = avifRWStreamWriteBox(&s, "pasp", -1, 0); - avifRWStreamWriteU32(&s, item->image->pasp.hSpacing); // unsigned int(32) hSpacing; - avifRWStreamWriteU32(&s, item->image->pasp.vSpacing); // unsigned int(32) vSpacing; - avifRWStreamFinishBox(&s, pasp); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_FALSE); - } - if (item->image->transformFlags & AVIF_TRANSFORM_CLAP) { - avifBoxMarker clap = avifRWStreamWriteBox(&s, "clap", -1, 0); - avifRWStreamWriteU32(&s, item->image->clap.widthN); // unsigned int(32) cleanApertureWidthN; - avifRWStreamWriteU32(&s, item->image->clap.widthD); // unsigned int(32) cleanApertureWidthD; - avifRWStreamWriteU32(&s, item->image->clap.heightN); // unsigned int(32) cleanApertureHeightN; - avifRWStreamWriteU32(&s, item->image->clap.heightD); // unsigned int(32) cleanApertureHeightD; - avifRWStreamWriteU32(&s, item->image->clap.horizOffN); // unsigned int(32) horizOffN; - avifRWStreamWriteU32(&s, item->image->clap.horizOffD); // unsigned int(32) horizOffD; - avifRWStreamWriteU32(&s, item->image->clap.vertOffN); // unsigned int(32) vertOffN; - avifRWStreamWriteU32(&s, item->image->clap.vertOffD); // unsigned int(32) vertOffD; - avifRWStreamFinishBox(&s, clap); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_TRUE); - } - if (item->image->transformFlags & AVIF_TRANSFORM_IROT) { - avifBoxMarker irot = avifRWStreamWriteBox(&s, "irot", -1, 0); - uint8_t angle = item->image->irot.angle & 0x3; - avifRWStreamWrite(&s, &angle, 1); // unsigned int (6) reserved = 0; unsigned int (2) angle; - avifRWStreamFinishBox(&s, irot); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_TRUE); - } - if (item->image->transformFlags & AVIF_TRANSFORM_IMIR) { - avifBoxMarker imir = avifRWStreamWriteBox(&s, "imir", -1, 0); - uint8_t axis = item->image->imir.axis & 0x1; - avifRWStreamWrite(&s, &axis, 1); // unsigned int (7) reserved = 0; unsigned int (1) axis; - avifRWStreamFinishBox(&s, imir); - ipmaPush(&item->ipma, ++itemPropertyIndex, AVIF_TRUE); - } + avifEncoderWriteColorProperties(&s, imageMetadata, &item->ipma, &itemPropertyIndex); } } avifRWStreamFinishBox(&s, ipco); - avifBoxMarker ipma = avifRWStreamWriteBox(&s, "ipma", 0, 0); + avifBoxMarker ipma = avifRWStreamWriteFullBox(&s, "ipma", AVIF_BOX_SIZE_TBD, 0, 0); { int ipmaCount = 0; for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { @@ -492,22 +739,236 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData avifRWStreamFinishBox(&s, meta); // ----------------------------------------------------------------------- + // Write tracks (if an image sequence) + + if (encoder->data->frames.count > 1) { + static const uint32_t unityMatrix[9] = { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 }; + + uint64_t durationInTimescales = 0; + for (uint32_t frameIndex = 0; frameIndex < encoder->data->frames.count; ++frameIndex) { + const avifEncoderFrame * frame = &encoder->data->frames.frame[frameIndex]; + durationInTimescales += frame->durationInTimescales; + } + + // ------------------------------------------------------------------- + // Start moov + + avifBoxMarker moov = avifRWStreamWriteBox(&s, "moov", AVIF_BOX_SIZE_TBD); + + avifBoxMarker mvhd = avifRWStreamWriteFullBox(&s, "mvhd", AVIF_BOX_SIZE_TBD, 1, 0); + avifRWStreamWriteU64(&s, now); // unsigned int(64) creation_time; + avifRWStreamWriteU64(&s, now); // unsigned int(64) modification_time; + avifRWStreamWriteU32(&s, (uint32_t)encoder->timescale); // unsigned int(32) timescale; + avifRWStreamWriteU64(&s, durationInTimescales); // unsigned int(64) duration; + avifRWStreamWriteU32(&s, 0x00010000); // template int(32) rate = 0x00010000; // typically 1.0 + avifRWStreamWriteU16(&s, 0x0100); // template int(16) volume = 0x0100; // typically, full volume + avifRWStreamWriteU16(&s, 0); // const bit(16) reserved = 0; + avifRWStreamWriteZeros(&s, 8); // const unsigned int(32)[2] reserved = 0; + avifRWStreamWrite(&s, unityMatrix, sizeof(unityMatrix)); + avifRWStreamWriteZeros(&s, 24); // bit(32)[6] pre_defined = 0; + avifRWStreamWriteU32(&s, encoder->data->items.count); // unsigned int(32) next_track_ID; + avifRWStreamFinishBox(&s, mvhd); + + // ------------------------------------------------------------------- + // Write tracks + + for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { + avifEncoderItem * item = &encoder->data->items.item[itemIndex]; + if (item->encodeOutput->samples.count == 0) { + continue; + } + + uint32_t syncSamplesCount = 0; + for (uint32_t sampleIndex = 0; sampleIndex < item->encodeOutput->samples.count; ++sampleIndex) { + avifEncodeSample * sample = &item->encodeOutput->samples.sample[sampleIndex]; + if (sample->sync) { + ++syncSamplesCount; + } + } + + avifBoxMarker trak = avifRWStreamWriteBox(&s, "trak", AVIF_BOX_SIZE_TBD); + + avifBoxMarker tkhd = avifRWStreamWriteFullBox(&s, "tkhd", AVIF_BOX_SIZE_TBD, 1, 1); + avifRWStreamWriteU64(&s, now); // unsigned int(64) creation_time; + avifRWStreamWriteU64(&s, now); // unsigned int(64) modification_time; + avifRWStreamWriteU32(&s, itemIndex + 1); // unsigned int(32) track_ID; + avifRWStreamWriteU32(&s, 0); // const unsigned int(32) reserved = 0; + avifRWStreamWriteU64(&s, durationInTimescales); // unsigned int(64) duration; + avifRWStreamWriteZeros(&s, sizeof(uint32_t) * 2); // const unsigned int(32)[2] reserved = 0; + avifRWStreamWriteU16(&s, 0); // template int(16) layer = 0; + avifRWStreamWriteU16(&s, 0); // template int(16) alternate_group = 0; + avifRWStreamWriteU16(&s, 0); // template int(16) volume = {if track_is_audio 0x0100 else 0}; + avifRWStreamWriteU16(&s, 0); // const unsigned int(16) reserved = 0; + avifRWStreamWrite(&s, unityMatrix, sizeof(unityMatrix)); // template int(32)[9] matrix= // { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 }; + avifRWStreamWriteU32(&s, imageMetadata->width << 16); // unsigned int(32) width; + avifRWStreamWriteU32(&s, imageMetadata->height << 16); // unsigned int(32) height; + avifRWStreamFinishBox(&s, tkhd); + + if (item->irefToID != 0) { + avifBoxMarker tref = avifRWStreamWriteBox(&s, "tref", AVIF_BOX_SIZE_TBD); + avifBoxMarker refType = avifRWStreamWriteBox(&s, item->irefType, AVIF_BOX_SIZE_TBD); + avifRWStreamWriteU32(&s, (uint32_t)item->irefToID); + avifRWStreamFinishBox(&s, refType); + avifRWStreamFinishBox(&s, tref); + } + + if (!item->alpha) { + avifEncoderWriteTrackMetaBox(encoder, &s); + } + + avifBoxMarker mdia = avifRWStreamWriteBox(&s, "mdia", AVIF_BOX_SIZE_TBD); + + avifBoxMarker mdhd = avifRWStreamWriteFullBox(&s, "mdhd", AVIF_BOX_SIZE_TBD, 1, 0); + avifRWStreamWriteU64(&s, now); // unsigned int(64) creation_time; + avifRWStreamWriteU64(&s, now); // unsigned int(64) modification_time; + avifRWStreamWriteU32(&s, (uint32_t)encoder->timescale); // unsigned int(32) timescale; + avifRWStreamWriteU64(&s, durationInTimescales); // unsigned int(64) duration; + avifRWStreamWriteU16(&s, 21956); // bit(1) pad = 0; unsigned int(5)[3] language; ("und") + avifRWStreamWriteU16(&s, 0); // unsigned int(16) pre_defined = 0; + avifRWStreamFinishBox(&s, mdhd); + + avifBoxMarker hdlrTrak = avifRWStreamWriteFullBox(&s, "hdlr", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 0); // unsigned int(32) pre_defined = 0; + avifRWStreamWriteChars(&s, "pict", 4); // unsigned int(32) handler_type; + avifRWStreamWriteZeros(&s, 12); // const unsigned int(32)[3] reserved = 0; + avifRWStreamWriteChars(&s, "libavif", 8); // string name; (writing null terminator) + avifRWStreamFinishBox(&s, hdlrTrak); + + avifBoxMarker minf = avifRWStreamWriteBox(&s, "minf", AVIF_BOX_SIZE_TBD); + + avifBoxMarker vmhd = avifRWStreamWriteFullBox(&s, "vmhd", AVIF_BOX_SIZE_TBD, 0, 1); + avifRWStreamWriteU16(&s, 0); // template unsigned int(16) graphicsmode = 0; (copy over the existing image) + avifRWStreamWriteZeros(&s, 6); // template unsigned int(16)[3] opcolor = {0, 0, 0}; + avifRWStreamFinishBox(&s, vmhd); + + avifBoxMarker dinf = avifRWStreamWriteBox(&s, "dinf", AVIF_BOX_SIZE_TBD); + avifBoxMarker dref = avifRWStreamWriteFullBox(&s, "dref", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 1); // unsigned int(32) entry_count; + avifRWStreamWriteFullBox(&s, "url ", 0, 0, 1); // flags:1 means data is in this file + avifRWStreamFinishBox(&s, dref); + avifRWStreamFinishBox(&s, dinf); + + avifBoxMarker stbl = avifRWStreamWriteBox(&s, "stbl", AVIF_BOX_SIZE_TBD); + + avifBoxMarker stco = avifRWStreamWriteFullBox(&s, "stco", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 1); // unsigned int(32) entry_count; + avifEncoderItemAddMdatFixup(item, &s); // + avifRWStreamWriteU32(&s, 1); // unsigned int(32) chunk_offset; (set later) + avifRWStreamFinishBox(&s, stco); + + avifBoxMarker stsc = avifRWStreamWriteFullBox(&s, "stsc", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 1); // unsigned int(32) entry_count; + avifRWStreamWriteU32(&s, 1); // unsigned int(32) first_chunk; + avifRWStreamWriteU32(&s, item->encodeOutput->samples.count); // unsigned int(32) samples_per_chunk; + avifRWStreamWriteU32(&s, 1); // unsigned int(32) sample_description_index; + avifRWStreamFinishBox(&s, stsc); + + avifBoxMarker stsz = avifRWStreamWriteFullBox(&s, "stsz", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 0); // unsigned int(32) sample_size; + avifRWStreamWriteU32(&s, item->encodeOutput->samples.count); // unsigned int(32) sample_count; + for (uint32_t sampleIndex = 0; sampleIndex < item->encodeOutput->samples.count; ++sampleIndex) { + avifEncodeSample * sample = &item->encodeOutput->samples.sample[sampleIndex]; + avifRWStreamWriteU32(&s, (uint32_t)sample->data.size); // unsigned int(32) entry_size; + } + avifRWStreamFinishBox(&s, stsz); + + avifBoxMarker stss = avifRWStreamWriteFullBox(&s, "stss", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, syncSamplesCount); // unsigned int(32) entry_count; + for (uint32_t sampleIndex = 0; sampleIndex < item->encodeOutput->samples.count; ++sampleIndex) { + avifEncodeSample * sample = &item->encodeOutput->samples.sample[sampleIndex]; + if (sample->sync) { + avifRWStreamWriteU32(&s, sampleIndex + 1); // unsigned int(32) sample_number; + } + } + avifRWStreamFinishBox(&s, stss); + + avifBoxMarker stts = avifRWStreamWriteFullBox(&s, "stts", AVIF_BOX_SIZE_TBD, 0, 0); + size_t sttsEntryCountOffset = avifRWStreamOffset(&s); + uint32_t sttsEntryCount = 0; + avifRWStreamWriteU32(&s, 0); // unsigned int(32) entry_count; + for (uint32_t sampleCount = 0, frameIndex = 0; frameIndex < encoder->data->frames.count; ++frameIndex) { + avifEncoderFrame * frame = &encoder->data->frames.frame[frameIndex]; + ++sampleCount; + if (frameIndex < (encoder->data->frames.count - 1)) { + avifEncoderFrame * nextFrame = &encoder->data->frames.frame[frameIndex + 1]; + if (frame->durationInTimescales == nextFrame->durationInTimescales) { + continue; + } + } + avifRWStreamWriteU32(&s, sampleCount); // unsigned int(32) sample_count; + avifRWStreamWriteU32(&s, (uint32_t)frame->durationInTimescales); // unsigned int(32) sample_delta; + sampleCount = 0; + ++sttsEntryCount; + } + size_t prevOffset = avifRWStreamOffset(&s); + avifRWStreamSetOffset(&s, sttsEntryCountOffset); + avifRWStreamWriteU32(&s, sttsEntryCount); + avifRWStreamSetOffset(&s, prevOffset); + avifRWStreamFinishBox(&s, stts); + + avifBoxMarker stsd = avifRWStreamWriteFullBox(&s, "stsd", AVIF_BOX_SIZE_TBD, 0, 0); + avifRWStreamWriteU32(&s, 1); // unsigned int(32) entry_count; + avifBoxMarker av01 = avifRWStreamWriteBox(&s, "av01", AVIF_BOX_SIZE_TBD); + avifRWStreamWriteZeros(&s, 6); // const unsigned int(8)[6] reserved = 0; + avifRWStreamWriteU16(&s, 1); // unsigned int(16) data_reference_index; + avifRWStreamWriteU16(&s, 0); // unsigned int(16) pre_defined = 0; + avifRWStreamWriteU16(&s, 0); // const unsigned int(16) reserved = 0; + avifRWStreamWriteZeros(&s, sizeof(uint32_t) * 3); // unsigned int(32)[3] pre_defined = 0; + avifRWStreamWriteU16(&s, (uint16_t)imageMetadata->width); // unsigned int(16) width; + avifRWStreamWriteU16(&s, (uint16_t)imageMetadata->height); // unsigned int(16) height; + avifRWStreamWriteU32(&s, 0x00480000); // template unsigned int(32) horizresolution + avifRWStreamWriteU32(&s, 0x00480000); // template unsigned int(32) vertresolution + avifRWStreamWriteU32(&s, 0); // const unsigned int(32) reserved = 0; + avifRWStreamWriteU16(&s, 1); // template unsigned int(16) frame_count = 1; + avifRWStreamWriteChars(&s, "\012AOM Coding", 11); // string[32] compressorname; + avifRWStreamWriteZeros(&s, 32 - 11); // + avifRWStreamWriteU16(&s, 0x0018); // template unsigned int(16) depth = 0x0018; + avifRWStreamWriteU16(&s, (uint16_t)0xffff); // int(16) pre_defined = -1; + writeConfigBox(&s, &item->codec->configBox); + if (!item->alpha) { + avifEncoderWriteColorProperties(&s, imageMetadata, NULL, NULL); + } + avifRWStreamFinishBox(&s, av01); + avifRWStreamFinishBox(&s, stsd); + + avifRWStreamFinishBox(&s, stbl); + + avifRWStreamFinishBox(&s, minf); + avifRWStreamFinishBox(&s, mdia); + avifRWStreamFinishBox(&s, trak); + } + + // ------------------------------------------------------------------- + // Finish moov box + + avifRWStreamFinishBox(&s, moov); + } + + // ----------------------------------------------------------------------- // Write mdat - avifBoxMarker mdat = avifRWStreamWriteBox(&s, "mdat", -1, 0); + avifBoxMarker mdat = avifRWStreamWriteBox(&s, "mdat", AVIF_BOX_SIZE_TBD); for (uint32_t itemIndex = 0; itemIndex < encoder->data->items.count; ++itemIndex) { avifEncoderItem * item = &encoder->data->items.item[itemIndex]; - if (item->content.size == 0) { + if ((item->metadataPayload.size == 0) && (item->encodeOutput->samples.count == 0)) { continue; } - uint32_t infeOffset = (uint32_t)s.offset; - avifRWStreamWrite(&s, item->content.data, item->content.size); + uint32_t chunkOffset = (uint32_t)avifRWStreamOffset(&s); + if (item->encodeOutput->samples.count > 0) { + for (uint32_t sampleIndex = 0; sampleIndex < item->encodeOutput->samples.count; ++sampleIndex) { + avifEncodeSample * sample = &item->encodeOutput->samples.sample[sampleIndex]; + avifRWStreamWrite(&s, sample->data.data, sample->data.size); + } + } else { + avifRWStreamWrite(&s, item->metadataPayload.data, item->metadataPayload.size); + } - if (item->infeOffsetOffset != 0) { + for (uint32_t fixupIndex = 0; fixupIndex < item->mdatFixups.count; ++fixupIndex) { + avifOffsetFixup * fixup = &item->mdatFixups.fixup[fixupIndex]; size_t prevOffset = avifRWStreamOffset(&s); - avifRWStreamSetOffset(&s, item->infeOffsetOffset); - avifRWStreamWriteU32(&s, infeOffset); + avifRWStreamSetOffset(&s, fixup->offset); + avifRWStreamWriteU32(&s, chunkOffset); avifRWStreamSetOffset(&s, prevOffset); } } @@ -518,16 +979,19 @@ avifResult avifEncoderWrite(avifEncoder * encoder, avifImage * image, avifRWData avifRWStreamFinishWrite(&s); - // ----------------------------------------------------------------------- - // Set result and cleanup - - result = AVIF_RESULT_OK; + return AVIF_RESULT_OK; +} -writeCleanup: - return result; +avifResult avifEncoderWrite(avifEncoder * encoder, const avifImage * image, avifRWData * output) +{ + avifResult addImageResult = avifEncoderAddImage(encoder, image, 1, AVIF_ADD_IMAGE_FLAG_SINGLE); + if (addImageResult != AVIF_RESULT_OK) { + return addImageResult; + } + return avifEncoderFinish(encoder, output); } -static avifBool avifImageIsOpaque(avifImage * image) +static avifBool avifImageIsOpaque(const avifImage * image) { if (!image->alphaPlane) { return AVIF_TRUE; @@ -555,7 +1019,7 @@ static avifBool avifImageIsOpaque(avifImage * image) return AVIF_TRUE; } -static void fillConfigBox(avifCodec * codec, avifImage * image, avifBool alpha) +static void fillConfigBox(avifCodec * codec, const avifImage * image, avifBool alpha) { avifPixelFormatInfo formatInfo; avifGetPixelFormatInfo(image->yuvFormat, &formatInfo); @@ -584,7 +1048,7 @@ static void fillConfigBox(avifCodec * codec, avifImage * image, avifBool alpha) case AVIF_PIXEL_FORMAT_YUV420: seqProfile = 0; break; - case AVIF_PIXEL_FORMAT_YV12: + case AVIF_PIXEL_FORMAT_YUV400: seqProfile = 0; break; case AVIF_PIXEL_FORMAT_NONE: @@ -605,23 +1069,17 @@ static void fillConfigBox(avifCodec * codec, avifImage * image, avifBool alpha) codec->configBox.seqProfile = seqProfile; codec->configBox.seqLevelIdx0 = seqLevelIdx0; codec->configBox.seqTier0 = 0; - codec->configBox.highBitdepth = (image->depth > 8) ? 1 : 0; - codec->configBox.twelveBit = (image->depth == 12) ? 1 : 0; - codec->configBox.monochrome = alpha ? 1 : 0; + codec->configBox.highBitdepth = (image->depth > 8); + codec->configBox.twelveBit = (image->depth == 12); + codec->configBox.monochrome = (alpha || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400)); codec->configBox.chromaSubsamplingX = (uint8_t)formatInfo.chromaShiftX; codec->configBox.chromaSubsamplingY = (uint8_t)formatInfo.chromaShiftY; - - // TODO: choose the correct one from below: - // * 0 - CSP_UNKNOWN Unknown (in this case the source video transfer function must be signaled outside the AV1 bitstream) - // * 1 - CSP_VERTICAL Horizontally co-located with (0, 0) luma sample, vertical position in the middle between two luma samples - // * 2 - CSP_COLOCATED co-located with (0, 0) luma sample - // * 3 - CSP_RESERVED - codec->configBox.chromaSamplePosition = 0; + codec->configBox.chromaSamplePosition = image->yuvChromaSamplePosition; } static void writeConfigBox(avifRWStream * s, avifCodecConfigurationBox * cfg) { - avifBoxMarker av1C = avifRWStreamWriteBox(s, "av1C", -1, 0); + avifBoxMarker av1C = avifRWStreamWriteBox(s, "av1C", AVIF_BOX_SIZE_TBD); // unsigned int (1) marker = 1; // unsigned int (7) version = 1; |