| #ifndef WUFFS_INCLUDE_GUARD | |
| #define WUFFS_INCLUDE_GUARD | |
| // Wuffs ships as a "single file C library" or "header file library" as per | |
| // https://github.com/nothings/stb/blob/master/docs/stb_howto.txt | |
| // | |
| // To use that single file as a "foo.c"-like implementation, instead of a | |
| // "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or | |
| // compiling it. | |
| // Wuffs' C code is generated automatically, not hand-written. These warnings' | |
| // costs outweigh the benefits. | |
| // | |
| // The "elif defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #if defined(__GNUC__) | |
| #pragma GCC diagnostic push | |
| #pragma GCC diagnostic ignored "-Wimplicit-fallthrough" | |
| #pragma GCC diagnostic ignored "-Wmissing-field-initializers" | |
| #pragma GCC diagnostic ignored "-Wunreachable-code" | |
| #pragma GCC diagnostic ignored "-Wunused-function" | |
| #pragma GCC diagnostic ignored "-Wunused-parameter" | |
| #if defined(__cplusplus) | |
| #pragma GCC diagnostic ignored "-Wold-style-cast" | |
| #endif | |
| #elif defined(__clang__) | |
| #pragma clang diagnostic push | |
| #pragma clang diagnostic ignored "-Wimplicit-fallthrough" | |
| #pragma clang diagnostic ignored "-Wmissing-field-initializers" | |
| #pragma clang diagnostic ignored "-Wunreachable-code" | |
| #pragma clang diagnostic ignored "-Wunused-function" | |
| #pragma clang diagnostic ignored "-Wunused-parameter" | |
| #if defined(__cplusplus) | |
| #pragma clang diagnostic ignored "-Wold-style-cast" | |
| #endif | |
| #endif | |
| // Copyright 2017 The Wuffs Authors. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // https://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include <stdbool.h> | |
| #include <stdint.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #ifdef __cplusplus | |
| #if (__cplusplus >= 201103L) || defined(_MSC_VER) | |
| #include <memory> | |
| #define WUFFS_BASE__HAVE_EQ_DELETE | |
| #define WUFFS_BASE__HAVE_UNIQUE_PTR | |
| // The "defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #elif defined(__GNUC__) || defined(__clang__) | |
| #warning "Wuffs' C++ code expects -std=c++11 or later" | |
| #endif | |
| extern "C" { | |
| #endif | |
| // ---------------- Version | |
| // WUFFS_VERSION is the major.minor.patch version, as per https://semver.org/, | |
| // as a uint64_t. The major number is the high 32 bits. The minor number is the | |
| // middle 16 bits. The patch number is the low 16 bits. The pre-release label | |
| // and build metadata are part of the string representation (such as | |
| // "1.2.3-beta+456.20181231") but not the uint64_t representation. | |
| // | |
| // WUFFS_VERSION_PRE_RELEASE_LABEL (such as "", "beta" or "rc.1") being | |
| // non-empty denotes a developer preview, not a release version, and has no | |
| // backwards or forwards compatibility guarantees. | |
| // | |
| // WUFFS_VERSION_BUILD_METADATA_XXX, if non-zero, are the number of commits and | |
| // the last commit date in the repository used to build this library. Within | |
| // each major.minor branch, the commit count should increase monotonically. | |
| // | |
| // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision | |
| // 3ff4bf46746fff230d4704f8c5a35a1665ddbd56 committed on 2022-06-03. | |
| #define WUFFS_VERSION 0x000030000 | |
| #define WUFFS_VERSION_MAJOR 0 | |
| #define WUFFS_VERSION_MINOR 3 | |
| #define WUFFS_VERSION_PATCH 0 | |
| #define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.15" | |
| #define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3345 | |
| #define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20220603 | |
| #define WUFFS_VERSION_STRING "0.3.0-beta.15+3345.20220603" | |
| // ---------------- Configuration | |
| // Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU | |
| // architecture, such as SSE SIMD for the x86 CPU family. | |
| #if defined(WUFFS_CONFIG__AVOID_CPU_ARCH) // (#if-chain ref AVOID_CPU_ARCH_0) | |
| // No-op. | |
| #else // (#if-chain ref AVOID_CPU_ARCH_0) | |
| // The "defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #if defined(__GNUC__) || defined(__clang__) | |
| #define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg) __attribute__((target(arg))) | |
| #else | |
| #define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg) | |
| #endif // defined(__GNUC__) || defined(__clang__) | |
| #if defined(__GNUC__) // (#if-chain ref AVOID_CPU_ARCH_1) | |
| // To simplify Wuffs code, "cpu_arch >= arm_xxx" requires xxx but also | |
| // unaligned little-endian load/stores. | |
| #if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \ | |
| defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) | |
| // Not all gcc versions define __ARM_ACLE, even if they support crc32 | |
| // intrinsics. Look for __ARM_FEATURE_CRC32 instead. | |
| #if defined(__ARM_FEATURE_CRC32) | |
| #include <arm_acle.h> | |
| #define WUFFS_BASE__CPU_ARCH__ARM_CRC32 | |
| #endif // defined(__ARM_FEATURE_CRC32) | |
| #if defined(__ARM_NEON) | |
| #include <arm_neon.h> | |
| #define WUFFS_BASE__CPU_ARCH__ARM_NEON | |
| #endif // defined(__ARM_NEON) | |
| #endif // defined(__ARM_FEATURE_UNALIGNED) etc | |
| // Similarly, "cpu_arch >= x86_sse42" requires SSE4.2 but also PCLMUL and | |
| // POPCNT. This is checked at runtime via cpuid, not at compile time. | |
| // | |
| // Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2. | |
| #if defined(__i386__) || defined(__x86_64__) | |
| #if !defined(__native_client__) | |
| #include <cpuid.h> | |
| #include <x86intrin.h> | |
| // X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously). | |
| #define WUFFS_BASE__CPU_ARCH__X86_FAMILY | |
| #endif // !defined(__native_client__) | |
| #endif // defined(__i386__) || defined(__x86_64__) | |
| #elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1) | |
| #if defined(_M_IX86) || defined(_M_X64) | |
| #if defined(__AVX__) || defined(__clang__) | |
| // We need <intrin.h> for the __cpuid function. | |
| #include <intrin.h> | |
| // That's not enough for X64 SIMD, with clang-cl, if we want to use | |
| // "__attribute__((target(arg)))" without e.g. "/arch:AVX". | |
| // | |
| // Some web pages suggest that <immintrin.h> is all you need, as it pulls in | |
| // the earlier SIMD families like SSE4.2, but that doesn't seem to work in | |
| // practice, possibly for the same reason that just <intrin.h> doesn't work. | |
| #include <immintrin.h> // AVX, AVX2, FMA, POPCNT | |
| #include <nmmintrin.h> // SSE4.2 | |
| #include <wmmintrin.h> // AES, PCLMUL | |
| // X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously). | |
| #define WUFFS_BASE__CPU_ARCH__X86_FAMILY | |
| #else // defined(__AVX__) || defined(__clang__) | |
| // clang-cl (which defines both __clang__ and _MSC_VER) supports | |
| // "__attribute__((target(arg)))". | |
| // | |
| // For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time | |
| // property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not | |
| // of individual functions (that can be conditionally selected at runtime). | |
| #pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance") | |
| #endif // defined(__AVX__) || defined(__clang__) | |
| #endif // defined(_M_IX86) || defined(_M_X64) | |
| #endif // (#if-chain ref AVOID_CPU_ARCH_1) | |
| #endif // (#if-chain ref AVOID_CPU_ARCH_0) | |
| // -------- | |
| // Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION) | |
| // to make all of Wuffs' functions have static storage. | |
| // | |
| // This can help the compiler ignore or discard unused code, which can produce | |
| // faster compiles and smaller binaries. Other motivations are discussed in the | |
| // "ALLOW STATIC IMPLEMENTATION" section of | |
| // https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt | |
| #if defined(WUFFS_CONFIG__STATIC_FUNCTIONS) | |
| #define WUFFS_BASE__MAYBE_STATIC static | |
| #else | |
| #define WUFFS_BASE__MAYBE_STATIC | |
| #endif // defined(WUFFS_CONFIG__STATIC_FUNCTIONS) | |
| // ---------------- CPU Architecture | |
| static inline bool // | |
| wuffs_base__cpu_arch__have_arm_crc32() { | |
| #if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32) | |
| return true; | |
| #else | |
| return false; | |
| #endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32) | |
| } | |
| static inline bool // | |
| wuffs_base__cpu_arch__have_arm_neon() { | |
| #if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON) | |
| return true; | |
| #else | |
| return false; | |
| #endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON) | |
| } | |
| static inline bool // | |
| wuffs_base__cpu_arch__have_x86_avx2() { | |
| #if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| // GCC defines these macros but MSVC does not. | |
| // - bit_AVX2 = (1 << 5) | |
| const unsigned int avx2_ebx7 = 0x00000020; | |
| // GCC defines these macros but MSVC does not. | |
| // - bit_PCLMUL = (1 << 1) | |
| // - bit_POPCNT = (1 << 23) | |
| // - bit_SSE4_2 = (1 << 20) | |
| const unsigned int avx2_ecx1 = 0x00900002; | |
| // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). | |
| #if defined(__GNUC__) | |
| unsigned int eax7 = 0; | |
| unsigned int ebx7 = 0; | |
| unsigned int ecx7 = 0; | |
| unsigned int edx7 = 0; | |
| if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) && | |
| ((ebx7 & avx2_ebx7) == avx2_ebx7)) { | |
| unsigned int eax1 = 0; | |
| unsigned int ebx1 = 0; | |
| unsigned int ecx1 = 0; | |
| unsigned int edx1 = 0; | |
| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && | |
| ((ecx1 & avx2_ecx1) == avx2_ecx1)) { | |
| return true; | |
| } | |
| } | |
| #elif defined(_MSC_VER) // defined(__GNUC__) | |
| int x7[4]; | |
| __cpuidex(x7, 7, 0); | |
| if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) { | |
| int x1[4]; | |
| __cpuid(x1, 1); | |
| if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) { | |
| return true; | |
| } | |
| } | |
| #else | |
| #error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler" | |
| #endif // defined(__GNUC__); defined(_MSC_VER) | |
| #endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| return false; | |
| } | |
| static inline bool // | |
| wuffs_base__cpu_arch__have_x86_bmi2() { | |
| #if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| // GCC defines these macros but MSVC does not. | |
| // - bit_BMI2 = (1 << 8) | |
| const unsigned int bmi2_ebx7 = 0x00000100; | |
| // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). | |
| #if defined(__GNUC__) | |
| unsigned int eax7 = 0; | |
| unsigned int ebx7 = 0; | |
| unsigned int ecx7 = 0; | |
| unsigned int edx7 = 0; | |
| if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) && | |
| ((ebx7 & bmi2_ebx7) == bmi2_ebx7)) { | |
| return true; | |
| } | |
| #elif defined(_MSC_VER) // defined(__GNUC__) | |
| int x7[4]; | |
| __cpuidex(x7, 7, 0); | |
| if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) { | |
| return true; | |
| } | |
| #else | |
| #error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler" | |
| #endif // defined(__GNUC__); defined(_MSC_VER) | |
| #endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| return false; | |
| } | |
| static inline bool // | |
| wuffs_base__cpu_arch__have_x86_sse42() { | |
| #if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| // GCC defines these macros but MSVC does not. | |
| // - bit_PCLMUL = (1 << 1) | |
| // - bit_POPCNT = (1 << 23) | |
| // - bit_SSE4_2 = (1 << 20) | |
| const unsigned int sse42_ecx1 = 0x00900002; | |
| // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__). | |
| #if defined(__GNUC__) | |
| unsigned int eax1 = 0; | |
| unsigned int ebx1 = 0; | |
| unsigned int ecx1 = 0; | |
| unsigned int edx1 = 0; | |
| if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) && | |
| ((ecx1 & sse42_ecx1) == sse42_ecx1)) { | |
| return true; | |
| } | |
| #elif defined(_MSC_VER) // defined(__GNUC__) | |
| int x1[4]; | |
| __cpuid(x1, 1); | |
| if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) { | |
| return true; | |
| } | |
| #else | |
| #error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler" | |
| #endif // defined(__GNUC__); defined(_MSC_VER) | |
| #endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY) | |
| return false; | |
| } | |
| // ---------------- Fundamentals | |
| // Wuffs assumes that: | |
| // - converting a uint32_t to a size_t will never overflow. | |
| // - converting a size_t to a uint64_t will never overflow. | |
| #if defined(__WORDSIZE) | |
| #if (__WORDSIZE != 32) && (__WORDSIZE != 64) | |
| #error "Wuffs requires a word size of either 32 or 64 bits" | |
| #endif | |
| #endif | |
| // The "defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #if defined(__GNUC__) || defined(__clang__) | |
| #define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused)) | |
| #define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result)) | |
| #else | |
| #define WUFFS_BASE__POTENTIALLY_UNUSED | |
| #define WUFFS_BASE__WARN_UNUSED_RESULT | |
| #endif | |
| // -------- | |
| // Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions. | |
| #define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000) | |
| // WUFFS_INITIALIZE__ALREADY_ZEROED means that the "self" receiver struct value | |
| // has already been set to all zeroes. | |
| #define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001) | |
| // WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent | |
| // WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the "self" receiver struct | |
| // value will be set to all zeroes. Internal buffers, which tend to be a large | |
| // proportion of the struct's size, will be left uninitialized. Internal means | |
| // that the buffer is contained by the receiver struct, as opposed to being | |
| // passed as a separately allocated "work buffer". | |
| // | |
| // For more detail, see: | |
| // https://github.com/google/wuffs/blob/main/doc/note/initialization.md | |
| #define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \ | |
| ((uint32_t)0x00000002) | |
| // -------- | |
| // wuffs_base__empty_struct is used when a Wuffs function returns an empty | |
| // struct. In C, if a function f returns void, you can't say "x = f()", but in | |
| // Wuffs, if a function g returns empty, you can say "y = g()". | |
| typedef struct wuffs_base__empty_struct__struct { | |
| // private_impl is a placeholder field. It isn't explicitly used, except that | |
| // without it, the sizeof a struct with no fields can differ across C/C++ | |
| // compilers, and it is undefined behavior in C99. For example, gcc says that | |
| // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to | |
| // ABI incompatibility if a Wuffs .c file is processed by one compiler and | |
| // its .h file with another compiler. | |
| // | |
| // Instead, we explicitly insert an otherwise unused field, so that the | |
| // sizeof this struct is always 1. | |
| uint8_t private_impl; | |
| } wuffs_base__empty_struct; | |
| static inline wuffs_base__empty_struct // | |
| wuffs_base__make_empty_struct() { | |
| wuffs_base__empty_struct ret; | |
| ret.private_impl = 0; | |
| return ret; | |
| } | |
| // wuffs_base__utility is a placeholder receiver type. It enables what Java | |
| // calls static methods, as opposed to regular methods. | |
| typedef struct wuffs_base__utility__struct { | |
| // private_impl is a placeholder field. It isn't explicitly used, except that | |
| // without it, the sizeof a struct with no fields can differ across C/C++ | |
| // compilers, and it is undefined behavior in C99. For example, gcc says that | |
| // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to | |
| // ABI incompatibility if a Wuffs .c file is processed by one compiler and | |
| // its .h file with another compiler. | |
| // | |
| // Instead, we explicitly insert an otherwise unused field, so that the | |
| // sizeof this struct is always 1. | |
| uint8_t private_impl; | |
| } wuffs_base__utility; | |
| typedef struct wuffs_base__vtable__struct { | |
| const char* vtable_name; | |
| const void* function_pointers; | |
| } wuffs_base__vtable; | |
| // -------- | |
| // See https://github.com/google/wuffs/blob/main/doc/note/statuses.md | |
| typedef struct wuffs_base__status__struct { | |
| const char* repr; | |
| #ifdef __cplusplus | |
| inline bool is_complete() const; | |
| inline bool is_error() const; | |
| inline bool is_note() const; | |
| inline bool is_ok() const; | |
| inline bool is_suspension() const; | |
| inline const char* message() const; | |
| #endif // __cplusplus | |
| } wuffs_base__status; | |
| extern const char wuffs_base__note__i_o_redirect[]; | |
| extern const char wuffs_base__note__end_of_data[]; | |
| extern const char wuffs_base__note__metadata_reported[]; | |
| extern const char wuffs_base__suspension__even_more_information[]; | |
| extern const char wuffs_base__suspension__mispositioned_read[]; | |
| extern const char wuffs_base__suspension__mispositioned_write[]; | |
| extern const char wuffs_base__suspension__short_read[]; | |
| extern const char wuffs_base__suspension__short_write[]; | |
| extern const char wuffs_base__error__bad_i_o_position[]; | |
| extern const char wuffs_base__error__bad_argument_length_too_short[]; | |
| extern const char wuffs_base__error__bad_argument[]; | |
| extern const char wuffs_base__error__bad_call_sequence[]; | |
| extern const char wuffs_base__error__bad_data[]; | |
| extern const char wuffs_base__error__bad_receiver[]; | |
| extern const char wuffs_base__error__bad_restart[]; | |
| extern const char wuffs_base__error__bad_sizeof_receiver[]; | |
| extern const char wuffs_base__error__bad_vtable[]; | |
| extern const char wuffs_base__error__bad_workbuf_length[]; | |
| extern const char wuffs_base__error__bad_wuffs_version[]; | |
| extern const char wuffs_base__error__cannot_return_a_suspension[]; | |
| extern const char wuffs_base__error__disabled_by_previous_error[]; | |
| extern const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[]; | |
| extern const char wuffs_base__error__initialize_not_called[]; | |
| extern const char wuffs_base__error__interleaved_coroutine_calls[]; | |
| extern const char wuffs_base__error__no_more_information[]; | |
| extern const char wuffs_base__error__not_enough_data[]; | |
| extern const char wuffs_base__error__out_of_bounds[]; | |
| extern const char wuffs_base__error__unsupported_method[]; | |
| extern const char wuffs_base__error__unsupported_option[]; | |
| extern const char wuffs_base__error__unsupported_pixel_swizzler_option[]; | |
| extern const char wuffs_base__error__too_much_data[]; | |
| static inline wuffs_base__status // | |
| wuffs_base__make_status(const char* repr) { | |
| wuffs_base__status z; | |
| z.repr = repr; | |
| return z; | |
| } | |
| static inline bool // | |
| wuffs_base__status__is_complete(const wuffs_base__status* z) { | |
| return (z->repr == NULL) || ((*z->repr != '$') && (*z->repr != '#')); | |
| } | |
| static inline bool // | |
| wuffs_base__status__is_error(const wuffs_base__status* z) { | |
| return z->repr && (*z->repr == '#'); | |
| } | |
| static inline bool // | |
| wuffs_base__status__is_note(const wuffs_base__status* z) { | |
| return z->repr && (*z->repr != '$') && (*z->repr != '#'); | |
| } | |
| static inline bool // | |
| wuffs_base__status__is_ok(const wuffs_base__status* z) { | |
| return z->repr == NULL; | |
| } | |
| static inline bool // | |
| wuffs_base__status__is_suspension(const wuffs_base__status* z) { | |
| return z->repr && (*z->repr == '$'); | |
| } | |
| // wuffs_base__status__message strips the leading '$', '#' or '@'. | |
| static inline const char* // | |
| wuffs_base__status__message(const wuffs_base__status* z) { | |
| if (z->repr) { | |
| if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) { | |
| return z->repr + 1; | |
| } | |
| } | |
| return z->repr; | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__status::is_complete() const { | |
| return wuffs_base__status__is_complete(this); | |
| } | |
| inline bool // | |
| wuffs_base__status::is_error() const { | |
| return wuffs_base__status__is_error(this); | |
| } | |
| inline bool // | |
| wuffs_base__status::is_note() const { | |
| return wuffs_base__status__is_note(this); | |
| } | |
| inline bool // | |
| wuffs_base__status::is_ok() const { | |
| return wuffs_base__status__is_ok(this); | |
| } | |
| inline bool // | |
| wuffs_base__status::is_suspension() const { | |
| return wuffs_base__status__is_suspension(this); | |
| } | |
| inline const char* // | |
| wuffs_base__status::message() const { | |
| return wuffs_base__status__message(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| // WUFFS_BASE__RESULT is a result type: either a status (an error) or a value. | |
| // | |
| // A result with all fields NULL or zero is as valid as a zero-valued T. | |
| #define WUFFS_BASE__RESULT(T) \ | |
| struct { \ | |
| wuffs_base__status status; \ | |
| T value; \ | |
| } | |
| typedef WUFFS_BASE__RESULT(double) wuffs_base__result_f64; | |
| typedef WUFFS_BASE__RESULT(int64_t) wuffs_base__result_i64; | |
| typedef WUFFS_BASE__RESULT(uint64_t) wuffs_base__result_u64; | |
| // -------- | |
| // wuffs_base__transform__output is the result of transforming from a src slice | |
| // to a dst slice. | |
| typedef struct wuffs_base__transform__output__struct { | |
| wuffs_base__status status; | |
| size_t num_dst; | |
| size_t num_src; | |
| } wuffs_base__transform__output; | |
| // -------- | |
| // FourCC constants. Four Character Codes are literally four ASCII characters | |
| // (sometimes padded with ' ' spaces) that pack neatly into a signed or | |
| // unsigned 32-bit integer. ASCII letters are conventionally upper case. | |
| // | |
| // They are often used to identify video codecs (e.g. "H265") and pixel formats | |
| // (e.g. "YV12"). Wuffs uses them for that but also generally for naming | |
| // various things: compression formats (e.g. "BZ2 "), image metadata (e.g. | |
| // "EXIF"), file formats (e.g. "HTML"), etc. | |
| // | |
| // Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to | |
| // preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320. | |
| // Background Color. | |
| #define WUFFS_BASE__FOURCC__BGCL 0x4247434C | |
| // Bitmap. | |
| #define WUFFS_BASE__FOURCC__BMP 0x424D5020 | |
| // Brotli. | |
| #define WUFFS_BASE__FOURCC__BRTL 0x4252544C | |
| // Bzip2. | |
| #define WUFFS_BASE__FOURCC__BZ2 0x425A3220 | |
| // Concise Binary Object Representation. | |
| #define WUFFS_BASE__FOURCC__CBOR 0x43424F52 | |
| // Primary Chromaticities and White Point. | |
| #define WUFFS_BASE__FOURCC__CHRM 0x4348524D | |
| // Cascading Style Sheets. | |
| #define WUFFS_BASE__FOURCC__CSS 0x43535320 | |
| // Encapsulated PostScript. | |
| #define WUFFS_BASE__FOURCC__EPS 0x45505320 | |
| // Exchangeable Image File Format. | |
| #define WUFFS_BASE__FOURCC__EXIF 0x45584946 | |
| // Free Lossless Audio Codec. | |
| #define WUFFS_BASE__FOURCC__FLAC 0x464C4143 | |
| // Gamma Correction. | |
| #define WUFFS_BASE__FOURCC__GAMA 0x47414D41 | |
| // Graphics Interchange Format. | |
| #define WUFFS_BASE__FOURCC__GIF 0x47494620 | |
| // GNU Zip. | |
| #define WUFFS_BASE__FOURCC__GZ 0x475A2020 | |
| // High Efficiency Image File. | |
| #define WUFFS_BASE__FOURCC__HEIF 0x48454946 | |
| // Hypertext Markup Language. | |
| #define WUFFS_BASE__FOURCC__HTML 0x48544D4C | |
| // International Color Consortium Profile. | |
| #define WUFFS_BASE__FOURCC__ICCP 0x49434350 | |
| // Icon. | |
| #define WUFFS_BASE__FOURCC__ICO 0x49434F20 | |
| // Icon Vector Graphics. | |
| #define WUFFS_BASE__FOURCC__ICVG 0x49435647 | |
| // Initialization. | |
| #define WUFFS_BASE__FOURCC__INI 0x494E4920 | |
| // Joint Photographic Experts Group. | |
| #define WUFFS_BASE__FOURCC__JPEG 0x4A504547 | |
| // JavaScript. | |
| #define WUFFS_BASE__FOURCC__JS 0x4A532020 | |
| // JavaScript Object Notation. | |
| #define WUFFS_BASE__FOURCC__JSON 0x4A534F4E | |
| // JSON With Commas and Comments. | |
| #define WUFFS_BASE__FOURCC__JWCC 0x4A574343 | |
| // Key-Value Pair. | |
| #define WUFFS_BASE__FOURCC__KVP 0x4B565020 | |
| // Key-Value Pair (Key). | |
| #define WUFFS_BASE__FOURCC__KVPK 0x4B56504B | |
| // Key-Value Pair (Value). | |
| #define WUFFS_BASE__FOURCC__KVPV 0x4B565056 | |
| // Lempel–Ziv 4. | |
| #define WUFFS_BASE__FOURCC__LZ4 0x4C5A3420 | |
| // Markdown. | |
| #define WUFFS_BASE__FOURCC__MD 0x4D442020 | |
| // Modification Time. | |
| #define WUFFS_BASE__FOURCC__MTIM 0x4D54494D | |
| // MPEG-1 Audio Layer III. | |
| #define WUFFS_BASE__FOURCC__MP3 0x4D503320 | |
| // Naive Image. | |
| #define WUFFS_BASE__FOURCC__NIE 0x4E494520 | |
| // Offset (2-Dimensional). | |
| #define WUFFS_BASE__FOURCC__OFS2 0x4F465332 | |
| // Open Type Format. | |
| #define WUFFS_BASE__FOURCC__OTF 0x4F544620 | |
| // Portable Document Format. | |
| #define WUFFS_BASE__FOURCC__PDF 0x50444620 | |
| // Physical Dimensions. | |
| #define WUFFS_BASE__FOURCC__PHYD 0x50485944 | |
| // Portable Network Graphics. | |
| #define WUFFS_BASE__FOURCC__PNG 0x504E4720 | |
| // Portable Anymap. | |
| #define WUFFS_BASE__FOURCC__PNM 0x504E4D20 | |
| // PostScript. | |
| #define WUFFS_BASE__FOURCC__PS 0x50532020 | |
| // Quite OK Image. | |
| #define WUFFS_BASE__FOURCC__QOI 0x514F4920 | |
| // Random Access Compression. | |
| #define WUFFS_BASE__FOURCC__RAC 0x52414320 | |
| // Raw. | |
| #define WUFFS_BASE__FOURCC__RAW 0x52415720 | |
| // Resource Interchange File Format. | |
| #define WUFFS_BASE__FOURCC__RIFF 0x52494646 | |
| // Riegeli Records. | |
| #define WUFFS_BASE__FOURCC__RIGL 0x5249474C | |
| // Snappy. | |
| #define WUFFS_BASE__FOURCC__SNPY 0x534E5059 | |
| // Standard Red Green Blue (Rendering Intent). | |
| #define WUFFS_BASE__FOURCC__SRGB 0x53524742 | |
| // Scalable Vector Graphics. | |
| #define WUFFS_BASE__FOURCC__SVG 0x53564720 | |
| // Tape Archive. | |
| #define WUFFS_BASE__FOURCC__TAR 0x54415220 | |
| // Text. | |
| #define WUFFS_BASE__FOURCC__TEXT 0x54455854 | |
| // Truevision Advanced Raster Graphics Adapter. | |
| #define WUFFS_BASE__FOURCC__TGA 0x54474120 | |
| // Tagged Image File Format. | |
| #define WUFFS_BASE__FOURCC__TIFF 0x54494646 | |
| // Tom's Obvious Minimal Language. | |
| #define WUFFS_BASE__FOURCC__TOML 0x544F4D4C | |
| // Waveform. | |
| #define WUFFS_BASE__FOURCC__WAVE 0x57415645 | |
| // Wireless Bitmap. | |
| #define WUFFS_BASE__FOURCC__WBMP 0x57424D50 | |
| // Web Picture. | |
| #define WUFFS_BASE__FOURCC__WEBP 0x57454250 | |
| // Web Open Font Format. | |
| #define WUFFS_BASE__FOURCC__WOFF 0x574F4646 | |
| // Extensible Markup Language. | |
| #define WUFFS_BASE__FOURCC__XML 0x584D4C20 | |
| // Extensible Metadata Platform. | |
| #define WUFFS_BASE__FOURCC__XMP 0x584D5020 | |
| // Xz. | |
| #define WUFFS_BASE__FOURCC__XZ 0x585A2020 | |
| // Zip. | |
| #define WUFFS_BASE__FOURCC__ZIP 0x5A495020 | |
| // Zlib. | |
| #define WUFFS_BASE__FOURCC__ZLIB 0x5A4C4942 | |
| // Zstandard. | |
| #define WUFFS_BASE__FOURCC__ZSTD 0x5A535444 | |
| // -------- | |
| // Quirks. | |
| #define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1 | |
| // -------- | |
| // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a | |
| // second. See https://github.com/OculusVR/Flicks | |
| typedef int64_t wuffs_base__flicks; | |
| #define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) | |
| #define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600) | |
| // ---------------- Numeric Types | |
| // The helpers below are functions, instead of macros, because their arguments | |
| // can be an expression that we shouldn't evaluate more than once. | |
| // | |
| // They are static, so that linking multiple wuffs .o files won't complain about | |
| // duplicate function definitions. | |
| // | |
| // They are explicitly marked inline, even if modern compilers don't use the | |
| // inline attribute to guide optimizations such as inlining, to avoid the | |
| // -Wunused-function warning, and we like to compile with -Wall -Werror. | |
| static inline int8_t // | |
| wuffs_base__i8__min(int8_t x, int8_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline int8_t // | |
| wuffs_base__i8__max(int8_t x, int8_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline int16_t // | |
| wuffs_base__i16__min(int16_t x, int16_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline int16_t // | |
| wuffs_base__i16__max(int16_t x, int16_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline int32_t // | |
| wuffs_base__i32__min(int32_t x, int32_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline int32_t // | |
| wuffs_base__i32__max(int32_t x, int32_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline int64_t // | |
| wuffs_base__i64__min(int64_t x, int64_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline int64_t // | |
| wuffs_base__i64__max(int64_t x, int64_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline uint8_t // | |
| wuffs_base__u8__min(uint8_t x, uint8_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline uint8_t // | |
| wuffs_base__u8__max(uint8_t x, uint8_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__min(uint16_t x, uint16_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__max(uint16_t x, uint16_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__min(uint32_t x, uint32_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__max(uint32_t x, uint32_t y) { | |
| return x > y ? x : y; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__min(uint64_t x, uint64_t y) { | |
| return x < y ? x : y; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__max(uint64_t x, uint64_t y) { | |
| return x > y ? x : y; | |
| } | |
| // -------- | |
| static inline uint8_t // | |
| wuffs_base__u8__rotate_left(uint8_t x, uint32_t n) { | |
| n &= 7; | |
| return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n))); | |
| } | |
| static inline uint8_t // | |
| wuffs_base__u8__rotate_right(uint8_t x, uint32_t n) { | |
| n &= 7; | |
| return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n))); | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__rotate_left(uint16_t x, uint32_t n) { | |
| n &= 15; | |
| return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n))); | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__rotate_right(uint16_t x, uint32_t n) { | |
| n &= 15; | |
| return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n))); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__rotate_left(uint32_t x, uint32_t n) { | |
| n &= 31; | |
| return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n))); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__rotate_right(uint32_t x, uint32_t n) { | |
| n &= 31; | |
| return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n))); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__rotate_left(uint64_t x, uint32_t n) { | |
| n &= 63; | |
| return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n))); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__rotate_right(uint64_t x, uint32_t n) { | |
| n &= 63; | |
| return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n))); | |
| } | |
| // -------- | |
| // Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms | |
| // are per https://locklessinc.com/articles/sat_arithmetic/ | |
| // | |
| // It is important that the underlying types are unsigned integers, as signed | |
| // integer arithmetic overflow is undefined behavior in C. | |
| static inline uint8_t // | |
| wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { | |
| uint8_t res = (uint8_t)(x + y); | |
| res |= (uint8_t)(-(res < x)); | |
| return res; | |
| } | |
| static inline uint8_t // | |
| wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { | |
| uint8_t res = (uint8_t)(x - y); | |
| res &= (uint8_t)(-(res <= x)); | |
| return res; | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { | |
| uint16_t res = (uint16_t)(x + y); | |
| res |= (uint16_t)(-(res < x)); | |
| return res; | |
| } | |
| static inline uint16_t // | |
| wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { | |
| uint16_t res = (uint16_t)(x - y); | |
| res &= (uint16_t)(-(res <= x)); | |
| return res; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { | |
| uint32_t res = (uint32_t)(x + y); | |
| res |= (uint32_t)(-(res < x)); | |
| return res; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) { | |
| uint32_t res = (uint32_t)(x - y); | |
| res &= (uint32_t)(-(res <= x)); | |
| return res; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__sat_add(uint64_t x, uint64_t y) { | |
| uint64_t res = (uint64_t)(x + y); | |
| res |= (uint64_t)(-(res < x)); | |
| return res; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { | |
| uint64_t res = (uint64_t)(x - y); | |
| res &= (uint64_t)(-(res <= x)); | |
| return res; | |
| } | |
| // -------- | |
| typedef struct wuffs_base__multiply_u64__output__struct { | |
| uint64_t lo; | |
| uint64_t hi; | |
| } wuffs_base__multiply_u64__output; | |
| // wuffs_base__multiply_u64 returns x*y as a 128-bit value. | |
| // | |
| // The maximum inclusive output hi_lo is 0xFFFFFFFFFFFFFFFE_0000000000000001. | |
| static inline wuffs_base__multiply_u64__output // | |
| wuffs_base__multiply_u64(uint64_t x, uint64_t y) { | |
| #if defined(__SIZEOF_INT128__) | |
| __uint128_t z = ((__uint128_t)x) * ((__uint128_t)y); | |
| wuffs_base__multiply_u64__output o; | |
| o.lo = ((uint64_t)(z)); | |
| o.hi = ((uint64_t)(z >> 64)); | |
| return o; | |
| #else | |
| // TODO: consider using the _mul128 intrinsic if defined(_MSC_VER). | |
| uint64_t x0 = x & 0xFFFFFFFF; | |
| uint64_t x1 = x >> 32; | |
| uint64_t y0 = y & 0xFFFFFFFF; | |
| uint64_t y1 = y >> 32; | |
| uint64_t w0 = x0 * y0; | |
| uint64_t t = (x1 * y0) + (w0 >> 32); | |
| uint64_t w1 = t & 0xFFFFFFFF; | |
| uint64_t w2 = t >> 32; | |
| w1 += x0 * y1; | |
| wuffs_base__multiply_u64__output o; | |
| o.lo = x * y; | |
| o.hi = (x1 * y1) + w2 + (w1 >> 32); | |
| return o; | |
| #endif | |
| } | |
| // -------- | |
| // The "defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8) | |
| static inline uint32_t // | |
| wuffs_base__count_leading_zeroes_u64(uint64_t u) { | |
| return u ? ((uint32_t)(__builtin_clzl(u))) : 64u; | |
| } | |
| #else | |
| // TODO: consider using the _BitScanReverse intrinsic if defined(_MSC_VER). | |
| static inline uint32_t // | |
| wuffs_base__count_leading_zeroes_u64(uint64_t u) { | |
| if (u == 0) { | |
| return 64; | |
| } | |
| uint32_t n = 0; | |
| if ((u >> 32) == 0) { | |
| n |= 32; | |
| u <<= 32; | |
| } | |
| if ((u >> 48) == 0) { | |
| n |= 16; | |
| u <<= 16; | |
| } | |
| if ((u >> 56) == 0) { | |
| n |= 8; | |
| u <<= 8; | |
| } | |
| if ((u >> 60) == 0) { | |
| n |= 4; | |
| u <<= 4; | |
| } | |
| if ((u >> 62) == 0) { | |
| n |= 2; | |
| u <<= 2; | |
| } | |
| if ((u >> 63) == 0) { | |
| n |= 1; | |
| u <<= 1; | |
| } | |
| return n; | |
| } | |
| #endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8) | |
| // -------- | |
| #define wuffs_base__peek_u8be__no_bounds_check \ | |
| wuffs_base__peek_u8__no_bounds_check | |
| #define wuffs_base__peek_u8le__no_bounds_check \ | |
| wuffs_base__peek_u8__no_bounds_check | |
| static inline uint8_t // | |
| wuffs_base__peek_u8__no_bounds_check(const uint8_t* p) { | |
| return p[0]; | |
| } | |
| static inline uint16_t // | |
| wuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) { | |
| return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); | |
| } | |
| static inline uint16_t // | |
| wuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) { | |
| return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) { | |
| return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | | |
| ((uint32_t)(p[2]) << 0); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) { | |
| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | | |
| ((uint32_t)(p[2]) << 16); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__peek_u32be__no_bounds_check(const uint8_t* p) { | |
| return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | | |
| ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) { | |
| return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | | |
| ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u40be__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) | | |
| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) | | |
| ((uint64_t)(p[4]) << 0); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u40le__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | | |
| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | | |
| ((uint64_t)(p[4]) << 32); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u48be__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) | | |
| ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) | | |
| ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u48le__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | | |
| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | | |
| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u56be__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) | | |
| ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) | | |
| ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) | | |
| ((uint64_t)(p[6]) << 0); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u56le__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | | |
| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | | |
| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | | |
| ((uint64_t)(p[6]) << 48); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u64be__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) | | |
| ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) | | |
| ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) | | |
| ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) { | |
| return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | | |
| ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | | |
| ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | | |
| ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); | |
| } | |
| // -------- | |
| #define wuffs_base__poke_u8be__no_bounds_check \ | |
| wuffs_base__poke_u8__no_bounds_check | |
| #define wuffs_base__poke_u8le__no_bounds_check \ | |
| wuffs_base__poke_u8__no_bounds_check | |
| static inline void // | |
| wuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) { | |
| p[0] = x; | |
| } | |
| static inline void // | |
| wuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) { | |
| p[0] = (uint8_t)(x >> 8); | |
| p[1] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) { | |
| #if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__) | |
| // This seems to perform better on gcc 10 (but not clang 9). Clang also | |
| // defines "__GNUC__". | |
| memcpy(p, &x, 2); | |
| #else | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| #endif | |
| } | |
| static inline void // | |
| wuffs_base__poke_u24be__no_bounds_check(uint8_t* p, uint32_t x) { | |
| p[0] = (uint8_t)(x >> 16); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u24le__no_bounds_check(uint8_t* p, uint32_t x) { | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u32be__no_bounds_check(uint8_t* p, uint32_t x) { | |
| p[0] = (uint8_t)(x >> 24); | |
| p[1] = (uint8_t)(x >> 16); | |
| p[2] = (uint8_t)(x >> 8); | |
| p[3] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) { | |
| #if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__) | |
| // This seems to perform better on gcc 10 (but not clang 9). Clang also | |
| // defines "__GNUC__". | |
| memcpy(p, &x, 4); | |
| #else | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 24); | |
| #endif | |
| } | |
| static inline void // | |
| wuffs_base__poke_u40be__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 32); | |
| p[1] = (uint8_t)(x >> 24); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 8); | |
| p[4] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u40le__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 24); | |
| p[4] = (uint8_t)(x >> 32); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u48be__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 40); | |
| p[1] = (uint8_t)(x >> 32); | |
| p[2] = (uint8_t)(x >> 24); | |
| p[3] = (uint8_t)(x >> 16); | |
| p[4] = (uint8_t)(x >> 8); | |
| p[5] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u48le__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 24); | |
| p[4] = (uint8_t)(x >> 32); | |
| p[5] = (uint8_t)(x >> 40); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u56be__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 48); | |
| p[1] = (uint8_t)(x >> 40); | |
| p[2] = (uint8_t)(x >> 32); | |
| p[3] = (uint8_t)(x >> 24); | |
| p[4] = (uint8_t)(x >> 16); | |
| p[5] = (uint8_t)(x >> 8); | |
| p[6] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u56le__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 24); | |
| p[4] = (uint8_t)(x >> 32); | |
| p[5] = (uint8_t)(x >> 40); | |
| p[6] = (uint8_t)(x >> 48); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u64be__no_bounds_check(uint8_t* p, uint64_t x) { | |
| p[0] = (uint8_t)(x >> 56); | |
| p[1] = (uint8_t)(x >> 48); | |
| p[2] = (uint8_t)(x >> 40); | |
| p[3] = (uint8_t)(x >> 32); | |
| p[4] = (uint8_t)(x >> 24); | |
| p[5] = (uint8_t)(x >> 16); | |
| p[6] = (uint8_t)(x >> 8); | |
| p[7] = (uint8_t)(x >> 0); | |
| } | |
| static inline void // | |
| wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) { | |
| #if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__) | |
| // This seems to perform better on gcc 10 (but not clang 9). Clang also | |
| // defines "__GNUC__". | |
| memcpy(p, &x, 8); | |
| #else | |
| p[0] = (uint8_t)(x >> 0); | |
| p[1] = (uint8_t)(x >> 8); | |
| p[2] = (uint8_t)(x >> 16); | |
| p[3] = (uint8_t)(x >> 24); | |
| p[4] = (uint8_t)(x >> 32); | |
| p[5] = (uint8_t)(x >> 40); | |
| p[6] = (uint8_t)(x >> 48); | |
| p[7] = (uint8_t)(x >> 56); | |
| #endif | |
| } | |
| // -------- | |
| // Load and Store functions are deprecated. Use Peek and Poke instead. | |
| #define wuffs_base__load_u8__no_bounds_check \ | |
| wuffs_base__peek_u8__no_bounds_check | |
| #define wuffs_base__load_u16be__no_bounds_check \ | |
| wuffs_base__peek_u16be__no_bounds_check | |
| #define wuffs_base__load_u16le__no_bounds_check \ | |
| wuffs_base__peek_u16le__no_bounds_check | |
| #define wuffs_base__load_u24be__no_bounds_check \ | |
| wuffs_base__peek_u24be__no_bounds_check | |
| #define wuffs_base__load_u24le__no_bounds_check \ | |
| wuffs_base__peek_u24le__no_bounds_check | |
| #define wuffs_base__load_u32be__no_bounds_check \ | |
| wuffs_base__peek_u32be__no_bounds_check | |
| #define wuffs_base__load_u32le__no_bounds_check \ | |
| wuffs_base__peek_u32le__no_bounds_check | |
| #define wuffs_base__load_u40be__no_bounds_check \ | |
| wuffs_base__peek_u40be__no_bounds_check | |
| #define wuffs_base__load_u40le__no_bounds_check \ | |
| wuffs_base__peek_u40le__no_bounds_check | |
| #define wuffs_base__load_u48be__no_bounds_check \ | |
| wuffs_base__peek_u48be__no_bounds_check | |
| #define wuffs_base__load_u48le__no_bounds_check \ | |
| wuffs_base__peek_u48le__no_bounds_check | |
| #define wuffs_base__load_u56be__no_bounds_check \ | |
| wuffs_base__peek_u56be__no_bounds_check | |
| #define wuffs_base__load_u56le__no_bounds_check \ | |
| wuffs_base__peek_u56le__no_bounds_check | |
| #define wuffs_base__load_u64be__no_bounds_check \ | |
| wuffs_base__peek_u64be__no_bounds_check | |
| #define wuffs_base__load_u64le__no_bounds_check \ | |
| wuffs_base__peek_u64le__no_bounds_check | |
| #define wuffs_base__store_u8__no_bounds_check \ | |
| wuffs_base__poke_u8__no_bounds_check | |
| #define wuffs_base__store_u16be__no_bounds_check \ | |
| wuffs_base__poke_u16be__no_bounds_check | |
| #define wuffs_base__store_u16le__no_bounds_check \ | |
| wuffs_base__poke_u16le__no_bounds_check | |
| #define wuffs_base__store_u24be__no_bounds_check \ | |
| wuffs_base__poke_u24be__no_bounds_check | |
| #define wuffs_base__store_u24le__no_bounds_check \ | |
| wuffs_base__poke_u24le__no_bounds_check | |
| #define wuffs_base__store_u32be__no_bounds_check \ | |
| wuffs_base__poke_u32be__no_bounds_check | |
| #define wuffs_base__store_u32le__no_bounds_check \ | |
| wuffs_base__poke_u32le__no_bounds_check | |
| #define wuffs_base__store_u40be__no_bounds_check \ | |
| wuffs_base__poke_u40be__no_bounds_check | |
| #define wuffs_base__store_u40le__no_bounds_check \ | |
| wuffs_base__poke_u40le__no_bounds_check | |
| #define wuffs_base__store_u48be__no_bounds_check \ | |
| wuffs_base__poke_u48be__no_bounds_check | |
| #define wuffs_base__store_u48le__no_bounds_check \ | |
| wuffs_base__poke_u48le__no_bounds_check | |
| #define wuffs_base__store_u56be__no_bounds_check \ | |
| wuffs_base__poke_u56be__no_bounds_check | |
| #define wuffs_base__store_u56le__no_bounds_check \ | |
| wuffs_base__poke_u56le__no_bounds_check | |
| #define wuffs_base__store_u64be__no_bounds_check \ | |
| wuffs_base__poke_u64be__no_bounds_check | |
| #define wuffs_base__store_u64le__no_bounds_check \ | |
| wuffs_base__poke_u64le__no_bounds_check | |
| // ---------------- Slices and Tables | |
| // WUFFS_BASE__SLICE is a 1-dimensional buffer. | |
| // | |
| // len measures a number of elements, not necessarily a size in bytes. | |
| // | |
| // A value with all fields NULL or zero is a valid, empty slice. | |
| #define WUFFS_BASE__SLICE(T) \ | |
| struct { \ | |
| T* ptr; \ | |
| size_t len; \ | |
| } | |
| // WUFFS_BASE__TABLE is a 2-dimensional buffer. | |
| // | |
| // width, height and stride measure a number of elements, not necessarily a | |
| // size in bytes. | |
| // | |
| // A value with all fields NULL or zero is a valid, empty table. | |
| #define WUFFS_BASE__TABLE(T) \ | |
| struct { \ | |
| T* ptr; \ | |
| size_t width; \ | |
| size_t height; \ | |
| size_t stride; \ | |
| } | |
| typedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8; | |
| typedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16; | |
| typedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32; | |
| typedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64; | |
| typedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8; | |
| typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16; | |
| typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32; | |
| typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64; | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) { | |
| wuffs_base__slice_u8 ret; | |
| ret.ptr = ptr; | |
| ret.len = len; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u16 // | |
| wuffs_base__make_slice_u16(uint16_t* ptr, size_t len) { | |
| wuffs_base__slice_u16 ret; | |
| ret.ptr = ptr; | |
| ret.len = len; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u32 // | |
| wuffs_base__make_slice_u32(uint32_t* ptr, size_t len) { | |
| wuffs_base__slice_u32 ret; | |
| ret.ptr = ptr; | |
| ret.len = len; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u64 // | |
| wuffs_base__make_slice_u64(uint64_t* ptr, size_t len) { | |
| wuffs_base__slice_u64 ret; | |
| ret.ptr = ptr; | |
| ret.len = len; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) { | |
| wuffs_base__slice_u8 ret; | |
| ret.ptr = ptr + i; | |
| ret.len = (j >= i) ? (j - i) : 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u16 // | |
| wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) { | |
| wuffs_base__slice_u16 ret; | |
| ret.ptr = ptr + i; | |
| ret.len = (j >= i) ? (j - i) : 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u32 // | |
| wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) { | |
| wuffs_base__slice_u32 ret; | |
| ret.ptr = ptr + i; | |
| ret.len = (j >= i) ? (j - i) : 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u64 // | |
| wuffs_base__make_slice_u64_ij(uint64_t* ptr, size_t i, size_t j) { | |
| wuffs_base__slice_u64 ret; | |
| ret.ptr = ptr + i; | |
| ret.len = (j >= i) ? (j - i) : 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__empty_slice_u8() { | |
| wuffs_base__slice_u8 ret; | |
| ret.ptr = NULL; | |
| ret.len = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u16 // | |
| wuffs_base__empty_slice_u16() { | |
| wuffs_base__slice_u16 ret; | |
| ret.ptr = NULL; | |
| ret.len = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u32 // | |
| wuffs_base__empty_slice_u32() { | |
| wuffs_base__slice_u32 ret; | |
| ret.ptr = NULL; | |
| ret.len = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_u64 // | |
| wuffs_base__empty_slice_u64() { | |
| wuffs_base__slice_u64 ret; | |
| ret.ptr = NULL; | |
| ret.len = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u8 // | |
| wuffs_base__make_table_u8(uint8_t* ptr, | |
| size_t width, | |
| size_t height, | |
| size_t stride) { | |
| wuffs_base__table_u8 ret; | |
| ret.ptr = ptr; | |
| ret.width = width; | |
| ret.height = height; | |
| ret.stride = stride; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u16 // | |
| wuffs_base__make_table_u16(uint16_t* ptr, | |
| size_t width, | |
| size_t height, | |
| size_t stride) { | |
| wuffs_base__table_u16 ret; | |
| ret.ptr = ptr; | |
| ret.width = width; | |
| ret.height = height; | |
| ret.stride = stride; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u32 // | |
| wuffs_base__make_table_u32(uint32_t* ptr, | |
| size_t width, | |
| size_t height, | |
| size_t stride) { | |
| wuffs_base__table_u32 ret; | |
| ret.ptr = ptr; | |
| ret.width = width; | |
| ret.height = height; | |
| ret.stride = stride; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u64 // | |
| wuffs_base__make_table_u64(uint64_t* ptr, | |
| size_t width, | |
| size_t height, | |
| size_t stride) { | |
| wuffs_base__table_u64 ret; | |
| ret.ptr = ptr; | |
| ret.width = width; | |
| ret.height = height; | |
| ret.stride = stride; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u8 // | |
| wuffs_base__empty_table_u8() { | |
| wuffs_base__table_u8 ret; | |
| ret.ptr = NULL; | |
| ret.width = 0; | |
| ret.height = 0; | |
| ret.stride = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u16 // | |
| wuffs_base__empty_table_u16() { | |
| wuffs_base__table_u16 ret; | |
| ret.ptr = NULL; | |
| ret.width = 0; | |
| ret.height = 0; | |
| ret.stride = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u32 // | |
| wuffs_base__empty_table_u32() { | |
| wuffs_base__table_u32 ret; | |
| ret.ptr = NULL; | |
| ret.width = 0; | |
| ret.height = 0; | |
| ret.stride = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__table_u64 // | |
| wuffs_base__empty_table_u64() { | |
| wuffs_base__table_u64 ret; | |
| ret.ptr = NULL; | |
| ret.width = 0; | |
| ret.height = 0; | |
| ret.stride = 0; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__slice_u8__overlaps(wuffs_base__slice_u8 s, wuffs_base__slice_u8 t) { | |
| return ((s.ptr <= t.ptr) && (t.ptr < (s.ptr + s.len))) || | |
| ((t.ptr <= s.ptr) && (s.ptr < (t.ptr + t.len))); | |
| } | |
| // wuffs_base__slice_u8__subslice_i returns s[i:]. | |
| // | |
| // It returns an empty slice if i is out of bounds. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) { | |
| if ((i <= SIZE_MAX) && (i <= s.len)) { | |
| return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(s.len - i))); | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| // wuffs_base__slice_u8__subslice_j returns s[:j]. | |
| // | |
| // It returns an empty slice if j is out of bounds. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) { | |
| if ((j <= SIZE_MAX) && (j <= s.len)) { | |
| return wuffs_base__make_slice_u8(s.ptr, ((size_t)j)); | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| // wuffs_base__slice_u8__subslice_ij returns s[i:j]. | |
| // | |
| // It returns an empty slice if i or j is out of bounds. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, | |
| uint64_t i, | |
| uint64_t j) { | |
| if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) { | |
| return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(j - i))); | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| // wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy]. | |
| // | |
| // It returns an empty table if i or j is out of bounds. | |
| static inline wuffs_base__table_u8 // | |
| wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t, | |
| uint64_t ix, | |
| uint64_t iy, | |
| uint64_t jx, | |
| uint64_t jy) { | |
| if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && // | |
| (iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) { | |
| return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), // | |
| ((size_t)(jx - ix)), // | |
| ((size_t)(jy - iy)), // | |
| t.stride); // | |
| } | |
| return wuffs_base__make_table_u8(NULL, 0, 0, 0); | |
| } | |
| // wuffs_base__table__flattened_length returns the number of elements covered | |
| // by the 1-dimensional span that backs a 2-dimensional table. This counts the | |
| // elements inside the table and, when width != stride, the elements outside | |
| // the table but between its rows. | |
| // | |
| // For example, consider a width 10, height 4, stride 10 table. Mark its first | |
| // and last (inclusive) elements with 'a' and 'z'. This function returns 40. | |
| // | |
| // a123456789 | |
| // 0123456789 | |
| // 0123456789 | |
| // 012345678z | |
| // | |
| // Now consider the sub-table of that from (2, 1) inclusive to (8, 4) exclusive. | |
| // | |
| // a123456789 | |
| // 01iiiiiioo | |
| // ooiiiiiioo | |
| // ooiiiiii8z | |
| // | |
| // This function (called with width 6, height 3, stride 10) returns 26: 18 'i' | |
| // inside elements plus 8 'o' outside elements. Note that 26 is less than a | |
| // naive (height * stride = 30) computation. Indeed, advancing 29 elements from | |
| // the first 'i' would venture past 'z', out of bounds of the original table. | |
| // | |
| // It does not check for overflow, but if the arguments come from a table that | |
| // exists in memory and each element occupies a positive number of bytes then | |
| // the result should be bounded by the amount of allocatable memory (which | |
| // shouldn't overflow SIZE_MAX). | |
| static inline size_t // | |
| wuffs_base__table__flattened_length(size_t width, | |
| size_t height, | |
| size_t stride) { | |
| if (height == 0) { | |
| return 0; | |
| } | |
| return ((height - 1) * stride) + width; | |
| } | |
| // ---------------- Magic Numbers | |
| // wuffs_base__magic_number_guess_fourcc guesses the file format of some data, | |
| // given its starting bytes (the prefix_data argument) and whether or not there | |
| // may be further bytes (the prefix_closed argument; true means that | |
| // prefix_data is the entire data). | |
| // | |
| // It returns a positive FourCC value on success. | |
| // | |
| // It returns zero if nothing matches its hard-coded list of 'magic numbers'. | |
| // | |
| // It returns a negative value if prefix_closed is false and a longer prefix is | |
| // required for a conclusive result. For example, a single 'B' byte (without | |
| // further data) is not enough to discriminate the BMP and BPG image file | |
| // formats. Similarly, a single '\xFF' byte might be the start of JPEG data or | |
| // it might be the start of some other binary data. | |
| // | |
| // It does not do a full validity check. Like any guess made from a short | |
| // prefix of the data, it may return false positives. Data that starts with 99 | |
| // bytes of valid JPEG followed by corruption or truncation is an invalid JPEG | |
| // image overall, but this function will still return WUFFS_BASE__FOURCC__JPEG. | |
| // | |
| // Another source of false positives is that some 'magic numbers' are valid | |
| // ASCII data. A file starting with "GIF87a and GIF89a are the two versions of | |
| // GIF" will match GIF's 'magic number' even if it's plain text, not an image. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__MAGIC sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC int32_t // | |
| wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, | |
| bool prefix_closed); | |
| // ---------------- Ranges and Rects | |
| // See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md | |
| typedef struct wuffs_base__range_ii_u32__struct { | |
| uint32_t min_incl; | |
| uint32_t max_incl; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__range_ii_u32__struct s) const; | |
| inline wuffs_base__range_ii_u32__struct intersect( | |
| wuffs_base__range_ii_u32__struct s) const; | |
| inline wuffs_base__range_ii_u32__struct unite( | |
| wuffs_base__range_ii_u32__struct s) const; | |
| inline bool contains(uint32_t x) const; | |
| inline bool contains_range(wuffs_base__range_ii_u32__struct s) const; | |
| #endif // __cplusplus | |
| } wuffs_base__range_ii_u32; | |
| static inline wuffs_base__range_ii_u32 // | |
| wuffs_base__empty_range_ii_u32() { | |
| wuffs_base__range_ii_u32 ret; | |
| ret.min_incl = 0; | |
| ret.max_incl = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__range_ii_u32 // | |
| wuffs_base__make_range_ii_u32(uint32_t min_incl, uint32_t max_incl) { | |
| wuffs_base__range_ii_u32 ret; | |
| ret.min_incl = min_incl; | |
| ret.max_incl = max_incl; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u32__is_empty(const wuffs_base__range_ii_u32* r) { | |
| return r->min_incl > r->max_incl; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u32__equals(const wuffs_base__range_ii_u32* r, | |
| wuffs_base__range_ii_u32 s) { | |
| return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || | |
| (wuffs_base__range_ii_u32__is_empty(r) && | |
| wuffs_base__range_ii_u32__is_empty(&s)); | |
| } | |
| static inline wuffs_base__range_ii_u32 // | |
| wuffs_base__range_ii_u32__intersect(const wuffs_base__range_ii_u32* r, | |
| wuffs_base__range_ii_u32 s) { | |
| wuffs_base__range_ii_u32 t; | |
| t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); | |
| t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl); | |
| return t; | |
| } | |
| static inline wuffs_base__range_ii_u32 // | |
| wuffs_base__range_ii_u32__unite(const wuffs_base__range_ii_u32* r, | |
| wuffs_base__range_ii_u32 s) { | |
| if (wuffs_base__range_ii_u32__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__range_ii_u32__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__range_ii_u32 t; | |
| t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl); | |
| t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u32__contains(const wuffs_base__range_ii_u32* r, | |
| uint32_t x) { | |
| return (r->min_incl <= x) && (x <= r->max_incl); | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u32__contains_range(const wuffs_base__range_ii_u32* r, | |
| wuffs_base__range_ii_u32 s) { | |
| return wuffs_base__range_ii_u32__equals( | |
| &s, wuffs_base__range_ii_u32__intersect(r, s)); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__range_ii_u32::is_empty() const { | |
| return wuffs_base__range_ii_u32__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) const { | |
| return wuffs_base__range_ii_u32__equals(this, s); | |
| } | |
| inline wuffs_base__range_ii_u32 // | |
| wuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) const { | |
| return wuffs_base__range_ii_u32__intersect(this, s); | |
| } | |
| inline wuffs_base__range_ii_u32 // | |
| wuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) const { | |
| return wuffs_base__range_ii_u32__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u32::contains(uint32_t x) const { | |
| return wuffs_base__range_ii_u32__contains(this, x); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u32::contains_range(wuffs_base__range_ii_u32 s) const { | |
| return wuffs_base__range_ii_u32__contains_range(this, s); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__range_ie_u32__struct { | |
| uint32_t min_incl; | |
| uint32_t max_excl; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__range_ie_u32__struct s) const; | |
| inline wuffs_base__range_ie_u32__struct intersect( | |
| wuffs_base__range_ie_u32__struct s) const; | |
| inline wuffs_base__range_ie_u32__struct unite( | |
| wuffs_base__range_ie_u32__struct s) const; | |
| inline bool contains(uint32_t x) const; | |
| inline bool contains_range(wuffs_base__range_ie_u32__struct s) const; | |
| inline uint32_t length() const; | |
| #endif // __cplusplus | |
| } wuffs_base__range_ie_u32; | |
| static inline wuffs_base__range_ie_u32 // | |
| wuffs_base__empty_range_ie_u32() { | |
| wuffs_base__range_ie_u32 ret; | |
| ret.min_incl = 0; | |
| ret.max_excl = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__range_ie_u32 // | |
| wuffs_base__make_range_ie_u32(uint32_t min_incl, uint32_t max_excl) { | |
| wuffs_base__range_ie_u32 ret; | |
| ret.min_incl = min_incl; | |
| ret.max_excl = max_excl; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u32__is_empty(const wuffs_base__range_ie_u32* r) { | |
| return r->min_incl >= r->max_excl; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u32__equals(const wuffs_base__range_ie_u32* r, | |
| wuffs_base__range_ie_u32 s) { | |
| return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || | |
| (wuffs_base__range_ie_u32__is_empty(r) && | |
| wuffs_base__range_ie_u32__is_empty(&s)); | |
| } | |
| static inline wuffs_base__range_ie_u32 // | |
| wuffs_base__range_ie_u32__intersect(const wuffs_base__range_ie_u32* r, | |
| wuffs_base__range_ie_u32 s) { | |
| wuffs_base__range_ie_u32 t; | |
| t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); | |
| t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl); | |
| return t; | |
| } | |
| static inline wuffs_base__range_ie_u32 // | |
| wuffs_base__range_ie_u32__unite(const wuffs_base__range_ie_u32* r, | |
| wuffs_base__range_ie_u32 s) { | |
| if (wuffs_base__range_ie_u32__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__range_ie_u32__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__range_ie_u32 t; | |
| t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl); | |
| t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u32__contains(const wuffs_base__range_ie_u32* r, | |
| uint32_t x) { | |
| return (r->min_incl <= x) && (x < r->max_excl); | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u32__contains_range(const wuffs_base__range_ie_u32* r, | |
| wuffs_base__range_ie_u32 s) { | |
| return wuffs_base__range_ie_u32__equals( | |
| &s, wuffs_base__range_ie_u32__intersect(r, s)); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__range_ie_u32__length(const wuffs_base__range_ie_u32* r) { | |
| return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__range_ie_u32::is_empty() const { | |
| return wuffs_base__range_ie_u32__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) const { | |
| return wuffs_base__range_ie_u32__equals(this, s); | |
| } | |
| inline wuffs_base__range_ie_u32 // | |
| wuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) const { | |
| return wuffs_base__range_ie_u32__intersect(this, s); | |
| } | |
| inline wuffs_base__range_ie_u32 // | |
| wuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) const { | |
| return wuffs_base__range_ie_u32__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u32::contains(uint32_t x) const { | |
| return wuffs_base__range_ie_u32__contains(this, x); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u32::contains_range(wuffs_base__range_ie_u32 s) const { | |
| return wuffs_base__range_ie_u32__contains_range(this, s); | |
| } | |
| inline uint32_t // | |
| wuffs_base__range_ie_u32::length() const { | |
| return wuffs_base__range_ie_u32__length(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__range_ii_u64__struct { | |
| uint64_t min_incl; | |
| uint64_t max_incl; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__range_ii_u64__struct s) const; | |
| inline wuffs_base__range_ii_u64__struct intersect( | |
| wuffs_base__range_ii_u64__struct s) const; | |
| inline wuffs_base__range_ii_u64__struct unite( | |
| wuffs_base__range_ii_u64__struct s) const; | |
| inline bool contains(uint64_t x) const; | |
| inline bool contains_range(wuffs_base__range_ii_u64__struct s) const; | |
| #endif // __cplusplus | |
| } wuffs_base__range_ii_u64; | |
| static inline wuffs_base__range_ii_u64 // | |
| wuffs_base__empty_range_ii_u64() { | |
| wuffs_base__range_ii_u64 ret; | |
| ret.min_incl = 0; | |
| ret.max_incl = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__range_ii_u64 // | |
| wuffs_base__make_range_ii_u64(uint64_t min_incl, uint64_t max_incl) { | |
| wuffs_base__range_ii_u64 ret; | |
| ret.min_incl = min_incl; | |
| ret.max_incl = max_incl; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u64__is_empty(const wuffs_base__range_ii_u64* r) { | |
| return r->min_incl > r->max_incl; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u64__equals(const wuffs_base__range_ii_u64* r, | |
| wuffs_base__range_ii_u64 s) { | |
| return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || | |
| (wuffs_base__range_ii_u64__is_empty(r) && | |
| wuffs_base__range_ii_u64__is_empty(&s)); | |
| } | |
| static inline wuffs_base__range_ii_u64 // | |
| wuffs_base__range_ii_u64__intersect(const wuffs_base__range_ii_u64* r, | |
| wuffs_base__range_ii_u64 s) { | |
| wuffs_base__range_ii_u64 t; | |
| t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); | |
| t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl); | |
| return t; | |
| } | |
| static inline wuffs_base__range_ii_u64 // | |
| wuffs_base__range_ii_u64__unite(const wuffs_base__range_ii_u64* r, | |
| wuffs_base__range_ii_u64 s) { | |
| if (wuffs_base__range_ii_u64__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__range_ii_u64__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__range_ii_u64 t; | |
| t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl); | |
| t.max_incl = wuffs_base__u64__max(r->max_incl, s.max_incl); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u64__contains(const wuffs_base__range_ii_u64* r, | |
| uint64_t x) { | |
| return (r->min_incl <= x) && (x <= r->max_incl); | |
| } | |
| static inline bool // | |
| wuffs_base__range_ii_u64__contains_range(const wuffs_base__range_ii_u64* r, | |
| wuffs_base__range_ii_u64 s) { | |
| return wuffs_base__range_ii_u64__equals( | |
| &s, wuffs_base__range_ii_u64__intersect(r, s)); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__range_ii_u64::is_empty() const { | |
| return wuffs_base__range_ii_u64__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) const { | |
| return wuffs_base__range_ii_u64__equals(this, s); | |
| } | |
| inline wuffs_base__range_ii_u64 // | |
| wuffs_base__range_ii_u64::intersect(wuffs_base__range_ii_u64 s) const { | |
| return wuffs_base__range_ii_u64__intersect(this, s); | |
| } | |
| inline wuffs_base__range_ii_u64 // | |
| wuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) const { | |
| return wuffs_base__range_ii_u64__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u64::contains(uint64_t x) const { | |
| return wuffs_base__range_ii_u64__contains(this, x); | |
| } | |
| inline bool // | |
| wuffs_base__range_ii_u64::contains_range(wuffs_base__range_ii_u64 s) const { | |
| return wuffs_base__range_ii_u64__contains_range(this, s); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__range_ie_u64__struct { | |
| uint64_t min_incl; | |
| uint64_t max_excl; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__range_ie_u64__struct s) const; | |
| inline wuffs_base__range_ie_u64__struct intersect( | |
| wuffs_base__range_ie_u64__struct s) const; | |
| inline wuffs_base__range_ie_u64__struct unite( | |
| wuffs_base__range_ie_u64__struct s) const; | |
| inline bool contains(uint64_t x) const; | |
| inline bool contains_range(wuffs_base__range_ie_u64__struct s) const; | |
| inline uint64_t length() const; | |
| #endif // __cplusplus | |
| } wuffs_base__range_ie_u64; | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__empty_range_ie_u64() { | |
| wuffs_base__range_ie_u64 ret; | |
| ret.min_incl = 0; | |
| ret.max_excl = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__make_range_ie_u64(uint64_t min_incl, uint64_t max_excl) { | |
| wuffs_base__range_ie_u64 ret; | |
| ret.min_incl = min_incl; | |
| ret.max_excl = max_excl; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u64__is_empty(const wuffs_base__range_ie_u64* r) { | |
| return r->min_incl >= r->max_excl; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u64__equals(const wuffs_base__range_ie_u64* r, | |
| wuffs_base__range_ie_u64 s) { | |
| return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || | |
| (wuffs_base__range_ie_u64__is_empty(r) && | |
| wuffs_base__range_ie_u64__is_empty(&s)); | |
| } | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__range_ie_u64__intersect(const wuffs_base__range_ie_u64* r, | |
| wuffs_base__range_ie_u64 s) { | |
| wuffs_base__range_ie_u64 t; | |
| t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); | |
| t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl); | |
| return t; | |
| } | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__range_ie_u64__unite(const wuffs_base__range_ie_u64* r, | |
| wuffs_base__range_ie_u64 s) { | |
| if (wuffs_base__range_ie_u64__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__range_ie_u64__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__range_ie_u64 t; | |
| t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl); | |
| t.max_excl = wuffs_base__u64__max(r->max_excl, s.max_excl); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u64__contains(const wuffs_base__range_ie_u64* r, | |
| uint64_t x) { | |
| return (r->min_incl <= x) && (x < r->max_excl); | |
| } | |
| static inline bool // | |
| wuffs_base__range_ie_u64__contains_range(const wuffs_base__range_ie_u64* r, | |
| wuffs_base__range_ie_u64 s) { | |
| return wuffs_base__range_ie_u64__equals( | |
| &s, wuffs_base__range_ie_u64__intersect(r, s)); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__range_ie_u64__length(const wuffs_base__range_ie_u64* r) { | |
| return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__range_ie_u64::is_empty() const { | |
| return wuffs_base__range_ie_u64__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) const { | |
| return wuffs_base__range_ie_u64__equals(this, s); | |
| } | |
| inline wuffs_base__range_ie_u64 // | |
| wuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) const { | |
| return wuffs_base__range_ie_u64__intersect(this, s); | |
| } | |
| inline wuffs_base__range_ie_u64 // | |
| wuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) const { | |
| return wuffs_base__range_ie_u64__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u64::contains(uint64_t x) const { | |
| return wuffs_base__range_ie_u64__contains(this, x); | |
| } | |
| inline bool // | |
| wuffs_base__range_ie_u64::contains_range(wuffs_base__range_ie_u64 s) const { | |
| return wuffs_base__range_ie_u64__contains_range(this, s); | |
| } | |
| inline uint64_t // | |
| wuffs_base__range_ie_u64::length() const { | |
| return wuffs_base__range_ie_u64__length(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__rect_ii_u32__struct { | |
| uint32_t min_incl_x; | |
| uint32_t min_incl_y; | |
| uint32_t max_incl_x; | |
| uint32_t max_incl_y; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__rect_ii_u32__struct s) const; | |
| inline wuffs_base__rect_ii_u32__struct intersect( | |
| wuffs_base__rect_ii_u32__struct s) const; | |
| inline wuffs_base__rect_ii_u32__struct unite( | |
| wuffs_base__rect_ii_u32__struct s) const; | |
| inline bool contains(uint32_t x, uint32_t y) const; | |
| inline bool contains_rect(wuffs_base__rect_ii_u32__struct s) const; | |
| #endif // __cplusplus | |
| } wuffs_base__rect_ii_u32; | |
| static inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__empty_rect_ii_u32() { | |
| wuffs_base__rect_ii_u32 ret; | |
| ret.min_incl_x = 0; | |
| ret.min_incl_y = 0; | |
| ret.max_incl_x = 0; | |
| ret.max_incl_y = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__make_rect_ii_u32(uint32_t min_incl_x, | |
| uint32_t min_incl_y, | |
| uint32_t max_incl_x, | |
| uint32_t max_incl_y) { | |
| wuffs_base__rect_ii_u32 ret; | |
| ret.min_incl_x = min_incl_x; | |
| ret.min_incl_y = min_incl_y; | |
| ret.max_incl_x = max_incl_x; | |
| ret.max_incl_y = max_incl_y; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ii_u32__is_empty(const wuffs_base__rect_ii_u32* r) { | |
| return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y); | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ii_u32__equals(const wuffs_base__rect_ii_u32* r, | |
| wuffs_base__rect_ii_u32 s) { | |
| return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && | |
| r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) || | |
| (wuffs_base__rect_ii_u32__is_empty(r) && | |
| wuffs_base__rect_ii_u32__is_empty(&s)); | |
| } | |
| static inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__rect_ii_u32__intersect(const wuffs_base__rect_ii_u32* r, | |
| wuffs_base__rect_ii_u32 s) { | |
| wuffs_base__rect_ii_u32 t; | |
| t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); | |
| t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); | |
| t.max_incl_x = wuffs_base__u32__min(r->max_incl_x, s.max_incl_x); | |
| t.max_incl_y = wuffs_base__u32__min(r->max_incl_y, s.max_incl_y); | |
| return t; | |
| } | |
| static inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__rect_ii_u32__unite(const wuffs_base__rect_ii_u32* r, | |
| wuffs_base__rect_ii_u32 s) { | |
| if (wuffs_base__rect_ii_u32__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__rect_ii_u32__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__rect_ii_u32 t; | |
| t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x); | |
| t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y); | |
| t.max_incl_x = wuffs_base__u32__max(r->max_incl_x, s.max_incl_x); | |
| t.max_incl_y = wuffs_base__u32__max(r->max_incl_y, s.max_incl_y); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ii_u32__contains(const wuffs_base__rect_ii_u32* r, | |
| uint32_t x, | |
| uint32_t y) { | |
| return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) && | |
| (y <= r->max_incl_y); | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ii_u32__contains_rect(const wuffs_base__rect_ii_u32* r, | |
| wuffs_base__rect_ii_u32 s) { | |
| return wuffs_base__rect_ii_u32__equals( | |
| &s, wuffs_base__rect_ii_u32__intersect(r, s)); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__rect_ii_u32::is_empty() const { | |
| return wuffs_base__rect_ii_u32__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) const { | |
| return wuffs_base__rect_ii_u32__equals(this, s); | |
| } | |
| inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) const { | |
| return wuffs_base__rect_ii_u32__intersect(this, s); | |
| } | |
| inline wuffs_base__rect_ii_u32 // | |
| wuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) const { | |
| return wuffs_base__rect_ii_u32__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) const { | |
| return wuffs_base__rect_ii_u32__contains(this, x, y); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ii_u32::contains_rect(wuffs_base__rect_ii_u32 s) const { | |
| return wuffs_base__rect_ii_u32__contains_rect(this, s); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__rect_ie_u32__struct { | |
| uint32_t min_incl_x; | |
| uint32_t min_incl_y; | |
| uint32_t max_excl_x; | |
| uint32_t max_excl_y; | |
| #ifdef __cplusplus | |
| inline bool is_empty() const; | |
| inline bool equals(wuffs_base__rect_ie_u32__struct s) const; | |
| inline wuffs_base__rect_ie_u32__struct intersect( | |
| wuffs_base__rect_ie_u32__struct s) const; | |
| inline wuffs_base__rect_ie_u32__struct unite( | |
| wuffs_base__rect_ie_u32__struct s) const; | |
| inline bool contains(uint32_t x, uint32_t y) const; | |
| inline bool contains_rect(wuffs_base__rect_ie_u32__struct s) const; | |
| inline uint32_t width() const; | |
| inline uint32_t height() const; | |
| #endif // __cplusplus | |
| } wuffs_base__rect_ie_u32; | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__empty_rect_ie_u32() { | |
| wuffs_base__rect_ie_u32 ret; | |
| ret.min_incl_x = 0; | |
| ret.min_incl_y = 0; | |
| ret.max_excl_x = 0; | |
| ret.max_excl_y = 0; | |
| return ret; | |
| } | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__make_rect_ie_u32(uint32_t min_incl_x, | |
| uint32_t min_incl_y, | |
| uint32_t max_excl_x, | |
| uint32_t max_excl_y) { | |
| wuffs_base__rect_ie_u32 ret; | |
| ret.min_incl_x = min_incl_x; | |
| ret.min_incl_y = min_incl_y; | |
| ret.max_excl_x = max_excl_x; | |
| ret.max_excl_y = max_excl_y; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ie_u32__is_empty(const wuffs_base__rect_ie_u32* r) { | |
| return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y); | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ie_u32__equals(const wuffs_base__rect_ie_u32* r, | |
| wuffs_base__rect_ie_u32 s) { | |
| return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && | |
| r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) || | |
| (wuffs_base__rect_ie_u32__is_empty(r) && | |
| wuffs_base__rect_ie_u32__is_empty(&s)); | |
| } | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__rect_ie_u32__intersect(const wuffs_base__rect_ie_u32* r, | |
| wuffs_base__rect_ie_u32 s) { | |
| wuffs_base__rect_ie_u32 t; | |
| t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); | |
| t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); | |
| t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x); | |
| t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y); | |
| return t; | |
| } | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__rect_ie_u32__unite(const wuffs_base__rect_ie_u32* r, | |
| wuffs_base__rect_ie_u32 s) { | |
| if (wuffs_base__rect_ie_u32__is_empty(r)) { | |
| return s; | |
| } | |
| if (wuffs_base__rect_ie_u32__is_empty(&s)) { | |
| return *r; | |
| } | |
| wuffs_base__rect_ie_u32 t; | |
| t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x); | |
| t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y); | |
| t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x); | |
| t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y); | |
| return t; | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ie_u32__contains(const wuffs_base__rect_ie_u32* r, | |
| uint32_t x, | |
| uint32_t y) { | |
| return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) && | |
| (y < r->max_excl_y); | |
| } | |
| static inline bool // | |
| wuffs_base__rect_ie_u32__contains_rect(const wuffs_base__rect_ie_u32* r, | |
| wuffs_base__rect_ie_u32 s) { | |
| return wuffs_base__rect_ie_u32__equals( | |
| &s, wuffs_base__rect_ie_u32__intersect(r, s)); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__rect_ie_u32__width(const wuffs_base__rect_ie_u32* r) { | |
| return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__rect_ie_u32__height(const wuffs_base__rect_ie_u32* r) { | |
| return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__rect_ie_u32::is_empty() const { | |
| return wuffs_base__rect_ie_u32__is_empty(this); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) const { | |
| return wuffs_base__rect_ie_u32__equals(this, s); | |
| } | |
| inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) const { | |
| return wuffs_base__rect_ie_u32__intersect(this, s); | |
| } | |
| inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) const { | |
| return wuffs_base__rect_ie_u32__unite(this, s); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) const { | |
| return wuffs_base__rect_ie_u32__contains(this, x, y); | |
| } | |
| inline bool // | |
| wuffs_base__rect_ie_u32::contains_rect(wuffs_base__rect_ie_u32 s) const { | |
| return wuffs_base__rect_ie_u32__contains_rect(this, s); | |
| } | |
| inline uint32_t // | |
| wuffs_base__rect_ie_u32::width() const { | |
| return wuffs_base__rect_ie_u32__width(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__rect_ie_u32::height() const { | |
| return wuffs_base__rect_ie_u32__height(this); | |
| } | |
| #endif // __cplusplus | |
| // ---------------- More Information | |
| // wuffs_base__more_information holds additional fields, typically when a Wuffs | |
| // method returns a [note status](/doc/note/statuses.md). | |
| // | |
| // The flavor field follows the base38 namespace | |
| // convention](/doc/note/base38-and-fourcc.md). The other fields' semantics | |
| // depends on the flavor. | |
| typedef struct wuffs_base__more_information__struct { | |
| uint32_t flavor; | |
| uint32_t w; | |
| uint64_t x; | |
| uint64_t y; | |
| uint64_t z; | |
| #ifdef __cplusplus | |
| inline void set(uint32_t flavor_arg, | |
| uint32_t w_arg, | |
| uint64_t x_arg, | |
| uint64_t y_arg, | |
| uint64_t z_arg); | |
| inline uint32_t io_redirect__fourcc() const; | |
| inline wuffs_base__range_ie_u64 io_redirect__range() const; | |
| inline uint64_t io_seek__position() const; | |
| inline uint32_t metadata__fourcc() const; | |
| // Deprecated: use metadata_raw_passthrough__range. | |
| inline wuffs_base__range_ie_u64 metadata__range() const; | |
| inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const; | |
| inline int32_t metadata_parsed__chrm(uint32_t component) const; | |
| inline uint32_t metadata_parsed__gama() const; | |
| inline uint32_t metadata_parsed__srgb() const; | |
| #endif // __cplusplus | |
| } wuffs_base__more_information; | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1 | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2 | |
| // Deprecated: use | |
| // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH. | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3 | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3 | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4 | |
| #define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5 | |
| static inline wuffs_base__more_information // | |
| wuffs_base__empty_more_information() { | |
| wuffs_base__more_information ret; | |
| ret.flavor = 0; | |
| ret.w = 0; | |
| ret.x = 0; | |
| ret.y = 0; | |
| ret.z = 0; | |
| return ret; | |
| } | |
| static inline void // | |
| wuffs_base__more_information__set(wuffs_base__more_information* m, | |
| uint32_t flavor, | |
| uint32_t w, | |
| uint64_t x, | |
| uint64_t y, | |
| uint64_t z) { | |
| if (!m) { | |
| return; | |
| } | |
| m->flavor = flavor; | |
| m->w = w; | |
| m->x = x; | |
| m->y = y; | |
| m->z = z; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__more_information__io_redirect__fourcc( | |
| const wuffs_base__more_information* m) { | |
| return m->w; | |
| } | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information__io_redirect__range( | |
| const wuffs_base__more_information* m) { | |
| wuffs_base__range_ie_u64 ret; | |
| ret.min_incl = m->y; | |
| ret.max_excl = m->z; | |
| return ret; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__more_information__io_seek__position( | |
| const wuffs_base__more_information* m) { | |
| return m->x; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__more_information__metadata__fourcc( | |
| const wuffs_base__more_information* m) { | |
| return m->w; | |
| } | |
| // Deprecated: use | |
| // wuffs_base__more_information__metadata_raw_passthrough__range. | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information__metadata__range( | |
| const wuffs_base__more_information* m) { | |
| wuffs_base__range_ie_u64 ret; | |
| ret.min_incl = m->y; | |
| ret.max_excl = m->z; | |
| return ret; | |
| } | |
| static inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information__metadata_raw_passthrough__range( | |
| const wuffs_base__more_information* m) { | |
| wuffs_base__range_ie_u64 ret; | |
| ret.min_incl = m->y; | |
| ret.max_excl = m->z; | |
| return ret; | |
| } | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6 | |
| #define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7 | |
| // wuffs_base__more_information__metadata_parsed__chrm returns chromaticity | |
| // values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB | |
| // color space corresponds to: | |
| // - ETC__CHRM__WHITE_X 31270 | |
| // - ETC__CHRM__WHITE_Y 32900 | |
| // - ETC__CHRM__RED_X 64000 | |
| // - ETC__CHRM__RED_Y 33000 | |
| // - ETC__CHRM__GREEN_X 30000 | |
| // - ETC__CHRM__GREEN_Y 60000 | |
| // - ETC__CHRM__BLUE_X 15000 | |
| // - ETC__CHRM__BLUE_Y 6000 | |
| // | |
| // See | |
| // https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates | |
| static inline int32_t // | |
| wuffs_base__more_information__metadata_parsed__chrm( | |
| const wuffs_base__more_information* m, | |
| uint32_t component) { | |
| // After the flavor and the w field (holding a FourCC), a | |
| // wuffs_base__more_information holds 24 bytes of data in three uint64_t | |
| // typed fields (x, y and z). We pack the eight chromaticity values (wx, wy, | |
| // rx, ..., by), basically int24_t values, into 24 bytes like this: | |
| // - LSB MSB | |
| // - x: wx wx wx wy wy wy rx rx | |
| // - y: rx ry ry ry gx gx gx gy | |
| // - z: gy gy bx bx bx by by by | |
| uint32_t u = 0; | |
| switch (component & 7) { | |
| case 0: | |
| u = ((uint32_t)(m->x >> 0)); | |
| break; | |
| case 1: | |
| u = ((uint32_t)(m->x >> 24)); | |
| break; | |
| case 2: | |
| u = ((uint32_t)((m->x >> 48) | (m->y << 16))); | |
| break; | |
| case 3: | |
| u = ((uint32_t)(m->y >> 8)); | |
| break; | |
| case 4: | |
| u = ((uint32_t)(m->y >> 32)); | |
| break; | |
| case 5: | |
| u = ((uint32_t)((m->y >> 56) | (m->z << 8))); | |
| break; | |
| case 6: | |
| u = ((uint32_t)(m->z >> 16)); | |
| break; | |
| case 7: | |
| u = ((uint32_t)(m->z >> 40)); | |
| break; | |
| } | |
| // The left-right shifts sign-extend from 24-bit to 32-bit integers. | |
| return ((int32_t)(u << 8)) >> 8; | |
| } | |
| // wuffs_base__more_information__metadata_parsed__gama returns inverse gamma | |
| // correction values (scaled by 100000) like the PNG "gAMA" chunk. For example, | |
| // for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2). | |
| static inline uint32_t // | |
| wuffs_base__more_information__metadata_parsed__gama( | |
| const wuffs_base__more_information* m) { | |
| return ((uint32_t)(m->x)); | |
| } | |
| #define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0 | |
| #define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1 | |
| #define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2 | |
| #define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3 | |
| // wuffs_base__more_information__metadata_parsed__srgb returns the sRGB | |
| // rendering intent like the PNG "sRGB" chunk. | |
| static inline uint32_t // | |
| wuffs_base__more_information__metadata_parsed__srgb( | |
| const wuffs_base__more_information* m) { | |
| return m->x & 3; | |
| } | |
| #ifdef __cplusplus | |
| inline void // | |
| wuffs_base__more_information::set(uint32_t flavor_arg, | |
| uint32_t w_arg, | |
| uint64_t x_arg, | |
| uint64_t y_arg, | |
| uint64_t z_arg) { | |
| wuffs_base__more_information__set(this, flavor_arg, w_arg, x_arg, y_arg, | |
| z_arg); | |
| } | |
| inline uint32_t // | |
| wuffs_base__more_information::io_redirect__fourcc() const { | |
| return wuffs_base__more_information__io_redirect__fourcc(this); | |
| } | |
| inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information::io_redirect__range() const { | |
| return wuffs_base__more_information__io_redirect__range(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__more_information::io_seek__position() const { | |
| return wuffs_base__more_information__io_seek__position(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__more_information::metadata__fourcc() const { | |
| return wuffs_base__more_information__metadata__fourcc(this); | |
| } | |
| inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information::metadata__range() const { | |
| return wuffs_base__more_information__metadata__range(this); | |
| } | |
| inline wuffs_base__range_ie_u64 // | |
| wuffs_base__more_information::metadata_raw_passthrough__range() const { | |
| return wuffs_base__more_information__metadata_raw_passthrough__range(this); | |
| } | |
| inline int32_t // | |
| wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const { | |
| return wuffs_base__more_information__metadata_parsed__chrm(this, component); | |
| } | |
| inline uint32_t // | |
| wuffs_base__more_information::metadata_parsed__gama() const { | |
| return wuffs_base__more_information__metadata_parsed__gama(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__more_information::metadata_parsed__srgb() const { | |
| return wuffs_base__more_information__metadata_parsed__srgb(this); | |
| } | |
| #endif // __cplusplus | |
| // ---------------- I/O | |
| // | |
| // See (/doc/note/io-input-output.md). | |
| // wuffs_base__io_buffer_meta is the metadata for a wuffs_base__io_buffer's | |
| // data. | |
| typedef struct wuffs_base__io_buffer_meta__struct { | |
| size_t wi; // Write index. Invariant: wi <= len. | |
| size_t ri; // Read index. Invariant: ri <= wi. | |
| uint64_t pos; // Buffer position (relative to the start of stream). | |
| bool closed; // No further writes are expected. | |
| } wuffs_base__io_buffer_meta; | |
| // wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus | |
| // additional metadata. | |
| // | |
| // A value with all fields zero is a valid, empty buffer. | |
| typedef struct wuffs_base__io_buffer__struct { | |
| wuffs_base__slice_u8 data; | |
| wuffs_base__io_buffer_meta meta; | |
| #ifdef __cplusplus | |
| inline bool is_valid() const; | |
| inline void compact(); | |
| inline size_t reader_length() const; | |
| inline uint8_t* reader_pointer() const; | |
| inline uint64_t reader_position() const; | |
| inline wuffs_base__slice_u8 reader_slice() const; | |
| inline size_t writer_length() const; | |
| inline uint8_t* writer_pointer() const; | |
| inline uint64_t writer_position() const; | |
| inline wuffs_base__slice_u8 writer_slice() const; | |
| // Deprecated: use reader_position. | |
| inline uint64_t reader_io_position() const; | |
| // Deprecated: use writer_position. | |
| inline uint64_t writer_io_position() const; | |
| #endif // __cplusplus | |
| } wuffs_base__io_buffer; | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__make_io_buffer(wuffs_base__slice_u8 data, | |
| wuffs_base__io_buffer_meta meta) { | |
| wuffs_base__io_buffer ret; | |
| ret.data = data; | |
| ret.meta = meta; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer_meta // | |
| wuffs_base__make_io_buffer_meta(size_t wi, | |
| size_t ri, | |
| uint64_t pos, | |
| bool closed) { | |
| wuffs_base__io_buffer_meta ret; | |
| ret.wi = wi; | |
| ret.ri = ri; | |
| ret.pos = pos; | |
| ret.closed = closed; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__ptr_u8__reader(uint8_t* ptr, size_t len, bool closed) { | |
| wuffs_base__io_buffer ret; | |
| ret.data.ptr = ptr; | |
| ret.data.len = len; | |
| ret.meta.wi = len; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = closed; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__ptr_u8__writer(uint8_t* ptr, size_t len) { | |
| wuffs_base__io_buffer ret; | |
| ret.data.ptr = ptr; | |
| ret.data.len = len; | |
| ret.meta.wi = 0; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = false; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__slice_u8__reader(wuffs_base__slice_u8 s, bool closed) { | |
| wuffs_base__io_buffer ret; | |
| ret.data.ptr = s.ptr; | |
| ret.data.len = s.len; | |
| ret.meta.wi = s.len; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = closed; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__slice_u8__writer(wuffs_base__slice_u8 s) { | |
| wuffs_base__io_buffer ret; | |
| ret.data.ptr = s.ptr; | |
| ret.data.len = s.len; | |
| ret.meta.wi = 0; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = false; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer // | |
| wuffs_base__empty_io_buffer() { | |
| wuffs_base__io_buffer ret; | |
| ret.data.ptr = NULL; | |
| ret.data.len = 0; | |
| ret.meta.wi = 0; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = false; | |
| return ret; | |
| } | |
| static inline wuffs_base__io_buffer_meta // | |
| wuffs_base__empty_io_buffer_meta() { | |
| wuffs_base__io_buffer_meta ret; | |
| ret.wi = 0; | |
| ret.ri = 0; | |
| ret.pos = 0; | |
| ret.closed = false; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__io_buffer__is_valid(const wuffs_base__io_buffer* buf) { | |
| if (buf) { | |
| if (buf->data.ptr) { | |
| return (buf->meta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len); | |
| } else { | |
| return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0); | |
| } | |
| } | |
| return false; | |
| } | |
| // wuffs_base__io_buffer__compact moves any written but unread bytes to the | |
| // start of the buffer. | |
| static inline void // | |
| wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { | |
| if (!buf || (buf->meta.ri == 0)) { | |
| return; | |
| } | |
| buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); | |
| size_t n = buf->meta.wi - buf->meta.ri; | |
| if (n != 0) { | |
| memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n); | |
| } | |
| buf->meta.wi = n; | |
| buf->meta.ri = 0; | |
| } | |
| // Deprecated. Use wuffs_base__io_buffer__reader_position. | |
| static inline uint64_t // | |
| wuffs_base__io_buffer__reader_io_position(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0; | |
| } | |
| static inline size_t // | |
| wuffs_base__io_buffer__reader_length(const wuffs_base__io_buffer* buf) { | |
| return buf ? buf->meta.wi - buf->meta.ri : 0; | |
| } | |
| static inline uint8_t* // | |
| wuffs_base__io_buffer__reader_pointer(const wuffs_base__io_buffer* buf) { | |
| return buf ? (buf->data.ptr + buf->meta.ri) : NULL; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__io_buffer__reader_position(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0; | |
| } | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__io_buffer__reader_slice(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.ri, | |
| buf->meta.wi - buf->meta.ri) | |
| : wuffs_base__empty_slice_u8(); | |
| } | |
| // Deprecated. Use wuffs_base__io_buffer__writer_position. | |
| static inline uint64_t // | |
| wuffs_base__io_buffer__writer_io_position(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0; | |
| } | |
| static inline size_t // | |
| wuffs_base__io_buffer__writer_length(const wuffs_base__io_buffer* buf) { | |
| return buf ? buf->data.len - buf->meta.wi : 0; | |
| } | |
| static inline uint8_t* // | |
| wuffs_base__io_buffer__writer_pointer(const wuffs_base__io_buffer* buf) { | |
| return buf ? (buf->data.ptr + buf->meta.wi) : NULL; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__io_buffer__writer_position(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0; | |
| } | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__io_buffer__writer_slice(const wuffs_base__io_buffer* buf) { | |
| return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.wi, | |
| buf->data.len - buf->meta.wi) | |
| : wuffs_base__empty_slice_u8(); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__io_buffer::is_valid() const { | |
| return wuffs_base__io_buffer__is_valid(this); | |
| } | |
| inline void // | |
| wuffs_base__io_buffer::compact() { | |
| wuffs_base__io_buffer__compact(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__io_buffer::reader_io_position() const { | |
| return wuffs_base__io_buffer__reader_io_position(this); | |
| } | |
| inline size_t // | |
| wuffs_base__io_buffer::reader_length() const { | |
| return wuffs_base__io_buffer__reader_length(this); | |
| } | |
| inline uint8_t* // | |
| wuffs_base__io_buffer::reader_pointer() const { | |
| return wuffs_base__io_buffer__reader_pointer(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__io_buffer::reader_position() const { | |
| return wuffs_base__io_buffer__reader_position(this); | |
| } | |
| inline wuffs_base__slice_u8 // | |
| wuffs_base__io_buffer::reader_slice() const { | |
| return wuffs_base__io_buffer__reader_slice(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__io_buffer::writer_io_position() const { | |
| return wuffs_base__io_buffer__writer_io_position(this); | |
| } | |
| inline size_t // | |
| wuffs_base__io_buffer::writer_length() const { | |
| return wuffs_base__io_buffer__writer_length(this); | |
| } | |
| inline uint8_t* // | |
| wuffs_base__io_buffer::writer_pointer() const { | |
| return wuffs_base__io_buffer__writer_pointer(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__io_buffer::writer_position() const { | |
| return wuffs_base__io_buffer__writer_position(this); | |
| } | |
| inline wuffs_base__slice_u8 // | |
| wuffs_base__io_buffer::writer_slice() const { | |
| return wuffs_base__io_buffer__writer_slice(this); | |
| } | |
| #endif // __cplusplus | |
| // ---------------- Tokens | |
| // wuffs_base__token is an element of a byte stream's tokenization. | |
| // | |
| // See https://github.com/google/wuffs/blob/main/doc/note/tokens.md | |
| typedef struct wuffs_base__token__struct { | |
| uint64_t repr; | |
| #ifdef __cplusplus | |
| inline int64_t value() const; | |
| inline int64_t value_extension() const; | |
| inline int64_t value_major() const; | |
| inline int64_t value_base_category() const; | |
| inline uint64_t value_minor() const; | |
| inline uint64_t value_base_detail() const; | |
| inline int64_t value_base_detail__sign_extended() const; | |
| inline bool continued() const; | |
| inline uint64_t length() const; | |
| #endif // __cplusplus | |
| } wuffs_base__token; | |
| static inline wuffs_base__token // | |
| wuffs_base__make_token(uint64_t repr) { | |
| wuffs_base__token ret; | |
| ret.repr = repr; | |
| return ret; | |
| } | |
| // -------- | |
| #define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF | |
| #define WUFFS_BASE__TOKEN__VALUE__SHIFT 17 | |
| #define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17 | |
| #define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42 | |
| #define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17 | |
| #define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38 | |
| #define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17 | |
| #define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16 | |
| #define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0 | |
| #define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46 | |
| // -------- | |
| #define WUFFS_BASE__TOKEN__VBC__FILLER 0 | |
| #define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1 | |
| #define WUFFS_BASE__TOKEN__VBC__STRING 2 | |
| #define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3 | |
| #define WUFFS_BASE__TOKEN__VBC__LITERAL 4 | |
| #define WUFFS_BASE__TOKEN__VBC__NUMBER 5 | |
| #define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6 | |
| #define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7 | |
| // -------- | |
| #define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001 | |
| #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002 | |
| #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004 | |
| // COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE. | |
| #define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006 | |
| // -------- | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000 | |
| // -------- | |
| // DEFINITELY_FOO means that the destination bytes (and also the source bytes, | |
| // for 1_DST_1_SRC_COPY) are in the FOO format. Definitely means that the lack | |
| // of the bit means "maybe FOO". It does not necessarily mean "not FOO". | |
| // | |
| // CHAIN_ETC means that decoding the entire token chain forms a UTF-8 or ASCII | |
| // string, not just this current token. CHAIN_ETC_UTF_8 therefore distinguishes | |
| // Unicode (UTF-8) strings from byte strings. MUST means that the the token | |
| // producer (e.g. parser) must verify this. SHOULD means that the token | |
| // consumer (e.g. renderer) should verify this. | |
| // | |
| // When a CHAIN_ETC_UTF_8 bit is set, the parser must ensure that non-ASCII | |
| // code points (with multi-byte UTF-8 encodings) do not straddle token | |
| // boundaries. Checking UTF-8 validity can inspect each token separately. | |
| // | |
| // The lack of any particular bit is conservative: it is valid for all-ASCII | |
| // strings, in a single- or multi-token chain, to have none of these bits set. | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_UTF_8 0x00001 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040 | |
| // CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded) | |
| // produces multiples of D destination bytes. For example, | |
| // CONVERT_1_DST_4_SRC_BACKSLASH_X means a source like "\\x23\\x67\\xAB", where | |
| // 12 src bytes encode 3 dst bytes. | |
| // | |
| // Post-processing may further transform those D destination bytes (e.g. treat | |
| // "\\xFF" as the Unicode code point U+00FF instead of the byte 0xFF), but that | |
| // is out of scope of this VBD's semantics. | |
| // | |
| // When src is the empty string, multiple conversion algorithms are applicable | |
| // (so these bits are not necessarily mutually exclusive), all producing the | |
| // same empty dst string. | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000 | |
| #define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000 | |
| // -------- | |
| #define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001 | |
| #define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002 | |
| #define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004 | |
| #define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008 | |
| // -------- | |
| // For a source string of "123" or "0x9A", it is valid for a tokenizer to | |
| // return any combination of: | |
| // - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT. | |
| // - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED. | |
| // - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED. | |
| // | |
| // For a source string of "+123" or "-0x9A", only the first two are valid. | |
| // | |
| // For a source string of "123.", only the first one is valid. | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF 0x00020 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN 0x00040 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN 0x00080 | |
| // The number 300 might be represented as "\x01\x2C", "\x2C\x01\x00\x00" or | |
| // "300", which are big-endian, little-endian or text. For binary formats, the | |
| // token length (after adjusting for FORMAT_IGNORE_ETC) discriminates | |
| // e.g. u16 little-endian vs u32 little-endian. | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400 | |
| #define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000 | |
| // -------- | |
| // wuffs_base__token__value returns the token's high 46 bits, sign-extended. A | |
| // negative value means an extended token, non-negative means a simple token. | |
| static inline int64_t // | |
| wuffs_base__token__value(const wuffs_base__token* t) { | |
| return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE__SHIFT; | |
| } | |
| // wuffs_base__token__value_extension returns a negative value if the token was | |
| // not an extended token. | |
| static inline int64_t // | |
| wuffs_base__token__value_extension(const wuffs_base__token* t) { | |
| return (~(int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT; | |
| } | |
| // wuffs_base__token__value_major returns a negative value if the token was not | |
| // a simple token. | |
| static inline int64_t // | |
| wuffs_base__token__value_major(const wuffs_base__token* t) { | |
| return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT; | |
| } | |
| // wuffs_base__token__value_base_category returns a negative value if the token | |
| // was not a simple token. | |
| static inline int64_t // | |
| wuffs_base__token__value_base_category(const wuffs_base__token* t) { | |
| return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token__value_minor(const wuffs_base__token* t) { | |
| return (t->repr >> WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) & 0x1FFFFFF; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token__value_base_detail(const wuffs_base__token* t) { | |
| return (t->repr >> WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT) & 0x1FFFFF; | |
| } | |
| static inline int64_t // | |
| wuffs_base__token__value_base_detail__sign_extended( | |
| const wuffs_base__token* t) { | |
| // The VBD is 21 bits in the middle of t->repr. Left shift the high (64 - 21 | |
| // - ETC__SHIFT) bits off, then right shift (sign-extending) back down. | |
| uint64_t u = t->repr << (43 - WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT); | |
| return ((int64_t)u) >> 43; | |
| } | |
| static inline bool // | |
| wuffs_base__token__continued(const wuffs_base__token* t) { | |
| return t->repr & 0x10000; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token__length(const wuffs_base__token* t) { | |
| return (t->repr >> WUFFS_BASE__TOKEN__LENGTH__SHIFT) & 0xFFFF; | |
| } | |
| #ifdef __cplusplus | |
| inline int64_t // | |
| wuffs_base__token::value() const { | |
| return wuffs_base__token__value(this); | |
| } | |
| inline int64_t // | |
| wuffs_base__token::value_extension() const { | |
| return wuffs_base__token__value_extension(this); | |
| } | |
| inline int64_t // | |
| wuffs_base__token::value_major() const { | |
| return wuffs_base__token__value_major(this); | |
| } | |
| inline int64_t // | |
| wuffs_base__token::value_base_category() const { | |
| return wuffs_base__token__value_base_category(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token::value_minor() const { | |
| return wuffs_base__token__value_minor(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token::value_base_detail() const { | |
| return wuffs_base__token__value_base_detail(this); | |
| } | |
| inline int64_t // | |
| wuffs_base__token::value_base_detail__sign_extended() const { | |
| return wuffs_base__token__value_base_detail__sign_extended(this); | |
| } | |
| inline bool // | |
| wuffs_base__token::continued() const { | |
| return wuffs_base__token__continued(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token::length() const { | |
| return wuffs_base__token__length(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef WUFFS_BASE__SLICE(wuffs_base__token) wuffs_base__slice_token; | |
| static inline wuffs_base__slice_token // | |
| wuffs_base__make_slice_token(wuffs_base__token* ptr, size_t len) { | |
| wuffs_base__slice_token ret; | |
| ret.ptr = ptr; | |
| ret.len = len; | |
| return ret; | |
| } | |
| static inline wuffs_base__slice_token // | |
| wuffs_base__empty_slice_token() { | |
| wuffs_base__slice_token ret; | |
| ret.ptr = NULL; | |
| ret.len = 0; | |
| return ret; | |
| } | |
| // -------- | |
| // wuffs_base__token_buffer_meta is the metadata for a | |
| // wuffs_base__token_buffer's data. | |
| typedef struct wuffs_base__token_buffer_meta__struct { | |
| size_t wi; // Write index. Invariant: wi <= len. | |
| size_t ri; // Read index. Invariant: ri <= wi. | |
| uint64_t pos; // Position of the buffer start relative to the stream start. | |
| bool closed; // No further writes are expected. | |
| } wuffs_base__token_buffer_meta; | |
| // wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length) | |
| // plus additional metadata. | |
| // | |
| // A value with all fields zero is a valid, empty buffer. | |
| typedef struct wuffs_base__token_buffer__struct { | |
| wuffs_base__slice_token data; | |
| wuffs_base__token_buffer_meta meta; | |
| #ifdef __cplusplus | |
| inline bool is_valid() const; | |
| inline void compact(); | |
| inline uint64_t reader_length() const; | |
| inline wuffs_base__token* reader_pointer() const; | |
| inline wuffs_base__slice_token reader_slice() const; | |
| inline uint64_t reader_token_position() const; | |
| inline uint64_t writer_length() const; | |
| inline uint64_t writer_token_position() const; | |
| inline wuffs_base__token* writer_pointer() const; | |
| inline wuffs_base__slice_token writer_slice() const; | |
| #endif // __cplusplus | |
| } wuffs_base__token_buffer; | |
| static inline wuffs_base__token_buffer // | |
| wuffs_base__make_token_buffer(wuffs_base__slice_token data, | |
| wuffs_base__token_buffer_meta meta) { | |
| wuffs_base__token_buffer ret; | |
| ret.data = data; | |
| ret.meta = meta; | |
| return ret; | |
| } | |
| static inline wuffs_base__token_buffer_meta // | |
| wuffs_base__make_token_buffer_meta(size_t wi, | |
| size_t ri, | |
| uint64_t pos, | |
| bool closed) { | |
| wuffs_base__token_buffer_meta ret; | |
| ret.wi = wi; | |
| ret.ri = ri; | |
| ret.pos = pos; | |
| ret.closed = closed; | |
| return ret; | |
| } | |
| static inline wuffs_base__token_buffer // | |
| wuffs_base__slice_token__reader(wuffs_base__slice_token s, bool closed) { | |
| wuffs_base__token_buffer ret; | |
| ret.data.ptr = s.ptr; | |
| ret.data.len = s.len; | |
| ret.meta.wi = s.len; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = closed; | |
| return ret; | |
| } | |
| static inline wuffs_base__token_buffer // | |
| wuffs_base__slice_token__writer(wuffs_base__slice_token s) { | |
| wuffs_base__token_buffer ret; | |
| ret.data.ptr = s.ptr; | |
| ret.data.len = s.len; | |
| ret.meta.wi = 0; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = false; | |
| return ret; | |
| } | |
| static inline wuffs_base__token_buffer // | |
| wuffs_base__empty_token_buffer() { | |
| wuffs_base__token_buffer ret; | |
| ret.data.ptr = NULL; | |
| ret.data.len = 0; | |
| ret.meta.wi = 0; | |
| ret.meta.ri = 0; | |
| ret.meta.pos = 0; | |
| ret.meta.closed = false; | |
| return ret; | |
| } | |
| static inline wuffs_base__token_buffer_meta // | |
| wuffs_base__empty_token_buffer_meta() { | |
| wuffs_base__token_buffer_meta ret; | |
| ret.wi = 0; | |
| ret.ri = 0; | |
| ret.pos = 0; | |
| ret.closed = false; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__token_buffer__is_valid(const wuffs_base__token_buffer* buf) { | |
| if (buf) { | |
| if (buf->data.ptr) { | |
| return (buf->meta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len); | |
| } else { | |
| return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0); | |
| } | |
| } | |
| return false; | |
| } | |
| // wuffs_base__token_buffer__compact moves any written but unread tokens to the | |
| // start of the buffer. | |
| static inline void // | |
| wuffs_base__token_buffer__compact(wuffs_base__token_buffer* buf) { | |
| if (!buf || (buf->meta.ri == 0)) { | |
| return; | |
| } | |
| buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri); | |
| size_t n = buf->meta.wi - buf->meta.ri; | |
| if (n != 0) { | |
| memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, | |
| n * sizeof(wuffs_base__token)); | |
| } | |
| buf->meta.wi = n; | |
| buf->meta.ri = 0; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token_buffer__reader_length(const wuffs_base__token_buffer* buf) { | |
| return buf ? buf->meta.wi - buf->meta.ri : 0; | |
| } | |
| static inline wuffs_base__token* // | |
| wuffs_base__token_buffer__reader_pointer(const wuffs_base__token_buffer* buf) { | |
| return buf ? (buf->data.ptr + buf->meta.ri) : NULL; | |
| } | |
| static inline wuffs_base__slice_token // | |
| wuffs_base__token_buffer__reader_slice(const wuffs_base__token_buffer* buf) { | |
| return buf ? wuffs_base__make_slice_token(buf->data.ptr + buf->meta.ri, | |
| buf->meta.wi - buf->meta.ri) | |
| : wuffs_base__empty_slice_token(); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token_buffer__reader_token_position( | |
| const wuffs_base__token_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token_buffer__writer_length(const wuffs_base__token_buffer* buf) { | |
| return buf ? buf->data.len - buf->meta.wi : 0; | |
| } | |
| static inline wuffs_base__token* // | |
| wuffs_base__token_buffer__writer_pointer(const wuffs_base__token_buffer* buf) { | |
| return buf ? (buf->data.ptr + buf->meta.wi) : NULL; | |
| } | |
| static inline wuffs_base__slice_token // | |
| wuffs_base__token_buffer__writer_slice(const wuffs_base__token_buffer* buf) { | |
| return buf ? wuffs_base__make_slice_token(buf->data.ptr + buf->meta.wi, | |
| buf->data.len - buf->meta.wi) | |
| : wuffs_base__empty_slice_token(); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__token_buffer__writer_token_position( | |
| const wuffs_base__token_buffer* buf) { | |
| return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0; | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__token_buffer::is_valid() const { | |
| return wuffs_base__token_buffer__is_valid(this); | |
| } | |
| inline void // | |
| wuffs_base__token_buffer::compact() { | |
| wuffs_base__token_buffer__compact(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token_buffer::reader_length() const { | |
| return wuffs_base__token_buffer__reader_length(this); | |
| } | |
| inline wuffs_base__token* // | |
| wuffs_base__token_buffer::reader_pointer() const { | |
| return wuffs_base__token_buffer__reader_pointer(this); | |
| } | |
| inline wuffs_base__slice_token // | |
| wuffs_base__token_buffer::reader_slice() const { | |
| return wuffs_base__token_buffer__reader_slice(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token_buffer::reader_token_position() const { | |
| return wuffs_base__token_buffer__reader_token_position(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token_buffer::writer_length() const { | |
| return wuffs_base__token_buffer__writer_length(this); | |
| } | |
| inline wuffs_base__token* // | |
| wuffs_base__token_buffer::writer_pointer() const { | |
| return wuffs_base__token_buffer__writer_pointer(this); | |
| } | |
| inline wuffs_base__slice_token // | |
| wuffs_base__token_buffer::writer_slice() const { | |
| return wuffs_base__token_buffer__writer_slice(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__token_buffer::writer_token_position() const { | |
| return wuffs_base__token_buffer__writer_token_position(this); | |
| } | |
| #endif // __cplusplus | |
| // ---------------- Memory Allocation | |
| // The memory allocation related functions in this section aren't used by Wuffs | |
| // per se, but they may be helpful to the code that uses Wuffs. | |
| // wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except | |
| // that it takes a uint64_t number of elements instead of a size_t size in | |
| // bytes, and it returns a slice (a pointer and a length) instead of just a | |
| // pointer. | |
| // | |
| // You can pass the C stdlib's malloc as the malloc_func. | |
| // | |
| // It returns an empty slice (containing a NULL ptr field) if (num_uxx * | |
| // sizeof(uintxx_t)) would overflow SIZE_MAX. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) { | |
| if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) { | |
| void* p = (*malloc_func)((size_t)(num_u8 * sizeof(uint8_t))); | |
| if (p) { | |
| return wuffs_base__make_slice_u8((uint8_t*)(p), (size_t)num_u8); | |
| } | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| static inline wuffs_base__slice_u16 // | |
| wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) { | |
| if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) { | |
| void* p = (*malloc_func)((size_t)(num_u16 * sizeof(uint16_t))); | |
| if (p) { | |
| return wuffs_base__make_slice_u16((uint16_t*)(p), (size_t)num_u16); | |
| } | |
| } | |
| return wuffs_base__make_slice_u16(NULL, 0); | |
| } | |
| static inline wuffs_base__slice_u32 // | |
| wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) { | |
| if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) { | |
| void* p = (*malloc_func)((size_t)(num_u32 * sizeof(uint32_t))); | |
| if (p) { | |
| return wuffs_base__make_slice_u32((uint32_t*)(p), (size_t)num_u32); | |
| } | |
| } | |
| return wuffs_base__make_slice_u32(NULL, 0); | |
| } | |
| static inline wuffs_base__slice_u64 // | |
| wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) { | |
| if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) { | |
| void* p = (*malloc_func)((size_t)(num_u64 * sizeof(uint64_t))); | |
| if (p) { | |
| return wuffs_base__make_slice_u64((uint64_t*)(p), (size_t)num_u64); | |
| } | |
| } | |
| return wuffs_base__make_slice_u64(NULL, 0); | |
| } | |
| // ---------------- Images | |
| // wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied | |
| // Alpha, Red, Green, Blue color, as a uint32_t value. Its value is always | |
| // 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness. | |
| typedef uint32_t wuffs_base__color_u32_argb_premul; | |
| // wuffs_base__color_u32_argb_premul__is_valid returns whether c's Red, Green | |
| // and Blue channels are all less than or equal to its Alpha channel. c uses | |
| // premultiplied alpha, so 50% opaque 100% saturated red is 0x7F7F_0000 and a | |
| // value like 0x7F80_0000 is invalid. | |
| static inline bool // | |
| wuffs_base__color_u32_argb_premul__is_valid( | |
| wuffs_base__color_u32_argb_premul c) { | |
| uint32_t a = 0xFF & (c >> 24); | |
| uint32_t r = 0xFF & (c >> 16); | |
| uint32_t g = 0xFF & (c >> 8); | |
| uint32_t b = 0xFF & (c >> 0); | |
| return (a >= r) && (a >= g) && (a >= b); | |
| } | |
| static inline uint16_t // | |
| wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565( | |
| wuffs_base__color_u32_argb_premul c) { | |
| uint32_t r5 = 0xF800 & (c >> 8); | |
| uint32_t g6 = 0x07E0 & (c >> 5); | |
| uint32_t b5 = 0x001F & (c >> 3); | |
| return (uint16_t)(r5 | g6 | b5); | |
| } | |
| static inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) { | |
| uint32_t b5 = 0x1F & (rgb_565 >> 0); | |
| uint32_t b = (b5 << 3) | (b5 >> 2); | |
| uint32_t g6 = 0x3F & (rgb_565 >> 5); | |
| uint32_t g = (g6 << 2) | (g6 >> 4); | |
| uint32_t r5 = 0x1F & (rgb_565 >> 11); | |
| uint32_t r = (r5 << 3) | (r5 >> 2); | |
| return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); | |
| } | |
| static inline uint8_t // | |
| wuffs_base__color_u32_argb_premul__as__color_u8_gray( | |
| wuffs_base__color_u32_argb_premul c) { | |
| // Work in 16-bit color. | |
| uint32_t cr = 0x101 * (0xFF & (c >> 16)); | |
| uint32_t cg = 0x101 * (0xFF & (c >> 8)); | |
| uint32_t cb = 0x101 * (0xFF & (c >> 0)); | |
| // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same | |
| // as those given by the JFIF specification. | |
| // | |
| // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We | |
| // shift by 24, not just by 16, because the return value is 8-bit color, not | |
| // 16-bit color. | |
| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; | |
| return (uint8_t)(weighted_average >> 24); | |
| } | |
| static inline uint16_t // | |
| wuffs_base__color_u32_argb_premul__as__color_u16_gray( | |
| wuffs_base__color_u32_argb_premul c) { | |
| // Work in 16-bit color. | |
| uint32_t cr = 0x101 * (0xFF & (c >> 16)); | |
| uint32_t cg = 0x101 * (0xFF & (c >> 8)); | |
| uint32_t cb = 0x101 * (0xFF & (c >> 0)); | |
| // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same | |
| // as those given by the JFIF specification. | |
| // | |
| // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). | |
| uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768; | |
| return (uint16_t)(weighted_average >> 16); | |
| } | |
| // wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul converts | |
| // from non-premultiplied alpha to premultiplied alpha. | |
| static inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( | |
| uint32_t argb_nonpremul) { | |
| // Multiplying by 0x101 (twice, once for alpha and once for color) converts | |
| // from 8-bit to 16-bit color. Shifting right by 8 undoes that. | |
| // | |
| // Working in the higher bit depth can produce slightly different (and | |
| // arguably slightly more accurate) results. For example, given 8-bit blue | |
| // and alpha of 0x80 and 0x81: | |
| // | |
| // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40 | |
| // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41 | |
| uint32_t a = 0xFF & (argb_nonpremul >> 24); | |
| uint32_t a16 = a * (0x101 * 0x101); | |
| uint32_t r = 0xFF & (argb_nonpremul >> 16); | |
| r = ((r * a16) / 0xFFFF) >> 8; | |
| uint32_t g = 0xFF & (argb_nonpremul >> 8); | |
| g = ((g * a16) / 0xFFFF) >> 8; | |
| uint32_t b = 0xFF & (argb_nonpremul >> 0); | |
| b = ((b * a16) / 0xFFFF) >> 8; | |
| return (a << 24) | (r << 16) | (g << 8) | (b << 0); | |
| } | |
| // wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul converts | |
| // from premultiplied alpha to non-premultiplied alpha. | |
| static inline uint32_t // | |
| wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul( | |
| wuffs_base__color_u32_argb_premul c) { | |
| uint32_t a = 0xFF & (c >> 24); | |
| if (a == 0xFF) { | |
| return c; | |
| } else if (a == 0) { | |
| return 0; | |
| } | |
| uint32_t a16 = a * 0x101; | |
| uint32_t r = 0xFF & (c >> 16); | |
| r = ((r * (0x101 * 0xFFFF)) / a16) >> 8; | |
| uint32_t g = 0xFF & (c >> 8); | |
| g = ((g * (0x101 * 0xFFFF)) / a16) >> 8; | |
| uint32_t b = 0xFF & (c >> 0); | |
| b = ((b * (0x101 * 0xFFFF)) / a16) >> 8; | |
| return (a << 24) | (r << 16) | (g << 8) | (b << 0); | |
| } | |
| // wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul converts | |
| // from 4x16LE non-premultiplied alpha to 4x8 premultiplied alpha. | |
| static inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul( | |
| uint64_t argb_nonpremul) { | |
| uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); | |
| uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); | |
| r16 = (r16 * a16) / 0xFFFF; | |
| uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); | |
| g16 = (g16 * a16) / 0xFFFF; | |
| uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); | |
| b16 = (b16 * a16) / 0xFFFF; | |
| return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) | | |
| ((b16 >> 8) << 0); | |
| } | |
| // wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul converts | |
| // from 4x8 premultiplied alpha to 4x16LE non-premultiplied alpha. | |
| static inline uint64_t // | |
| wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( | |
| wuffs_base__color_u32_argb_premul c) { | |
| uint32_t a = 0xFF & (c >> 24); | |
| if (a == 0xFF) { | |
| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); | |
| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); | |
| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); | |
| return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0); | |
| } else if (a == 0) { | |
| return 0; | |
| } | |
| uint64_t a16 = a * 0x101; | |
| uint64_t r = 0xFF & (c >> 16); | |
| uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16; | |
| uint64_t g = 0xFF & (c >> 8); | |
| uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16; | |
| uint64_t b = 0xFF & (c >> 0); | |
| uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16; | |
| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__color_u32__as__color_u64(uint32_t c) { | |
| uint64_t a16 = 0x101 * (0xFF & (c >> 24)); | |
| uint64_t r16 = 0x101 * (0xFF & (c >> 16)); | |
| uint64_t g16 = 0x101 * (0xFF & (c >> 8)); | |
| uint64_t b16 = 0x101 * (0xFF & (c >> 0)); | |
| return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__color_u64__as__color_u32(uint64_t c) { | |
| uint32_t a = ((uint32_t)(0xFF & (c >> 56))); | |
| uint32_t r = ((uint32_t)(0xFF & (c >> 40))); | |
| uint32_t g = ((uint32_t)(0xFF & (c >> 24))); | |
| uint32_t b = ((uint32_t)(0xFF & (c >> 8))); | |
| return (a << 24) | (r << 16) | (g << 8) | (b << 0); | |
| } | |
| // -------- | |
| typedef uint8_t wuffs_base__pixel_blend; | |
| // wuffs_base__pixel_blend encodes how to blend source and destination pixels, | |
| // accounting for transparency. It encompasses the Porter-Duff compositing | |
| // operators as well as the other blending modes defined by PDF. | |
| // | |
| // TODO: implement the other modes. | |
| #define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) | |
| #define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) | |
| // -------- | |
| // wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel | |
| // model. It is a property of the pixel format in general, not of a specific | |
| // pixel. An RGBA pixel format (with alpha) can still have fully opaque pixels. | |
| typedef uint32_t wuffs_base__pixel_alpha_transparency; | |
| #define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE 0 | |
| #define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA 1 | |
| #define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__PREMULTIPLIED_ALPHA 2 | |
| #define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__BINARY_ALPHA 3 | |
| // Deprecated: use WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA | |
| // instead. | |
| #define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NON_PREMULTIPLIED_ALPHA 1 | |
| // -------- | |
| #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0 | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3 | |
| // A palette is 256 entries × 4 bytes per entry (e.g. BGRA). | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024 | |
| // wuffs_base__pixel_format encodes the format of the bytes that constitute an | |
| // image frame's pixel data. | |
| // | |
| // See https://github.com/google/wuffs/blob/main/doc/note/pixel-formats.md | |
| // | |
| // Do not manipulate its bits directly; they are private implementation | |
| // details. Use methods such as wuffs_base__pixel_format__num_planes instead. | |
| typedef struct wuffs_base__pixel_format__struct { | |
| uint32_t repr; | |
| #ifdef __cplusplus | |
| inline bool is_valid() const; | |
| inline uint32_t bits_per_pixel() const; | |
| inline bool is_direct() const; | |
| inline bool is_indexed() const; | |
| inline bool is_interleaved() const; | |
| inline bool is_planar() const; | |
| inline uint32_t num_planes() const; | |
| inline wuffs_base__pixel_alpha_transparency transparency() const; | |
| #endif // __cplusplus | |
| } wuffs_base__pixel_format; | |
| static inline wuffs_base__pixel_format // | |
| wuffs_base__make_pixel_format(uint32_t repr) { | |
| wuffs_base__pixel_format f; | |
| f.repr = repr; | |
| return f; | |
| } | |
| // Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid | |
| // wuffs_base__pixel_format values are present. | |
| #define WUFFS_BASE__PIXEL_FORMAT__INVALID 0x00000000 | |
| #define WUFFS_BASE__PIXEL_FORMAT__A 0x02000008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B | |
| #define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B | |
| #define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL 0x22000008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCBCR 0x40020888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL 0x41038888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCBCRK 0x50038888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCOCG 0x60020888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL 0x61038888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__YCOCGK 0x70038888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY 0xA3008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__CMY 0xC0020888 | |
| #define WUFFS_BASE__PIXEL_FORMAT__CMYK 0xD0038888 | |
| extern const uint32_t wuffs_base__pixel_format__bits_per_channel[16]; | |
| static inline bool // | |
| wuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) { | |
| return f->repr != 0; | |
| } | |
| // wuffs_base__pixel_format__bits_per_pixel returns the number of bits per | |
| // pixel for interleaved pixel formats, and returns 0 for planar pixel formats. | |
| static inline uint32_t // | |
| wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) { | |
| if (((f->repr >> 16) & 0x03) != 0) { | |
| return 0; | |
| } | |
| return wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 0)] + | |
| wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 4)] + | |
| wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 8)] + | |
| wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 12)]; | |
| } | |
| static inline bool // | |
| wuffs_base__pixel_format__is_direct(const wuffs_base__pixel_format* f) { | |
| return ((f->repr >> 18) & 0x01) == 0; | |
| } | |
| static inline bool // | |
| wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { | |
| return ((f->repr >> 18) & 0x01) != 0; | |
| } | |
| static inline bool // | |
| wuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) { | |
| return ((f->repr >> 16) & 0x03) == 0; | |
| } | |
| static inline bool // | |
| wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { | |
| return ((f->repr >> 16) & 0x03) != 0; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) { | |
| return ((f->repr >> 16) & 0x03) + 1; | |
| } | |
| static inline wuffs_base__pixel_alpha_transparency // | |
| wuffs_base__pixel_format__transparency(const wuffs_base__pixel_format* f) { | |
| return (wuffs_base__pixel_alpha_transparency)((f->repr >> 24) & 0x03); | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__pixel_format::is_valid() const { | |
| return wuffs_base__pixel_format__is_valid(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_format::bits_per_pixel() const { | |
| return wuffs_base__pixel_format__bits_per_pixel(this); | |
| } | |
| inline bool // | |
| wuffs_base__pixel_format::is_direct() const { | |
| return wuffs_base__pixel_format__is_direct(this); | |
| } | |
| inline bool // | |
| wuffs_base__pixel_format::is_indexed() const { | |
| return wuffs_base__pixel_format__is_indexed(this); | |
| } | |
| inline bool // | |
| wuffs_base__pixel_format::is_interleaved() const { | |
| return wuffs_base__pixel_format__is_interleaved(this); | |
| } | |
| inline bool // | |
| wuffs_base__pixel_format::is_planar() const { | |
| return wuffs_base__pixel_format__is_planar(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_format::num_planes() const { | |
| return wuffs_base__pixel_format__num_planes(this); | |
| } | |
| inline wuffs_base__pixel_alpha_transparency // | |
| wuffs_base__pixel_format::transparency() const { | |
| return wuffs_base__pixel_format__transparency(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| // wuffs_base__pixel_subsampling encodes whether sample values cover one pixel | |
| // or cover multiple pixels. | |
| // | |
| // See https://github.com/google/wuffs/blob/main/doc/note/pixel-subsampling.md | |
| // | |
| // Do not manipulate its bits directly; they are private implementation | |
| // details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead. | |
| typedef struct wuffs_base__pixel_subsampling__struct { | |
| uint32_t repr; | |
| #ifdef __cplusplus | |
| inline uint32_t bias_x(uint32_t plane) const; | |
| inline uint32_t denominator_x(uint32_t plane) const; | |
| inline uint32_t bias_y(uint32_t plane) const; | |
| inline uint32_t denominator_y(uint32_t plane) const; | |
| #endif // __cplusplus | |
| } wuffs_base__pixel_subsampling; | |
| static inline wuffs_base__pixel_subsampling // | |
| wuffs_base__make_pixel_subsampling(uint32_t repr) { | |
| wuffs_base__pixel_subsampling s; | |
| s.repr = repr; | |
| return s; | |
| } | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE 0x00000000 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__444 0x000000 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__440 0x010100 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__422 0x101000 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__420 0x111100 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__411 0x303000 | |
| #define WUFFS_BASE__PIXEL_SUBSAMPLING__410 0x313100 | |
| static inline uint32_t // | |
| wuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s, | |
| uint32_t plane) { | |
| uint32_t shift = ((plane & 0x03) * 8) + 6; | |
| return (s->repr >> shift) & 0x03; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_subsampling__denominator_x( | |
| const wuffs_base__pixel_subsampling* s, | |
| uint32_t plane) { | |
| uint32_t shift = ((plane & 0x03) * 8) + 4; | |
| return ((s->repr >> shift) & 0x03) + 1; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s, | |
| uint32_t plane) { | |
| uint32_t shift = ((plane & 0x03) * 8) + 2; | |
| return (s->repr >> shift) & 0x03; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_subsampling__denominator_y( | |
| const wuffs_base__pixel_subsampling* s, | |
| uint32_t plane) { | |
| uint32_t shift = ((plane & 0x03) * 8) + 0; | |
| return ((s->repr >> shift) & 0x03) + 1; | |
| } | |
| #ifdef __cplusplus | |
| inline uint32_t // | |
| wuffs_base__pixel_subsampling::bias_x(uint32_t plane) const { | |
| return wuffs_base__pixel_subsampling__bias_x(this, plane); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_subsampling::denominator_x(uint32_t plane) const { | |
| return wuffs_base__pixel_subsampling__denominator_x(this, plane); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_subsampling::bias_y(uint32_t plane) const { | |
| return wuffs_base__pixel_subsampling__bias_y(this, plane); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_subsampling::denominator_y(uint32_t plane) const { | |
| return wuffs_base__pixel_subsampling__denominator_y(this, plane); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__pixel_config__struct { | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| wuffs_base__pixel_format pixfmt; | |
| wuffs_base__pixel_subsampling pixsub; | |
| uint32_t width; | |
| uint32_t height; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| inline void set(uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height); | |
| inline void invalidate(); | |
| inline bool is_valid() const; | |
| inline wuffs_base__pixel_format pixel_format() const; | |
| inline wuffs_base__pixel_subsampling pixel_subsampling() const; | |
| inline wuffs_base__rect_ie_u32 bounds() const; | |
| inline uint32_t width() const; | |
| inline uint32_t height() const; | |
| inline uint64_t pixbuf_len() const; | |
| #endif // __cplusplus | |
| } wuffs_base__pixel_config; | |
| static inline wuffs_base__pixel_config // | |
| wuffs_base__null_pixel_config() { | |
| wuffs_base__pixel_config ret; | |
| ret.private_impl.pixfmt.repr = 0; | |
| ret.private_impl.pixsub.repr = 0; | |
| ret.private_impl.width = 0; | |
| ret.private_impl.height = 0; | |
| return ret; | |
| } | |
| // TODO: Should this function return bool? An error type? | |
| static inline void // | |
| wuffs_base__pixel_config__set(wuffs_base__pixel_config* c, | |
| uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height) { | |
| if (!c) { | |
| return; | |
| } | |
| if (pixfmt_repr) { | |
| uint64_t wh = ((uint64_t)width) * ((uint64_t)height); | |
| // TODO: handle things other than 1 byte per pixel. | |
| if (wh <= ((uint64_t)SIZE_MAX)) { | |
| c->private_impl.pixfmt.repr = pixfmt_repr; | |
| c->private_impl.pixsub.repr = pixsub_repr; | |
| c->private_impl.width = width; | |
| c->private_impl.height = height; | |
| return; | |
| } | |
| } | |
| c->private_impl.pixfmt.repr = 0; | |
| c->private_impl.pixsub.repr = 0; | |
| c->private_impl.width = 0; | |
| c->private_impl.height = 0; | |
| } | |
| static inline void // | |
| wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) { | |
| if (c) { | |
| c->private_impl.pixfmt.repr = 0; | |
| c->private_impl.pixsub.repr = 0; | |
| c->private_impl.width = 0; | |
| c->private_impl.height = 0; | |
| } | |
| } | |
| static inline bool // | |
| wuffs_base__pixel_config__is_valid(const wuffs_base__pixel_config* c) { | |
| return c && c->private_impl.pixfmt.repr; | |
| } | |
| static inline wuffs_base__pixel_format // | |
| wuffs_base__pixel_config__pixel_format(const wuffs_base__pixel_config* c) { | |
| return c ? c->private_impl.pixfmt : wuffs_base__make_pixel_format(0); | |
| } | |
| static inline wuffs_base__pixel_subsampling // | |
| wuffs_base__pixel_config__pixel_subsampling(const wuffs_base__pixel_config* c) { | |
| return c ? c->private_impl.pixsub : wuffs_base__make_pixel_subsampling(0); | |
| } | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__pixel_config__bounds(const wuffs_base__pixel_config* c) { | |
| if (c) { | |
| wuffs_base__rect_ie_u32 ret; | |
| ret.min_incl_x = 0; | |
| ret.min_incl_y = 0; | |
| ret.max_excl_x = c->private_impl.width; | |
| ret.max_excl_y = c->private_impl.height; | |
| return ret; | |
| } | |
| wuffs_base__rect_ie_u32 ret; | |
| ret.min_incl_x = 0; | |
| ret.min_incl_y = 0; | |
| ret.max_excl_x = 0; | |
| ret.max_excl_y = 0; | |
| return ret; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) { | |
| return c ? c->private_impl.width : 0; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) { | |
| return c ? c->private_impl.height : 0; | |
| } | |
| // TODO: this is the right API for planar (not interleaved) pixbufs? Should it | |
| // allow decoding into a color model different from the format's intrinsic one? | |
| // For example, decoding a JPEG image straight to RGBA instead of to YCbCr? | |
| static inline uint64_t // | |
| wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { | |
| if (!c) { | |
| return 0; | |
| } | |
| if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { | |
| // TODO: support planar pixel formats, concious of pixel subsampling. | |
| return 0; | |
| } | |
| uint32_t bits_per_pixel = | |
| wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); | |
| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { | |
| // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? | |
| return 0; | |
| } | |
| uint64_t bytes_per_pixel = bits_per_pixel / 8; | |
| uint64_t n = | |
| ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); | |
| if (n > (UINT64_MAX / bytes_per_pixel)) { | |
| return 0; | |
| } | |
| n *= bytes_per_pixel; | |
| if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { | |
| if (n > | |
| (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) { | |
| return 0; | |
| } | |
| n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| } | |
| return n; | |
| } | |
| #ifdef __cplusplus | |
| inline void // | |
| wuffs_base__pixel_config::set(uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height) { | |
| wuffs_base__pixel_config__set(this, pixfmt_repr, pixsub_repr, width, height); | |
| } | |
| inline void // | |
| wuffs_base__pixel_config::invalidate() { | |
| wuffs_base__pixel_config__invalidate(this); | |
| } | |
| inline bool // | |
| wuffs_base__pixel_config::is_valid() const { | |
| return wuffs_base__pixel_config__is_valid(this); | |
| } | |
| inline wuffs_base__pixel_format // | |
| wuffs_base__pixel_config::pixel_format() const { | |
| return wuffs_base__pixel_config__pixel_format(this); | |
| } | |
| inline wuffs_base__pixel_subsampling // | |
| wuffs_base__pixel_config::pixel_subsampling() const { | |
| return wuffs_base__pixel_config__pixel_subsampling(this); | |
| } | |
| inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__pixel_config::bounds() const { | |
| return wuffs_base__pixel_config__bounds(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_config::width() const { | |
| return wuffs_base__pixel_config__width(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__pixel_config::height() const { | |
| return wuffs_base__pixel_config__height(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__pixel_config::pixbuf_len() const { | |
| return wuffs_base__pixel_config__pixbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__image_config__struct { | |
| wuffs_base__pixel_config pixcfg; | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| uint64_t first_frame_io_position; | |
| bool first_frame_is_opaque; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| inline void set(uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height, | |
| uint64_t first_frame_io_position, | |
| bool first_frame_is_opaque); | |
| inline void invalidate(); | |
| inline bool is_valid() const; | |
| inline uint64_t first_frame_io_position() const; | |
| inline bool first_frame_is_opaque() const; | |
| #endif // __cplusplus | |
| } wuffs_base__image_config; | |
| static inline wuffs_base__image_config // | |
| wuffs_base__null_image_config() { | |
| wuffs_base__image_config ret; | |
| ret.pixcfg = wuffs_base__null_pixel_config(); | |
| ret.private_impl.first_frame_io_position = 0; | |
| ret.private_impl.first_frame_is_opaque = false; | |
| return ret; | |
| } | |
| // TODO: Should this function return bool? An error type? | |
| static inline void // | |
| wuffs_base__image_config__set(wuffs_base__image_config* c, | |
| uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height, | |
| uint64_t first_frame_io_position, | |
| bool first_frame_is_opaque) { | |
| if (!c) { | |
| return; | |
| } | |
| if (pixfmt_repr) { | |
| c->pixcfg.private_impl.pixfmt.repr = pixfmt_repr; | |
| c->pixcfg.private_impl.pixsub.repr = pixsub_repr; | |
| c->pixcfg.private_impl.width = width; | |
| c->pixcfg.private_impl.height = height; | |
| c->private_impl.first_frame_io_position = first_frame_io_position; | |
| c->private_impl.first_frame_is_opaque = first_frame_is_opaque; | |
| return; | |
| } | |
| c->pixcfg.private_impl.pixfmt.repr = 0; | |
| c->pixcfg.private_impl.pixsub.repr = 0; | |
| c->pixcfg.private_impl.width = 0; | |
| c->pixcfg.private_impl.height = 0; | |
| c->private_impl.first_frame_io_position = 0; | |
| c->private_impl.first_frame_is_opaque = 0; | |
| } | |
| static inline void // | |
| wuffs_base__image_config__invalidate(wuffs_base__image_config* c) { | |
| if (c) { | |
| c->pixcfg.private_impl.pixfmt.repr = 0; | |
| c->pixcfg.private_impl.pixsub.repr = 0; | |
| c->pixcfg.private_impl.width = 0; | |
| c->pixcfg.private_impl.height = 0; | |
| c->private_impl.first_frame_io_position = 0; | |
| c->private_impl.first_frame_is_opaque = 0; | |
| } | |
| } | |
| static inline bool // | |
| wuffs_base__image_config__is_valid(const wuffs_base__image_config* c) { | |
| return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg)); | |
| } | |
| static inline uint64_t // | |
| wuffs_base__image_config__first_frame_io_position( | |
| const wuffs_base__image_config* c) { | |
| return c ? c->private_impl.first_frame_io_position : 0; | |
| } | |
| static inline bool // | |
| wuffs_base__image_config__first_frame_is_opaque( | |
| const wuffs_base__image_config* c) { | |
| return c ? c->private_impl.first_frame_is_opaque : false; | |
| } | |
| #ifdef __cplusplus | |
| inline void // | |
| wuffs_base__image_config::set(uint32_t pixfmt_repr, | |
| uint32_t pixsub_repr, | |
| uint32_t width, | |
| uint32_t height, | |
| uint64_t first_frame_io_position, | |
| bool first_frame_is_opaque) { | |
| wuffs_base__image_config__set(this, pixfmt_repr, pixsub_repr, width, height, | |
| first_frame_io_position, first_frame_is_opaque); | |
| } | |
| inline void // | |
| wuffs_base__image_config::invalidate() { | |
| wuffs_base__image_config__invalidate(this); | |
| } | |
| inline bool // | |
| wuffs_base__image_config::is_valid() const { | |
| return wuffs_base__image_config__is_valid(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__image_config::first_frame_io_position() const { | |
| return wuffs_base__image_config__first_frame_io_position(this); | |
| } | |
| inline bool // | |
| wuffs_base__image_config::first_frame_is_opaque() const { | |
| return wuffs_base__image_config__first_frame_is_opaque(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| // wuffs_base__animation_disposal encodes, for an animated image, how to | |
| // dispose of a frame after displaying it: | |
| // - None means to draw the next frame on top of this one. | |
| // - Restore Background means to clear the frame's dirty rectangle to "the | |
| // background color" (in practice, this means transparent black) before | |
| // drawing the next frame. | |
| // - Restore Previous means to undo the current frame, so that the next frame | |
| // is drawn on top of the previous one. | |
| typedef uint8_t wuffs_base__animation_disposal; | |
| #define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0) | |
| #define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \ | |
| ((wuffs_base__animation_disposal)1) | |
| #define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \ | |
| ((wuffs_base__animation_disposal)2) | |
| // -------- | |
| typedef struct wuffs_base__frame_config__struct { | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| wuffs_base__rect_ie_u32 bounds; | |
| wuffs_base__flicks duration; | |
| uint64_t index; | |
| uint64_t io_position; | |
| wuffs_base__animation_disposal disposal; | |
| bool opaque_within_bounds; | |
| bool overwrite_instead_of_blend; | |
| wuffs_base__color_u32_argb_premul background_color; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| inline void set(wuffs_base__rect_ie_u32 bounds, | |
| wuffs_base__flicks duration, | |
| uint64_t index, | |
| uint64_t io_position, | |
| wuffs_base__animation_disposal disposal, | |
| bool opaque_within_bounds, | |
| bool overwrite_instead_of_blend, | |
| wuffs_base__color_u32_argb_premul background_color); | |
| inline wuffs_base__rect_ie_u32 bounds() const; | |
| inline uint32_t width() const; | |
| inline uint32_t height() const; | |
| inline wuffs_base__flicks duration() const; | |
| inline uint64_t index() const; | |
| inline uint64_t io_position() const; | |
| inline wuffs_base__animation_disposal disposal() const; | |
| inline bool opaque_within_bounds() const; | |
| inline bool overwrite_instead_of_blend() const; | |
| inline wuffs_base__color_u32_argb_premul background_color() const; | |
| #endif // __cplusplus | |
| } wuffs_base__frame_config; | |
| static inline wuffs_base__frame_config // | |
| wuffs_base__null_frame_config() { | |
| wuffs_base__frame_config ret; | |
| ret.private_impl.bounds = wuffs_base__make_rect_ie_u32(0, 0, 0, 0); | |
| ret.private_impl.duration = 0; | |
| ret.private_impl.index = 0; | |
| ret.private_impl.io_position = 0; | |
| ret.private_impl.disposal = 0; | |
| ret.private_impl.opaque_within_bounds = false; | |
| ret.private_impl.overwrite_instead_of_blend = false; | |
| return ret; | |
| } | |
| static inline void // | |
| wuffs_base__frame_config__set( | |
| wuffs_base__frame_config* c, | |
| wuffs_base__rect_ie_u32 bounds, | |
| wuffs_base__flicks duration, | |
| uint64_t index, | |
| uint64_t io_position, | |
| wuffs_base__animation_disposal disposal, | |
| bool opaque_within_bounds, | |
| bool overwrite_instead_of_blend, | |
| wuffs_base__color_u32_argb_premul background_color) { | |
| if (!c) { | |
| return; | |
| } | |
| c->private_impl.bounds = bounds; | |
| c->private_impl.duration = duration; | |
| c->private_impl.index = index; | |
| c->private_impl.io_position = io_position; | |
| c->private_impl.disposal = disposal; | |
| c->private_impl.opaque_within_bounds = opaque_within_bounds; | |
| c->private_impl.overwrite_instead_of_blend = overwrite_instead_of_blend; | |
| c->private_impl.background_color = background_color; | |
| } | |
| static inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__frame_config__bounds(const wuffs_base__frame_config* c) { | |
| if (c) { | |
| return c->private_impl.bounds; | |
| } | |
| wuffs_base__rect_ie_u32 ret; | |
| ret.min_incl_x = 0; | |
| ret.min_incl_y = 0; | |
| ret.max_excl_x = 0; | |
| ret.max_excl_y = 0; | |
| return ret; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__frame_config__width(const wuffs_base__frame_config* c) { | |
| return c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__frame_config__height(const wuffs_base__frame_config* c) { | |
| return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0; | |
| } | |
| // wuffs_base__frame_config__duration returns the amount of time to display | |
| // this frame. Zero means to display forever - a still (non-animated) image. | |
| static inline wuffs_base__flicks // | |
| wuffs_base__frame_config__duration(const wuffs_base__frame_config* c) { | |
| return c ? c->private_impl.duration : 0; | |
| } | |
| // wuffs_base__frame_config__index returns the index of this frame. The first | |
| // frame in an image has index 0, the second frame has index 1, and so on. | |
| static inline uint64_t // | |
| wuffs_base__frame_config__index(const wuffs_base__frame_config* c) { | |
| return c ? c->private_impl.index : 0; | |
| } | |
| // wuffs_base__frame_config__io_position returns the I/O stream position before | |
| // the frame config. | |
| static inline uint64_t // | |
| wuffs_base__frame_config__io_position(const wuffs_base__frame_config* c) { | |
| return c ? c->private_impl.io_position : 0; | |
| } | |
| // wuffs_base__frame_config__disposal returns, for an animated image, how to | |
| // dispose of this frame after displaying it. | |
| static inline wuffs_base__animation_disposal // | |
| wuffs_base__frame_config__disposal(const wuffs_base__frame_config* c) { | |
| return c ? c->private_impl.disposal : 0; | |
| } | |
| // wuffs_base__frame_config__opaque_within_bounds returns whether all pixels | |
| // within the frame's bounds are fully opaque. It makes no claim about pixels | |
| // outside the frame bounds but still inside the overall image. The two | |
| // bounding rectangles can differ for animated images. | |
| // | |
| // Its semantics are conservative. It is valid for a fully opaque frame to have | |
| // this value be false: a false negative. | |
| // | |
| // If true, drawing the frame with WUFFS_BASE__PIXEL_BLEND__SRC and | |
| // WUFFS_BASE__PIXEL_BLEND__SRC_OVER should be equivalent, in terms of | |
| // resultant pixels, but the former may be faster. | |
| static inline bool // | |
| wuffs_base__frame_config__opaque_within_bounds( | |
| const wuffs_base__frame_config* c) { | |
| return c && c->private_impl.opaque_within_bounds; | |
| } | |
| // wuffs_base__frame_config__overwrite_instead_of_blend returns, for an | |
| // animated image, whether to ignore the previous image state (within the frame | |
| // bounds) when drawing this incremental frame. Equivalently, whether to use | |
| // WUFFS_BASE__PIXEL_BLEND__SRC instead of WUFFS_BASE__PIXEL_BLEND__SRC_OVER. | |
| // | |
| // The WebP spec (https://developers.google.com/speed/webp/docs/riff_container) | |
| // calls this the "Blending method" bit. WebP's "Do not blend" corresponds to | |
| // Wuffs' "overwrite_instead_of_blend". | |
| static inline bool // | |
| wuffs_base__frame_config__overwrite_instead_of_blend( | |
| const wuffs_base__frame_config* c) { | |
| return c && c->private_impl.overwrite_instead_of_blend; | |
| } | |
| static inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__frame_config__background_color(const wuffs_base__frame_config* c) { | |
| return c ? c->private_impl.background_color : 0; | |
| } | |
| #ifdef __cplusplus | |
| inline void // | |
| wuffs_base__frame_config::set( | |
| wuffs_base__rect_ie_u32 bounds, | |
| wuffs_base__flicks duration, | |
| uint64_t index, | |
| uint64_t io_position, | |
| wuffs_base__animation_disposal disposal, | |
| bool opaque_within_bounds, | |
| bool overwrite_instead_of_blend, | |
| wuffs_base__color_u32_argb_premul background_color) { | |
| wuffs_base__frame_config__set(this, bounds, duration, index, io_position, | |
| disposal, opaque_within_bounds, | |
| overwrite_instead_of_blend, background_color); | |
| } | |
| inline wuffs_base__rect_ie_u32 // | |
| wuffs_base__frame_config::bounds() const { | |
| return wuffs_base__frame_config__bounds(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__frame_config::width() const { | |
| return wuffs_base__frame_config__width(this); | |
| } | |
| inline uint32_t // | |
| wuffs_base__frame_config::height() const { | |
| return wuffs_base__frame_config__height(this); | |
| } | |
| inline wuffs_base__flicks // | |
| wuffs_base__frame_config::duration() const { | |
| return wuffs_base__frame_config__duration(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__frame_config::index() const { | |
| return wuffs_base__frame_config__index(this); | |
| } | |
| inline uint64_t // | |
| wuffs_base__frame_config::io_position() const { | |
| return wuffs_base__frame_config__io_position(this); | |
| } | |
| inline wuffs_base__animation_disposal // | |
| wuffs_base__frame_config::disposal() const { | |
| return wuffs_base__frame_config__disposal(this); | |
| } | |
| inline bool // | |
| wuffs_base__frame_config::opaque_within_bounds() const { | |
| return wuffs_base__frame_config__opaque_within_bounds(this); | |
| } | |
| inline bool // | |
| wuffs_base__frame_config::overwrite_instead_of_blend() const { | |
| return wuffs_base__frame_config__overwrite_instead_of_blend(this); | |
| } | |
| inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__frame_config::background_color() const { | |
| return wuffs_base__frame_config__background_color(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__pixel_buffer__struct { | |
| wuffs_base__pixel_config pixcfg; | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX]; | |
| // TODO: color spaces. | |
| } private_impl; | |
| #ifdef __cplusplus | |
| inline wuffs_base__status set_interleaved( | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__table_u8 primary_memory, | |
| wuffs_base__slice_u8 palette_memory); | |
| inline wuffs_base__status set_from_slice( | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__slice_u8 pixbuf_memory); | |
| inline wuffs_base__status set_from_table( | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__table_u8 primary_memory); | |
| inline wuffs_base__slice_u8 palette(); | |
| inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback); | |
| inline wuffs_base__pixel_format pixel_format() const; | |
| inline wuffs_base__table_u8 plane(uint32_t p); | |
| inline wuffs_base__color_u32_argb_premul color_u32_at(uint32_t x, | |
| uint32_t y) const; | |
| inline wuffs_base__status set_color_u32_at( | |
| uint32_t x, | |
| uint32_t y, | |
| wuffs_base__color_u32_argb_premul color); | |
| inline wuffs_base__status set_color_u32_fill_rect( | |
| wuffs_base__rect_ie_u32 rect, | |
| wuffs_base__color_u32_argb_premul color); | |
| #endif // __cplusplus | |
| } wuffs_base__pixel_buffer; | |
| static inline wuffs_base__pixel_buffer // | |
| wuffs_base__null_pixel_buffer() { | |
| wuffs_base__pixel_buffer ret; | |
| ret.pixcfg = wuffs_base__null_pixel_config(); | |
| ret.private_impl.planes[0] = wuffs_base__empty_table_u8(); | |
| ret.private_impl.planes[1] = wuffs_base__empty_table_u8(); | |
| ret.private_impl.planes[2] = wuffs_base__empty_table_u8(); | |
| ret.private_impl.planes[3] = wuffs_base__empty_table_u8(); | |
| return ret; | |
| } | |
| static inline wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_interleaved( | |
| wuffs_base__pixel_buffer* pb, | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__table_u8 primary_memory, | |
| wuffs_base__slice_u8 palette_memory) { | |
| if (!pb) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| memset(pb, 0, sizeof(*pb)); | |
| if (!pixcfg || | |
| wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) && | |
| (palette_memory.len < | |
| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) { | |
| return wuffs_base__make_status( | |
| wuffs_base__error__bad_argument_length_too_short); | |
| } | |
| uint32_t bits_per_pixel = | |
| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); | |
| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { | |
| // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? | |
| return wuffs_base__make_status(wuffs_base__error__unsupported_option); | |
| } | |
| uint64_t bytes_per_pixel = bits_per_pixel / 8; | |
| uint64_t width_in_bytes = | |
| ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel; | |
| if ((width_in_bytes > primary_memory.width) || | |
| (pixcfg->private_impl.height > primary_memory.height)) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| pb->pixcfg = *pixcfg; | |
| pb->private_impl.planes[0] = primary_memory; | |
| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { | |
| wuffs_base__table_u8* tab = | |
| &pb->private_impl | |
| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; | |
| tab->ptr = palette_memory.ptr; | |
| tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| tab->height = 1; | |
| tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| } | |
| return wuffs_base__make_status(NULL); | |
| } | |
| static inline wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb, | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__slice_u8 pixbuf_memory) { | |
| if (!pb) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| memset(pb, 0, sizeof(*pb)); | |
| if (!pixcfg) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { | |
| // TODO: support planar pixel formats, concious of pixel subsampling. | |
| return wuffs_base__make_status(wuffs_base__error__unsupported_option); | |
| } | |
| uint32_t bits_per_pixel = | |
| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); | |
| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { | |
| // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? | |
| return wuffs_base__make_status(wuffs_base__error__unsupported_option); | |
| } | |
| uint64_t bytes_per_pixel = bits_per_pixel / 8; | |
| uint8_t* ptr = pixbuf_memory.ptr; | |
| uint64_t len = pixbuf_memory.len; | |
| if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { | |
| // Split a WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte | |
| // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the | |
| // start of pixbuf_memory. We split from the start, not the end, so that | |
| // the both chunks' pointers have the same alignment as the original | |
| // pointer, up to an alignment of 1024. | |
| if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { | |
| return wuffs_base__make_status( | |
| wuffs_base__error__bad_argument_length_too_short); | |
| } | |
| wuffs_base__table_u8* tab = | |
| &pb->private_impl | |
| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; | |
| tab->ptr = ptr; | |
| tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| tab->height = 1; | |
| tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH; | |
| } | |
| uint64_t wh = ((uint64_t)pixcfg->private_impl.width) * | |
| ((uint64_t)pixcfg->private_impl.height); | |
| size_t width = (size_t)(pixcfg->private_impl.width); | |
| if ((wh > (UINT64_MAX / bytes_per_pixel)) || | |
| (width > (SIZE_MAX / bytes_per_pixel))) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| wh *= bytes_per_pixel; | |
| width = ((size_t)(width * bytes_per_pixel)); | |
| if (wh > len) { | |
| return wuffs_base__make_status( | |
| wuffs_base__error__bad_argument_length_too_short); | |
| } | |
| pb->pixcfg = *pixcfg; | |
| wuffs_base__table_u8* tab = &pb->private_impl.planes[0]; | |
| tab->ptr = ptr; | |
| tab->width = width; | |
| tab->height = pixcfg->private_impl.height; | |
| tab->stride = width; | |
| return wuffs_base__make_status(NULL); | |
| } | |
| // Deprecated: does not handle indexed pixel configurations. Use | |
| // wuffs_base__pixel_buffer__set_interleaved instead. | |
| static inline wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* pb, | |
| const wuffs_base__pixel_config* pixcfg, | |
| wuffs_base__table_u8 primary_memory) { | |
| if (!pb) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| memset(pb, 0, sizeof(*pb)); | |
| if (!pixcfg || | |
| wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) || | |
| wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| uint32_t bits_per_pixel = | |
| wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); | |
| if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { | |
| // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? | |
| return wuffs_base__make_status(wuffs_base__error__unsupported_option); | |
| } | |
| uint64_t bytes_per_pixel = bits_per_pixel / 8; | |
| uint64_t width_in_bytes = | |
| ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel; | |
| if ((width_in_bytes > primary_memory.width) || | |
| (pixcfg->private_impl.height > primary_memory.height)) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_argument); | |
| } | |
| pb->pixcfg = *pixcfg; | |
| pb->private_impl.planes[0] = primary_memory; | |
| return wuffs_base__make_status(NULL); | |
| } | |
| // wuffs_base__pixel_buffer__palette returns the palette color data. If | |
| // non-empty, it will have length | |
| // WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) { | |
| if (pb && | |
| wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) { | |
| wuffs_base__table_u8* tab = | |
| &pb->private_impl | |
| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; | |
| if ((tab->width == | |
| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) && | |
| (tab->height == 1)) { | |
| return wuffs_base__make_slice_u8( | |
| tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH); | |
| } | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__pixel_buffer__palette_or_else(wuffs_base__pixel_buffer* pb, | |
| wuffs_base__slice_u8 fallback) { | |
| if (pb && | |
| wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) { | |
| wuffs_base__table_u8* tab = | |
| &pb->private_impl | |
| .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; | |
| if ((tab->width == | |
| WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) && | |
| (tab->height == 1)) { | |
| return wuffs_base__make_slice_u8( | |
| tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH); | |
| } | |
| } | |
| return fallback; | |
| } | |
| static inline wuffs_base__pixel_format // | |
| wuffs_base__pixel_buffer__pixel_format(const wuffs_base__pixel_buffer* pb) { | |
| if (pb) { | |
| return pb->pixcfg.private_impl.pixfmt; | |
| } | |
| return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__INVALID); | |
| } | |
| static inline wuffs_base__table_u8 // | |
| wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* pb, uint32_t p) { | |
| if (pb && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) { | |
| return pb->private_impl.planes[p]; | |
| } | |
| wuffs_base__table_u8 ret; | |
| ret.ptr = NULL; | |
| ret.width = 0; | |
| ret.height = 0; | |
| ret.stride = 0; | |
| return ret; | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul // | |
| wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb, | |
| uint32_t x, | |
| uint32_t y); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_color_u32_at( | |
| wuffs_base__pixel_buffer* pb, | |
| uint32_t x, | |
| uint32_t y, | |
| wuffs_base__color_u32_argb_premul color); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_color_u32_fill_rect( | |
| wuffs_base__pixel_buffer* pb, | |
| wuffs_base__rect_ie_u32 rect, | |
| wuffs_base__color_u32_argb_premul color); | |
| #ifdef __cplusplus | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_buffer::set_interleaved( | |
| const wuffs_base__pixel_config* pixcfg_arg, | |
| wuffs_base__table_u8 primary_memory, | |
| wuffs_base__slice_u8 palette_memory) { | |
| return wuffs_base__pixel_buffer__set_interleaved( | |
| this, pixcfg_arg, primary_memory, palette_memory); | |
| } | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_buffer::set_from_slice( | |
| const wuffs_base__pixel_config* pixcfg_arg, | |
| wuffs_base__slice_u8 pixbuf_memory) { | |
| return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg_arg, | |
| pixbuf_memory); | |
| } | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_buffer::set_from_table( | |
| const wuffs_base__pixel_config* pixcfg_arg, | |
| wuffs_base__table_u8 primary_memory) { | |
| return wuffs_base__pixel_buffer__set_from_table(this, pixcfg_arg, | |
| primary_memory); | |
| } | |
| inline wuffs_base__slice_u8 // | |
| wuffs_base__pixel_buffer::palette() { | |
| return wuffs_base__pixel_buffer__palette(this); | |
| } | |
| inline wuffs_base__slice_u8 // | |
| wuffs_base__pixel_buffer::palette_or_else(wuffs_base__slice_u8 fallback) { | |
| return wuffs_base__pixel_buffer__palette_or_else(this, fallback); | |
| } | |
| inline wuffs_base__pixel_format // | |
| wuffs_base__pixel_buffer::pixel_format() const { | |
| return wuffs_base__pixel_buffer__pixel_format(this); | |
| } | |
| inline wuffs_base__table_u8 // | |
| wuffs_base__pixel_buffer::plane(uint32_t p) { | |
| return wuffs_base__pixel_buffer__plane(this, p); | |
| } | |
| inline wuffs_base__color_u32_argb_premul // | |
| wuffs_base__pixel_buffer::color_u32_at(uint32_t x, uint32_t y) const { | |
| return wuffs_base__pixel_buffer__color_u32_at(this, x, y); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status // | |
| wuffs_base__pixel_buffer__set_color_u32_fill_rect( | |
| wuffs_base__pixel_buffer* pb, | |
| wuffs_base__rect_ie_u32 rect, | |
| wuffs_base__color_u32_argb_premul color); | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_buffer::set_color_u32_at( | |
| uint32_t x, | |
| uint32_t y, | |
| wuffs_base__color_u32_argb_premul color) { | |
| return wuffs_base__pixel_buffer__set_color_u32_at(this, x, y, color); | |
| } | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_buffer::set_color_u32_fill_rect( | |
| wuffs_base__rect_ie_u32 rect, | |
| wuffs_base__color_u32_argb_premul color) { | |
| return wuffs_base__pixel_buffer__set_color_u32_fill_rect(this, rect, color); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| typedef struct wuffs_base__decode_frame_options__struct { | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| uint8_t TODO; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #endif // __cplusplus | |
| } wuffs_base__decode_frame_options; | |
| #ifdef __cplusplus | |
| #endif // __cplusplus | |
| // -------- | |
| // wuffs_base__pixel_palette__closest_element returns the index of the palette | |
| // element that minimizes the sum of squared differences of the four ARGB | |
| // channels, working in premultiplied alpha. Ties favor the smaller index. | |
| // | |
| // The palette_slice.len may equal (N*4), for N less than 256, which means that | |
| // only the first N palette elements are considered. It returns 0 when N is 0. | |
| // | |
| // Applying this function on a per-pixel basis will not produce whole-of-image | |
| // dithering. | |
| WUFFS_BASE__MAYBE_STATIC uint8_t // | |
| wuffs_base__pixel_palette__closest_element( | |
| wuffs_base__slice_u8 palette_slice, | |
| wuffs_base__pixel_format palette_format, | |
| wuffs_base__color_u32_argb_premul c); | |
| // -------- | |
| // TODO: should the func type take restrict pointers? | |
| typedef uint64_t (*wuffs_base__pixel_swizzler__func)(uint8_t* dst_ptr, | |
| size_t dst_len, | |
| uint8_t* dst_palette_ptr, | |
| size_t dst_palette_len, | |
| const uint8_t* src_ptr, | |
| size_t src_len); | |
| typedef uint64_t (*wuffs_base__pixel_swizzler__transparent_black_func)( | |
| uint8_t* dst_ptr, | |
| size_t dst_len, | |
| uint8_t* dst_palette_ptr, | |
| size_t dst_palette_len, | |
| uint64_t num_pixels, | |
| uint32_t dst_pixfmt_bytes_per_pixel); | |
| typedef struct wuffs_base__pixel_swizzler__struct { | |
| // Do not access the private_impl's fields directly. There is no API/ABI | |
| // compatibility or safety guarantee if you do so. | |
| struct { | |
| wuffs_base__pixel_swizzler__func func; | |
| wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func; | |
| uint32_t dst_pixfmt_bytes_per_pixel; | |
| uint32_t src_pixfmt_bytes_per_pixel; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| inline wuffs_base__status prepare(wuffs_base__pixel_format dst_pixfmt, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__pixel_format src_pixfmt, | |
| wuffs_base__slice_u8 src_palette, | |
| wuffs_base__pixel_blend blend); | |
| inline uint64_t swizzle_interleaved_from_slice( | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__slice_u8 src) const; | |
| #endif // __cplusplus | |
| } wuffs_base__pixel_swizzler; | |
| // wuffs_base__pixel_swizzler__prepare readies the pixel swizzler so that its | |
| // other methods may be called. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status // | |
| wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, | |
| wuffs_base__pixel_format dst_pixfmt, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__pixel_format src_pixfmt, | |
| wuffs_base__slice_u8 src_palette, | |
| wuffs_base__pixel_blend blend); | |
| // wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice converts pixels | |
| // from a source format to a destination format. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC uint64_t // | |
| wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice( | |
| const wuffs_base__pixel_swizzler* p, | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__slice_u8 src); | |
| #ifdef __cplusplus | |
| inline wuffs_base__status // | |
| wuffs_base__pixel_swizzler::prepare(wuffs_base__pixel_format dst_pixfmt, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__pixel_format src_pixfmt, | |
| wuffs_base__slice_u8 src_palette, | |
| wuffs_base__pixel_blend blend) { | |
| return wuffs_base__pixel_swizzler__prepare(this, dst_pixfmt, dst_palette, | |
| src_pixfmt, src_palette, blend); | |
| } | |
| uint64_t // | |
| wuffs_base__pixel_swizzler::swizzle_interleaved_from_slice( | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| wuffs_base__slice_u8 src) const { | |
| return wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice( | |
| this, dst, dst_palette, src); | |
| } | |
| #endif // __cplusplus | |
| // ---------------- String Conversions | |
| // Options (bitwise or'ed together) for wuffs_base__parse_number_xxx | |
| // functions. The XXX options apply to both integer and floating point. The FXX | |
| // options apply only to floating point. | |
| #define WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000) | |
| // WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES means to accept | |
| // inputs like "00", "0644" and "00.7". By default, they are rejected. | |
| #define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES \ | |
| ((uint32_t)0x00000001) | |
| // WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES means to accept inputs like | |
| // "1__2" and "_3.141_592". By default, they are rejected. | |
| #define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES ((uint32_t)0x00000002) | |
| // WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to accept | |
| // "1,5" and not "1.5" as one-and-a-half. | |
| // | |
| // If the caller wants to accept either, it is responsible for canonicalizing | |
| // the input before calling wuffs_base__parse_number_fxx. The caller also has | |
| // more context on e.g. exactly how to treat something like "$1,234". | |
| #define WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \ | |
| ((uint32_t)0x00000010) | |
| // WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN means to reject inputs that | |
| // would lead to infinite or Not-a-Number floating point values. By default, | |
| // they are accepted. | |
| // | |
| // This affects the literal "inf" as input, but also affects inputs like | |
| // "1e999" that would overflow double-precision floating point. | |
| #define WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN ((uint32_t)0x00000020) | |
| // -------- | |
| // Options (bitwise or'ed together) for wuffs_base__render_number_xxx | |
| // functions. The XXX options apply to both integer and floating point. The FXX | |
| // options apply only to floating point. | |
| #define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000) | |
| // WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side | |
| // (higher indexes) of the destination slice, leaving any untouched bytes on | |
| // the left side (lower indexes). The default is vice versa: rendering on the | |
| // left with slack on the right. | |
| #define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000100) | |
| // WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading | |
| // "+" for non-negative numbers: "+0" and "+12.3" instead of "0" and "12.3". | |
| #define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000200) | |
| // WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render | |
| // one-and-a-half as "1,5" instead of "1.5". | |
| #define WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \ | |
| ((uint32_t)0x00001000) | |
| // WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never | |
| // (EXPONENT_ABSENT, equivalent to printf's "%f") or to always | |
| // (EXPONENT_PRESENT, equivalent to printf's "%e") render a floating point | |
| // number as "1.23e+05" instead of "123000". | |
| // | |
| // Having both bits set is the same has having neither bit set, where the | |
| // notation used depends on whether the exponent is sufficiently large: "0.5" | |
| // is preferred over "5e-01" but "5e-09" is preferred over "0.000000005". | |
| #define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00002000) | |
| #define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00004000) | |
| // WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the | |
| // smallest number of digits so that parsing the resultant string will recover | |
| // the same double-precision floating point number. | |
| // | |
| // For example, double-precision cannot distinguish between 0.3 and | |
| // 0.299999999999999988897769753748434595763683319091796875, so when this bit | |
| // is set, rendering the latter will produce "0.3" but rendering | |
| // 0.3000000000000000444089209850062616169452667236328125 will produce | |
| // "0.30000000000000004". | |
| #define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \ | |
| ((uint32_t)0x00008000) | |
| // ---------------- IEEE 754 Floating Point | |
| // wuffs_base__ieee_754_bit_representation__etc converts between a double | |
| // precision numerical value and its IEEE 754 representations: | |
| // - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits. | |
| // - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits. | |
| // - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits. | |
| // | |
| // For example, it converts between: | |
| // - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000. | |
| // - +5.5 and 0x4580, 0x40B0_0000 or 0x4016_0000_0000_0000. | |
| // - -inf and 0xFC00, 0xFF80_0000 or 0xFFF0_0000_0000_0000. | |
| // | |
| // Converting from f64 to shorter formats (f16 or f32, represented in C as | |
| // uint16_t and uint32_t) may be lossy. Such functions have names that look | |
| // like etc_truncate, as converting finite numbers produce equal or smaller | |
| // (closer-to-zero) finite numbers. For example, 1048576.0 is a perfectly valid | |
| // f64 number, but converting it to a f16 (with truncation) produces 65504.0, | |
| // the largest finite f16 number. Truncating a f64-typed value d to f32 does | |
| // not always produce the same result as the C-style cast ((float)d), as | |
| // casting can convert from finite numbers to infinite ones. | |
| // | |
| // Converting infinities or NaNs produces infinities or NaNs and always report | |
| // no loss, even though there a multiple NaN representations so that round- | |
| // tripping a f64-typed NaN may produce a different 64 bits. Nonetheless, the | |
| // etc_truncate functions preserve a NaN's "quiet vs signaling" bit. | |
| // | |
| // See https://en.wikipedia.org/wiki/Double-precision_floating-point_format | |
| typedef struct wuffs_base__lossy_value_u16__struct { | |
| uint16_t value; | |
| bool lossy; | |
| } wuffs_base__lossy_value_u16; | |
| typedef struct wuffs_base__lossy_value_u32__struct { | |
| uint32_t value; | |
| bool lossy; | |
| } wuffs_base__lossy_value_u32; | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 // | |
| wuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 // | |
| wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f); | |
| static inline uint64_t // | |
| wuffs_base__ieee_754_bit_representation__from_f64_to_u64(double f) { | |
| uint64_t u = 0; | |
| if (sizeof(uint64_t) == sizeof(double)) { | |
| memcpy(&u, &f, sizeof(uint64_t)); | |
| } | |
| return u; | |
| } | |
| static inline double // | |
| wuffs_base__ieee_754_bit_representation__from_u16_to_f64(uint16_t u) { | |
| uint64_t v = ((uint64_t)(u & 0x8000)) << 48; | |
| do { | |
| uint64_t exp = (u >> 10) & 0x1F; | |
| uint64_t man = u & 0x3FF; | |
| if (exp == 0x1F) { // Infinity or NaN. | |
| exp = 2047; | |
| } else if (exp != 0) { // Normal. | |
| exp += 1008; // 1008 = 1023 - 15, the difference in biases. | |
| } else if (man != 0) { // Subnormal but non-zero. | |
| uint32_t clz = wuffs_base__count_leading_zeroes_u64(man); | |
| exp = 1062 - clz; // 1062 = 1008 + 64 - 10. | |
| man = 0x3FF & (man << (clz - 53)); | |
| } else { // Zero. | |
| break; | |
| } | |
| v |= (exp << 52) | (man << 42); | |
| } while (0); | |
| double f = 0; | |
| if (sizeof(uint64_t) == sizeof(double)) { | |
| memcpy(&f, &v, sizeof(uint64_t)); | |
| } | |
| return f; | |
| } | |
| static inline double // | |
| wuffs_base__ieee_754_bit_representation__from_u32_to_f64(uint32_t u) { | |
| float f = 0; | |
| if (sizeof(uint32_t) == sizeof(float)) { | |
| memcpy(&f, &u, sizeof(uint32_t)); | |
| } | |
| return (double)f; | |
| } | |
| static inline double // | |
| wuffs_base__ieee_754_bit_representation__from_u64_to_f64(uint64_t u) { | |
| double f = 0; | |
| if (sizeof(uint64_t) == sizeof(double)) { | |
| memcpy(&f, &u, sizeof(uint64_t)); | |
| } | |
| return f; | |
| } | |
| // ---------------- Parsing and Rendering Numbers | |
| // wuffs_base__parse_number_f64 parses the floating point number in s. For | |
| // example, if s contains the bytes "1.5" then it will return the double 1.5. | |
| // | |
| // It returns an error if s does not contain a floating point number. | |
| // | |
| // It does not necessarily return an error if the conversion is lossy, e.g. if | |
| // s is "0.3", which double-precision floating point cannot represent exactly. | |
| // | |
| // Similarly, the returned value may be infinite (and no error returned) even | |
| // if s was not "inf", when the input is nominally finite but sufficiently | |
| // larger than DBL_MAX, about 1.8e+308. | |
| // | |
| // It is similar to the C standard library's strtod function, but: | |
| // - Errors are returned in-band (in a result type), not out-of-band (errno). | |
| // - It takes a slice (a pointer and length), not a NUL-terminated C string. | |
| // - It does not take an optional endptr argument. It does not allow a partial | |
| // parse: it returns an error unless all of s is consumed. | |
| // - It does not allow whitespace, leading or otherwise. | |
| // - It does not allow hexadecimal floating point numbers. | |
| // - It is not affected by i18n / l10n settings such as environment variables. | |
| // | |
| // The options argument can change these, but by default, it: | |
| // - Allows "inf", "+Infinity" and "-NAN", case insensitive. Similarly, | |
| // without an explicit opt-out, it would successfully parse "1e999" as | |
| // infinity, even though it overflows double-precision floating point. | |
| // - Rejects underscores. With an explicit opt-in, "_3.141_592" would | |
| // successfully parse as an approximation to π. | |
| // - Rejects unnecessary leading zeroes: "00", "0644" and "00.7". | |
| // - Uses a dot '1.5' instead of a comma '1,5' for the decimal separator. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 // | |
| wuffs_base__parse_number_f64(wuffs_base__slice_u8 s, uint32_t options); | |
| // wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if | |
| // s contains the bytes "-123" then it will return the int64_t -123. | |
| // | |
| // It returns an error if s does not contain an integer or if the integer | |
| // within would overflow an int64_t. | |
| // | |
| // It is similar to wuffs_base__parse_number_u64 but it returns a signed | |
| // integer, not an unsigned integer. It also allows a leading '+' or '-'. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 // | |
| wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options); | |
| // wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if | |
| // s contains the bytes "123" then it will return the uint64_t 123. | |
| // | |
| // It returns an error if s does not contain an integer or if the integer | |
| // within would overflow a uint64_t. | |
| // | |
| // It is similar to the C standard library's strtoull function, but: | |
| // - Errors are returned in-band (in a result type), not out-of-band (errno). | |
| // - It takes a slice (a pointer and length), not a NUL-terminated C string. | |
| // - It does not take an optional endptr argument. It does not allow a partial | |
| // parse: it returns an error unless all of s is consumed. | |
| // - It does not allow whitespace, leading or otherwise. | |
| // - It does not allow a leading '+' or '-'. | |
| // - It does not take a base argument (e.g. base 10 vs base 16). Instead, it | |
| // always accepts both decimal (e.g "1234", "0d5678") and hexadecimal (e.g. | |
| // "0x9aBC"). The caller is responsible for prior filtering of e.g. hex | |
| // numbers if they are unwanted. For example, Wuffs' JSON decoder will only | |
| // produce a wuffs_base__token for decimal numbers, not hexadecimal. | |
| // - It is not affected by i18n / l10n settings such as environment variables. | |
| // | |
| // The options argument can change these, but by default, it: | |
| // - Rejects underscores. With an explicit opt-in, "__0D_1_002" would | |
| // successfully parse as "one thousand and two". Underscores are still | |
| // rejected inside the optional 2-byte opening "0d" or "0X" that denotes | |
| // base-10 or base-16. | |
| // - Rejects unnecessary leading zeroes: "00" and "0644". | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 // | |
| wuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options); | |
| // -------- | |
| // WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL is the string length of | |
| // "-9223372036854775808" and "+9223372036854775807", INT64_MIN and INT64_MAX. | |
| #define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20 | |
| // WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL is the string length of | |
| // "+18446744073709551615", UINT64_MAX. | |
| #define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21 | |
| // wuffs_base__render_number_f64 writes the decimal encoding of x to dst and | |
| // returns the number of bytes written. If dst is shorter than the entire | |
| // encoding, it returns 0 (and no bytes are written). | |
| // | |
| // For those familiar with C's printf or Go's fmt.Printf functions: | |
| // - "%e" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option. | |
| // - "%f" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT option. | |
| // - "%g" means neither or both bits are set. | |
| // | |
| // The precision argument controls the number of digits rendered, excluding the | |
| // exponent (the "e+05" in "1.23e+05"): | |
| // - for "%e" and "%f" it is the number of digits after the decimal separator, | |
| // - for "%g" it is the number of significant digits (and trailing zeroes are | |
| // removed). | |
| // | |
| // A precision of 6 gives similar output to printf's defaults. | |
| // | |
| // A precision greater than 4095 is equivalent to 4095. | |
| // | |
| // The precision argument is ignored when the | |
| // WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is | |
| // similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical) | |
| // precision, but there is no corresponding feature in C's printf. | |
| // | |
| // Extreme values of x will be rendered as "NaN", "Inf" (or "+Inf" if the | |
| // WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or "-Inf". | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__render_number_f64(wuffs_base__slice_u8 dst, | |
| double x, | |
| uint32_t precision, | |
| uint32_t options); | |
| // wuffs_base__render_number_i64 writes the decimal encoding of x to dst and | |
| // returns the number of bytes written. If dst is shorter than the entire | |
| // encoding, it returns 0 (and no bytes are written). | |
| // | |
| // dst will never be too short if its length is at least 20, also known as | |
| // WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__render_number_i64(wuffs_base__slice_u8 dst, | |
| int64_t x, | |
| uint32_t options); | |
| // wuffs_base__render_number_u64 writes the decimal encoding of x to dst and | |
| // returns the number of bytes written. If dst is shorter than the entire | |
| // encoding, it returns 0 (and no bytes are written). | |
| // | |
| // dst will never be too short if its length is at least 21, also known as | |
| // WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__render_number_u64(wuffs_base__slice_u8 dst, | |
| uint64_t x, | |
| uint32_t options); | |
| // ---------------- Base-16 | |
| // Options (bitwise or'ed together) for wuffs_base__base_16__xxx functions. | |
| #define WUFFS_BASE__BASE_16__DEFAULT_OPTIONS ((uint32_t)0x00000000) | |
| // wuffs_base__base_16__decode2 converts "6A6b" to "jk", where e.g. 'j' is | |
| // U+006A. There are 2 src bytes for every dst byte. | |
| // | |
| // It assumes that the src bytes are two hexadecimal digits (0-9, A-F, a-f), | |
| // repeated. It may write nonsense bytes if not, although it will not read or | |
| // write out of bounds. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_16__decode2(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // wuffs_base__base_16__decode4 converts both "\\x6A\\x6b" and "??6a??6B" to | |
| // "jk", where e.g. 'j' is U+006A. There are 4 src bytes for every dst byte. | |
| // | |
| // It assumes that the src bytes are two ignored bytes and then two hexadecimal | |
| // digits (0-9, A-F, a-f), repeated. It may write nonsense bytes if not, | |
| // although it will not read or write out of bounds. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_16__decode4(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // wuffs_base__base_16__encode2 converts "jk" to "6A6B", where e.g. 'j' is | |
| // U+006A. There are 2 dst bytes for every src byte. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_16__encode2(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // wuffs_base__base_16__encode4 converts "jk" to "\\x6A\\x6B", where e.g. 'j' | |
| // is U+006A. There are 4 dst bytes for every src byte. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_16__encode2(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // ---------------- Base-64 | |
| // Options (bitwise or'ed together) for wuffs_base__base_64__xxx functions. | |
| #define WUFFS_BASE__BASE_64__DEFAULT_OPTIONS ((uint32_t)0x00000000) | |
| // WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING means that, when decoding base-64, | |
| // the input may (but does not need to) be padded with '=' bytes so that the | |
| // overall encoded length in bytes is a multiple of 4. A successful decoding | |
| // will return a num_src that includes those padding bytes. | |
| // | |
| // Excess padding (e.g. three final '='s) will be rejected as bad data. | |
| #define WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING ((uint32_t)0x00000001) | |
| // WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING means that, when encoding base-64, | |
| // the output will be padded with '=' bytes so that the overall encoded length | |
| // in bytes is a multiple of 4. | |
| #define WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING ((uint32_t)0x00000002) | |
| // WUFFS_BASE__BASE_64__URL_ALPHABET means that, for base-64, the URL-friendly | |
| // and file-name-friendly alphabet be used, as per RFC 4648 section 5. When | |
| // this option bit is off, the standard alphabet from section 4 is used. | |
| #define WUFFS_BASE__BASE_64__URL_ALPHABET ((uint32_t)0x00000100) | |
| // wuffs_base__base_64__decode transforms base-64 encoded bytes from src to | |
| // arbitrary bytes in dst. | |
| // | |
| // It will not permit line breaks or other whitespace in src. Filtering those | |
| // out is the responsibility of the caller. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_64__decode(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // wuffs_base__base_64__encode transforms arbitrary bytes from src to base-64 | |
| // encoded bytes in dst. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output // | |
| wuffs_base__base_64__encode(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src, | |
| bool src_closed, | |
| uint32_t options); | |
| // ---------------- Unicode and UTF-8 | |
| #define WUFFS_BASE__UNICODE_CODE_POINT__MIN_INCL 0x00000000 | |
| #define WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL 0x0010FFFF | |
| #define WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER 0x0000FFFD | |
| #define WUFFS_BASE__UNICODE_SURROGATE__MIN_INCL 0x0000D800 | |
| #define WUFFS_BASE__UNICODE_SURROGATE__MAX_INCL 0x0000DFFF | |
| #define WUFFS_BASE__ASCII__MIN_INCL 0x00 | |
| #define WUFFS_BASE__ASCII__MAX_INCL 0x7F | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH__MIN_INCL 1 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL 4 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MIN_INCL 0x00000000 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MAX_INCL 0x0000007F | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MIN_INCL 0x00000080 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MAX_INCL 0x000007FF | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MIN_INCL 0x00000800 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MAX_INCL 0x0000FFFF | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT__MIN_INCL 0x00010000 | |
| #define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT__MAX_INCL 0x0010FFFF | |
| // -------- | |
| // wuffs_base__utf_8__next__output is the type returned by | |
| // wuffs_base__utf_8__next. | |
| typedef struct wuffs_base__utf_8__next__output__struct { | |
| uint32_t code_point; | |
| uint32_t byte_length; | |
| #ifdef __cplusplus | |
| inline bool is_valid() const; | |
| #endif // __cplusplus | |
| } wuffs_base__utf_8__next__output; | |
| static inline wuffs_base__utf_8__next__output // | |
| wuffs_base__make_utf_8__next__output(uint32_t code_point, | |
| uint32_t byte_length) { | |
| wuffs_base__utf_8__next__output ret; | |
| ret.code_point = code_point; | |
| ret.byte_length = byte_length; | |
| return ret; | |
| } | |
| static inline bool // | |
| wuffs_base__utf_8__next__output__is_valid( | |
| const wuffs_base__utf_8__next__output* o) { | |
| if (o) { | |
| uint32_t cp = o->code_point; | |
| switch (o->byte_length) { | |
| case 1: | |
| return (cp <= 0x7F); | |
| case 2: | |
| return (0x080 <= cp) && (cp <= 0x7FF); | |
| case 3: | |
| // Avoid the 0xD800 ..= 0xDFFF surrogate range. | |
| return ((0x0800 <= cp) && (cp <= 0xD7FF)) || | |
| ((0xE000 <= cp) && (cp <= 0xFFFF)); | |
| case 4: | |
| return (0x00010000 <= cp) && (cp <= 0x0010FFFF); | |
| } | |
| } | |
| return false; | |
| } | |
| #ifdef __cplusplus | |
| inline bool // | |
| wuffs_base__utf_8__next__output::is_valid() const { | |
| return wuffs_base__utf_8__next__output__is_valid(this); | |
| } | |
| #endif // __cplusplus | |
| // -------- | |
| // wuffs_base__utf_8__encode writes the UTF-8 encoding of code_point to s and | |
| // returns the number of bytes written. If code_point is invalid, or if s is | |
| // shorter than the entire encoding, it returns 0 (and no bytes are written). | |
| // | |
| // s will never be too short if its length is at least 4, also known as | |
| // WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point); | |
| // wuffs_base__utf_8__next returns the next UTF-8 code point (and that code | |
| // point's byte length) at the start of the read-only slice (s_ptr, s_len). | |
| // | |
| // There are exactly two cases in which this function returns something where | |
| // wuffs_base__utf_8__next__output__is_valid is false: | |
| // - If s is empty then it returns {.code_point=0, .byte_length=0}. | |
| // - If s is non-empty and starts with invalid UTF-8 then it returns | |
| // {.code_point=WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, .byte_length=1}. | |
| // | |
| // Otherwise, it returns something where | |
| // wuffs_base__utf_8__next__output__is_valid is true. | |
| // | |
| // In any case, it always returns an output that satisfies both of: | |
| // - (output.code_point <= WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL). | |
| // - (output.byte_length <= s_len). | |
| // | |
| // If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice | |
| // boundary occurs in the middle of a multi-byte UTF-8 encoding of a single | |
| // code point, then this function may return something invalid. It is the | |
| // caller's responsibility to split on or otherwise manage UTF-8 boundaries. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output // | |
| wuffs_base__utf_8__next(const uint8_t* s_ptr, size_t s_len); | |
| // wuffs_base__utf_8__next_from_end is like wuffs_base__utf_8__next except that | |
| // it looks at the end of (s_ptr, s_len) instead of the start. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output // | |
| wuffs_base__utf_8__next_from_end(const uint8_t* s_ptr, size_t s_len); | |
| // wuffs_base__utf_8__longest_valid_prefix returns the largest n such that the | |
| // sub-slice s[..n] is valid UTF-8, where s is the read-only slice (s_ptr, | |
| // s_len). | |
| // | |
| // In particular, it returns s_len if and only if all of s is valid UTF-8. | |
| // | |
| // If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice | |
| // boundary occurs in the middle of a multi-byte UTF-8 encoding of a single | |
| // code point, then this function will return less than s_len. It is the | |
| // caller's responsibility to split on or otherwise manage UTF-8 boundaries. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__utf_8__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len); | |
| // wuffs_base__ascii__longest_valid_prefix returns the largest n such that the | |
| // sub-slice s[..n] is valid ASCII, where s is the read-only slice (s_ptr, | |
| // s_len). | |
| // | |
| // In particular, it returns s_len if and only if all of s is valid ASCII. | |
| // Equivalently, when none of the bytes in s have the 0x80 high bit set. | |
| // | |
| // For modular builds that divide the base module into sub-modules, using this | |
| // function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just | |
| // WUFFS_CONFIG__MODULE__BASE__CORE. | |
| WUFFS_BASE__MAYBE_STATIC size_t // | |
| wuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len); | |
| // ---------------- Interface Declarations. | |
| // For modular builds that divide the base module into sub-modules, using these | |
| // functions require the WUFFS_CONFIG__MODULE__BASE__INTERFACES sub-module, not | |
| // just WUFFS_CONFIG__MODULE__BASE__CORE. | |
| // -------- | |
| extern const char wuffs_base__hasher_u32__vtable_name[]; | |
| typedef struct wuffs_base__hasher_u32__func_ptrs__struct { | |
| wuffs_base__empty_struct (*set_quirk_enabled)( | |
| void* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| uint32_t (*update_u32)( | |
| void* self, | |
| wuffs_base__slice_u8 a_x); | |
| } wuffs_base__hasher_u32__func_ptrs; | |
| typedef struct wuffs_base__hasher_u32__struct wuffs_base__hasher_u32; | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__hasher_u32__set_quirk_enabled( | |
| wuffs_base__hasher_u32* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_base__hasher_u32__update_u32( | |
| wuffs_base__hasher_u32* self, | |
| wuffs_base__slice_u8 a_x); | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_base__hasher_u32__struct { | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable first_vtable; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_base__hasher_u32, decltype(&free)>; | |
| #endif | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_base__hasher_u32__set_quirk_enabled( | |
| this, a_quirk, a_enabled); | |
| } | |
| inline uint32_t | |
| update_u32( | |
| wuffs_base__slice_u8 a_x) { | |
| return wuffs_base__hasher_u32__update_u32( | |
| this, a_x); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_base__hasher_u32__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // -------- | |
| extern const char wuffs_base__image_decoder__vtable_name[]; | |
| typedef struct wuffs_base__image_decoder__func_ptrs__struct { | |
| wuffs_base__status (*decode_frame)( | |
| void* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| wuffs_base__status (*decode_frame_config)( | |
| void* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| wuffs_base__status (*decode_image_config)( | |
| void* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| wuffs_base__rect_ie_u32 (*frame_dirty_rect)( | |
| const void* self); | |
| uint32_t (*num_animation_loops)( | |
| const void* self); | |
| uint64_t (*num_decoded_frame_configs)( | |
| const void* self); | |
| uint64_t (*num_decoded_frames)( | |
| const void* self); | |
| wuffs_base__status (*restart_frame)( | |
| void* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| wuffs_base__empty_struct (*set_quirk_enabled)( | |
| void* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| wuffs_base__empty_struct (*set_report_metadata)( | |
| void* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| wuffs_base__status (*tell_me_more)( | |
| void* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| wuffs_base__range_ii_u64 (*workbuf_len)( | |
| const void* self); | |
| } wuffs_base__image_decoder__func_ptrs; | |
| typedef struct wuffs_base__image_decoder__struct wuffs_base__image_decoder; | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_frame( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_frame_config( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_image_config( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_base__image_decoder__frame_dirty_rect( | |
| const wuffs_base__image_decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_base__image_decoder__num_animation_loops( | |
| const wuffs_base__image_decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_base__image_decoder__num_decoded_frame_configs( | |
| const wuffs_base__image_decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_base__image_decoder__num_decoded_frames( | |
| const wuffs_base__image_decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__restart_frame( | |
| wuffs_base__image_decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__image_decoder__set_quirk_enabled( | |
| wuffs_base__image_decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__image_decoder__set_report_metadata( | |
| wuffs_base__image_decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__tell_me_more( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__image_decoder__workbuf_len( | |
| const wuffs_base__image_decoder* self); | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_base__image_decoder__struct { | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable first_vtable; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_base__image_decoder, decltype(&free)>; | |
| #endif | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_base__image_decoder__decode_frame( | |
| this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_base__image_decoder__decode_frame_config( | |
| this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_base__image_decoder__decode_image_config( | |
| this, a_dst, a_src); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_base__image_decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_base__image_decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_base__image_decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_base__image_decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_base__image_decoder__restart_frame( | |
| this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_base__image_decoder__set_quirk_enabled( | |
| this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_base__image_decoder__set_report_metadata( | |
| this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_base__image_decoder__tell_me_more( | |
| this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_base__image_decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_base__image_decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // -------- | |
| extern const char wuffs_base__io_transformer__vtable_name[]; | |
| typedef struct wuffs_base__io_transformer__func_ptrs__struct { | |
| wuffs_base__empty_struct (*set_quirk_enabled)( | |
| void* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| wuffs_base__status (*transform_io)( | |
| void* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| wuffs_base__range_ii_u64 (*workbuf_len)( | |
| const void* self); | |
| } wuffs_base__io_transformer__func_ptrs; | |
| typedef struct wuffs_base__io_transformer__struct wuffs_base__io_transformer; | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__io_transformer__set_quirk_enabled( | |
| wuffs_base__io_transformer* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__io_transformer__transform_io( | |
| wuffs_base__io_transformer* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__io_transformer__workbuf_len( | |
| const wuffs_base__io_transformer* self); | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_base__io_transformer__struct { | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable first_vtable; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_base__io_transformer, decltype(&free)>; | |
| #endif | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_base__io_transformer__set_quirk_enabled( | |
| this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_base__io_transformer__transform_io( | |
| this, a_dst, a_src, a_workbuf); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_base__io_transformer__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_base__io_transformer__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // -------- | |
| extern const char wuffs_base__token_decoder__vtable_name[]; | |
| typedef struct wuffs_base__token_decoder__func_ptrs__struct { | |
| wuffs_base__status (*decode_tokens)( | |
| void* self, | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| wuffs_base__empty_struct (*set_quirk_enabled)( | |
| void* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| wuffs_base__range_ii_u64 (*workbuf_len)( | |
| const void* self); | |
| } wuffs_base__token_decoder__func_ptrs; | |
| typedef struct wuffs_base__token_decoder__struct wuffs_base__token_decoder; | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__token_decoder__decode_tokens( | |
| wuffs_base__token_decoder* self, | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__token_decoder__set_quirk_enabled( | |
| wuffs_base__token_decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__token_decoder__workbuf_len( | |
| const wuffs_base__token_decoder* self); | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_base__token_decoder__struct { | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable first_vtable; | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_base__token_decoder, decltype(&free)>; | |
| #endif | |
| inline wuffs_base__status | |
| decode_tokens( | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_base__token_decoder__decode_tokens( | |
| this, a_dst, a_src, a_workbuf); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_base__token_decoder__set_quirk_enabled( | |
| this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_base__token_decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_base__token_decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Status Codes | |
| // ---------------- Public Consts | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_adler32__hasher__struct wuffs_adler32__hasher; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_adler32__hasher__initialize( | |
| wuffs_adler32__hasher* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_adler32__hasher(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_adler32__hasher* | |
| wuffs_adler32__hasher__alloc(); | |
| static inline wuffs_base__hasher_u32* | |
| wuffs_adler32__hasher__alloc_as__wuffs_base__hasher_u32() { | |
| return (wuffs_base__hasher_u32*)(wuffs_adler32__hasher__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__hasher_u32* | |
| wuffs_adler32__hasher__upcast_as__wuffs_base__hasher_u32( | |
| wuffs_adler32__hasher* p) { | |
| return (wuffs_base__hasher_u32*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_adler32__hasher__set_quirk_enabled( | |
| wuffs_adler32__hasher* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_adler32__hasher__update_u32( | |
| wuffs_adler32__hasher* self, | |
| wuffs_base__slice_u8 a_x); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_adler32__hasher__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__hasher_u32; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_state; | |
| bool f_started; | |
| wuffs_base__empty_struct (*choosy_up)( | |
| wuffs_adler32__hasher* self, | |
| wuffs_base__slice_u8 a_x); | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_adler32__hasher, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_adler32__hasher__alloc(), &free); | |
| } | |
| static inline wuffs_base__hasher_u32::unique_ptr | |
| alloc_as__wuffs_base__hasher_u32() { | |
| return wuffs_base__hasher_u32::unique_ptr( | |
| wuffs_adler32__hasher__alloc_as__wuffs_base__hasher_u32(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_adler32__hasher__struct() = delete; | |
| wuffs_adler32__hasher__struct(const wuffs_adler32__hasher__struct&) = delete; | |
| wuffs_adler32__hasher__struct& operator=( | |
| const wuffs_adler32__hasher__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_adler32__hasher__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__hasher_u32* | |
| upcast_as__wuffs_base__hasher_u32() { | |
| return (wuffs_base__hasher_u32*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_adler32__hasher__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline uint32_t | |
| update_u32( | |
| wuffs_base__slice_u8 a_x) { | |
| return wuffs_adler32__hasher__update_u32(this, a_x); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_adler32__hasher__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_bmp__error__bad_header[]; | |
| extern const char wuffs_bmp__error__bad_rle_compression[]; | |
| extern const char wuffs_bmp__error__unsupported_bmp_file[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_BMP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_bmp__decoder__struct wuffs_bmp__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_bmp__decoder__initialize( | |
| wuffs_bmp__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_bmp__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_bmp__decoder* | |
| wuffs_bmp__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_bmp__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_bmp__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_bmp__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_bmp__decoder__set_quirk_enabled( | |
| wuffs_bmp__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bmp__decoder__decode_image_config( | |
| wuffs_bmp__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bmp__decoder__decode_frame_config( | |
| wuffs_bmp__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bmp__decoder__decode_frame( | |
| wuffs_bmp__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_bmp__decoder__frame_dirty_rect( | |
| const wuffs_bmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_bmp__decoder__num_animation_loops( | |
| const wuffs_bmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_bmp__decoder__num_decoded_frame_configs( | |
| const wuffs_bmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_bmp__decoder__num_decoded_frames( | |
| const wuffs_bmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bmp__decoder__restart_frame( | |
| wuffs_bmp__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_bmp__decoder__set_report_metadata( | |
| wuffs_bmp__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bmp__decoder__tell_me_more( | |
| wuffs_bmp__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_bmp__decoder__workbuf_len( | |
| const wuffs_bmp__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_bmp__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint8_t f_call_sequence; | |
| bool f_top_down; | |
| uint32_t f_pad_per_row; | |
| uint32_t f_src_pixfmt; | |
| uint32_t f_io_redirect_fourcc; | |
| uint64_t f_io_redirect_pos; | |
| uint64_t f_frame_config_io_position; | |
| uint32_t f_bitmap_info_len; | |
| uint32_t f_padding; | |
| uint32_t f_bits_per_pixel; | |
| uint32_t f_compression; | |
| uint32_t f_channel_masks[4]; | |
| uint8_t f_channel_shifts[4]; | |
| uint8_t f_channel_num_bits[4]; | |
| uint32_t f_dst_x; | |
| uint32_t f_dst_y; | |
| uint32_t f_dst_y_inc; | |
| uint32_t f_pending_pad; | |
| uint32_t f_rle_state; | |
| uint32_t f_rle_length; | |
| uint8_t f_rle_delta_x; | |
| bool f_rle_padded; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_decode_frame[1]; | |
| uint32_t p_read_palette[1]; | |
| } private_impl; | |
| struct { | |
| uint8_t f_scratch[2048]; | |
| uint8_t f_src_palette[1024]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_image_config[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_frame[1]; | |
| struct { | |
| uint32_t v_i; | |
| uint64_t scratch; | |
| } s_read_palette[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_bmp__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_bmp__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_bmp__decoder__struct() = delete; | |
| wuffs_bmp__decoder__struct(const wuffs_bmp__decoder__struct&) = delete; | |
| wuffs_bmp__decoder__struct& operator=( | |
| const wuffs_bmp__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_bmp__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_bmp__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_bmp__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_bmp__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_bmp__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_bmp__decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_bmp__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_bmp__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_bmp__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_bmp__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_bmp__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_bmp__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_bmp__decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_bmp__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_bzip2__error__bad_huffman_code_over_subscribed[]; | |
| extern const char wuffs_bzip2__error__bad_huffman_code_under_subscribed[]; | |
| extern const char wuffs_bzip2__error__bad_block_header[]; | |
| extern const char wuffs_bzip2__error__bad_block_length[]; | |
| extern const char wuffs_bzip2__error__bad_checksum[]; | |
| extern const char wuffs_bzip2__error__bad_header[]; | |
| extern const char wuffs_bzip2__error__bad_number_of_huffman_codes[]; | |
| extern const char wuffs_bzip2__error__bad_number_of_sections[]; | |
| extern const char wuffs_bzip2__error__unsupported_huffman_code[]; | |
| extern const char wuffs_bzip2__error__unsupported_block_randomization[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_BZIP2__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_bzip2__decoder__struct wuffs_bzip2__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_bzip2__decoder__initialize( | |
| wuffs_bzip2__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_bzip2__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_bzip2__decoder* | |
| wuffs_bzip2__decoder__alloc(); | |
| static inline wuffs_base__io_transformer* | |
| wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)(wuffs_bzip2__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__io_transformer* | |
| wuffs_bzip2__decoder__upcast_as__wuffs_base__io_transformer( | |
| wuffs_bzip2__decoder* p) { | |
| return (wuffs_base__io_transformer*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_bzip2__decoder__set_quirk_enabled( | |
| wuffs_bzip2__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_bzip2__decoder__workbuf_len( | |
| const wuffs_bzip2__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_bzip2__decoder__transform_io( | |
| wuffs_bzip2__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_bzip2__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__io_transformer; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_bits; | |
| uint32_t f_n_bits; | |
| uint32_t f_max_incl_block_size; | |
| uint32_t f_block_size; | |
| bool f_decode_huffman_finished; | |
| uint8_t f_decode_huffman_which; | |
| uint32_t f_decode_huffman_ticks; | |
| uint32_t f_decode_huffman_section; | |
| uint32_t f_decode_huffman_run_shift; | |
| uint32_t f_flush_pointer; | |
| uint32_t f_flush_repeat_count; | |
| uint8_t f_flush_prev; | |
| bool f_ignore_checksum; | |
| uint32_t f_final_checksum_have; | |
| uint32_t f_block_checksum_have; | |
| uint32_t f_block_checksum_want; | |
| uint32_t f_original_pointer; | |
| uint32_t f_num_symbols; | |
| uint32_t f_num_huffman_codes; | |
| uint32_t f_num_sections; | |
| uint32_t f_code_lengths_bitmask; | |
| uint32_t p_transform_io[1]; | |
| uint32_t p_prepare_block[1]; | |
| uint32_t p_read_code_lengths[1]; | |
| uint32_t p_flush_slow[1]; | |
| uint32_t p_decode_huffman_slow[1]; | |
| } private_impl; | |
| struct { | |
| uint32_t f_scratch; | |
| uint32_t f_letter_counts[256]; | |
| uint8_t f_presence[256]; | |
| uint8_t f_mtft[256]; | |
| uint8_t f_huffman_selectors[32768]; | |
| uint16_t f_huffman_trees[6][1024][2]; | |
| uint16_t f_huffman_tables[6][256]; | |
| uint32_t f_bwt[1048576]; | |
| struct { | |
| uint32_t v_i; | |
| uint64_t v_tag; | |
| uint32_t v_final_checksum_want; | |
| } s_transform_io[1]; | |
| struct { | |
| uint32_t v_i; | |
| uint32_t v_selector; | |
| } s_prepare_block[1]; | |
| struct { | |
| uint32_t v_i; | |
| uint32_t v_code_length; | |
| } s_read_code_lengths[1]; | |
| struct { | |
| uint32_t v_flush_pointer; | |
| uint32_t v_flush_repeat_count; | |
| uint8_t v_flush_prev; | |
| uint32_t v_block_checksum_have; | |
| uint32_t v_block_size; | |
| uint8_t v_curr; | |
| uint64_t scratch; | |
| } s_flush_slow[1]; | |
| struct { | |
| uint32_t v_node_index; | |
| } s_decode_huffman_slow[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_bzip2__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_bzip2__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__io_transformer::unique_ptr | |
| alloc_as__wuffs_base__io_transformer() { | |
| return wuffs_base__io_transformer::unique_ptr( | |
| wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_bzip2__decoder__struct() = delete; | |
| wuffs_bzip2__decoder__struct(const wuffs_bzip2__decoder__struct&) = delete; | |
| wuffs_bzip2__decoder__struct& operator=( | |
| const wuffs_bzip2__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_bzip2__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__io_transformer* | |
| upcast_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_bzip2__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_bzip2__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_bzip2__decoder__transform_io(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_bzip2__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_cbor__error__bad_input[]; | |
| extern const char wuffs_cbor__error__unsupported_recursion_depth[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| #define WUFFS_CBOR__DECODER_DEPTH_MAX_INCL 1024 | |
| #define WUFFS_CBOR__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL 2 | |
| #define WUFFS_CBOR__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 9 | |
| #define WUFFS_CBOR__TOKEN_VALUE_MAJOR 787997 | |
| #define WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK 262143 | |
| #define WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X 16777216 | |
| #define WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE 8388608 | |
| #define WUFFS_CBOR__TOKEN_VALUE_MINOR__TAG 4194304 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_cbor__decoder__struct wuffs_cbor__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_cbor__decoder__initialize( | |
| wuffs_cbor__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_cbor__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_cbor__decoder* | |
| wuffs_cbor__decoder__alloc(); | |
| static inline wuffs_base__token_decoder* | |
| wuffs_cbor__decoder__alloc_as__wuffs_base__token_decoder() { | |
| return (wuffs_base__token_decoder*)(wuffs_cbor__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__token_decoder* | |
| wuffs_cbor__decoder__upcast_as__wuffs_base__token_decoder( | |
| wuffs_cbor__decoder* p) { | |
| return (wuffs_base__token_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_cbor__decoder__set_quirk_enabled( | |
| wuffs_cbor__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_cbor__decoder__workbuf_len( | |
| const wuffs_cbor__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_cbor__decoder__decode_tokens( | |
| wuffs_cbor__decoder* self, | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_cbor__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__token_decoder; | |
| wuffs_base__vtable null_vtable; | |
| bool f_end_of_data; | |
| uint32_t p_decode_tokens[1]; | |
| } private_impl; | |
| struct { | |
| uint32_t f_stack[64]; | |
| uint64_t f_container_num_remaining[1024]; | |
| struct { | |
| uint64_t v_string_length; | |
| uint32_t v_depth; | |
| bool v_tagged; | |
| uint8_t v_indefinite_string_major_type; | |
| } s_decode_tokens[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_cbor__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_cbor__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__token_decoder::unique_ptr | |
| alloc_as__wuffs_base__token_decoder() { | |
| return wuffs_base__token_decoder::unique_ptr( | |
| wuffs_cbor__decoder__alloc_as__wuffs_base__token_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_cbor__decoder__struct() = delete; | |
| wuffs_cbor__decoder__struct(const wuffs_cbor__decoder__struct&) = delete; | |
| wuffs_cbor__decoder__struct& operator=( | |
| const wuffs_cbor__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_cbor__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__token_decoder* | |
| upcast_as__wuffs_base__token_decoder() { | |
| return (wuffs_base__token_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_cbor__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_cbor__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| decode_tokens( | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_cbor__decoder__decode_tokens(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_cbor__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| // ---------------- Public Consts | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_crc32__ieee_hasher__struct wuffs_crc32__ieee_hasher; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_crc32__ieee_hasher__initialize( | |
| wuffs_crc32__ieee_hasher* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_crc32__ieee_hasher(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_crc32__ieee_hasher* | |
| wuffs_crc32__ieee_hasher__alloc(); | |
| static inline wuffs_base__hasher_u32* | |
| wuffs_crc32__ieee_hasher__alloc_as__wuffs_base__hasher_u32() { | |
| return (wuffs_base__hasher_u32*)(wuffs_crc32__ieee_hasher__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__hasher_u32* | |
| wuffs_crc32__ieee_hasher__upcast_as__wuffs_base__hasher_u32( | |
| wuffs_crc32__ieee_hasher* p) { | |
| return (wuffs_base__hasher_u32*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_crc32__ieee_hasher__set_quirk_enabled( | |
| wuffs_crc32__ieee_hasher* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_crc32__ieee_hasher__update_u32( | |
| wuffs_crc32__ieee_hasher* self, | |
| wuffs_base__slice_u8 a_x); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_crc32__ieee_hasher__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__hasher_u32; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_state; | |
| wuffs_base__empty_struct (*choosy_up)( | |
| wuffs_crc32__ieee_hasher* self, | |
| wuffs_base__slice_u8 a_x); | |
| } private_impl; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_crc32__ieee_hasher, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_crc32__ieee_hasher__alloc(), &free); | |
| } | |
| static inline wuffs_base__hasher_u32::unique_ptr | |
| alloc_as__wuffs_base__hasher_u32() { | |
| return wuffs_base__hasher_u32::unique_ptr( | |
| wuffs_crc32__ieee_hasher__alloc_as__wuffs_base__hasher_u32(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_crc32__ieee_hasher__struct() = delete; | |
| wuffs_crc32__ieee_hasher__struct(const wuffs_crc32__ieee_hasher__struct&) = delete; | |
| wuffs_crc32__ieee_hasher__struct& operator=( | |
| const wuffs_crc32__ieee_hasher__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_crc32__ieee_hasher__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__hasher_u32* | |
| upcast_as__wuffs_base__hasher_u32() { | |
| return (wuffs_base__hasher_u32*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_crc32__ieee_hasher__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline uint32_t | |
| update_u32( | |
| wuffs_base__slice_u8 a_x) { | |
| return wuffs_crc32__ieee_hasher__update_u32(this, a_x); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_crc32__ieee_hasher__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_deflate__error__bad_huffman_code_over_subscribed[]; | |
| extern const char wuffs_deflate__error__bad_huffman_code_under_subscribed[]; | |
| extern const char wuffs_deflate__error__bad_huffman_code_length_count[]; | |
| extern const char wuffs_deflate__error__bad_huffman_code_length_repetition[]; | |
| extern const char wuffs_deflate__error__bad_huffman_code[]; | |
| extern const char wuffs_deflate__error__bad_huffman_minimum_code_length[]; | |
| extern const char wuffs_deflate__error__bad_block[]; | |
| extern const char wuffs_deflate__error__bad_distance[]; | |
| extern const char wuffs_deflate__error__bad_distance_code_count[]; | |
| extern const char wuffs_deflate__error__bad_literal_length_code_count[]; | |
| extern const char wuffs_deflate__error__inconsistent_stored_block_length[]; | |
| extern const char wuffs_deflate__error__missing_end_of_block_code[]; | |
| extern const char wuffs_deflate__error__no_huffman_codes[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_DEFLATE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_deflate__decoder__struct wuffs_deflate__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_deflate__decoder__initialize( | |
| wuffs_deflate__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_deflate__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_deflate__decoder* | |
| wuffs_deflate__decoder__alloc(); | |
| static inline wuffs_base__io_transformer* | |
| wuffs_deflate__decoder__alloc_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)(wuffs_deflate__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__io_transformer* | |
| wuffs_deflate__decoder__upcast_as__wuffs_base__io_transformer( | |
| wuffs_deflate__decoder* p) { | |
| return (wuffs_base__io_transformer*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_deflate__decoder__add_history( | |
| wuffs_deflate__decoder* self, | |
| wuffs_base__slice_u8 a_hist); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_deflate__decoder__set_quirk_enabled( | |
| wuffs_deflate__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_deflate__decoder__workbuf_len( | |
| const wuffs_deflate__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_deflate__decoder__transform_io( | |
| wuffs_deflate__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_deflate__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__io_transformer; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_bits; | |
| uint32_t f_n_bits; | |
| uint64_t f_transformed_history_count; | |
| uint32_t f_history_index; | |
| uint32_t f_n_huffs_bits[2]; | |
| bool f_end_of_block; | |
| uint32_t p_transform_io[1]; | |
| uint32_t p_decode_blocks[1]; | |
| uint32_t p_decode_uncompressed[1]; | |
| uint32_t p_init_dynamic_huffman[1]; | |
| wuffs_base__status (*choosy_decode_huffman_fast64)( | |
| wuffs_deflate__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| uint32_t p_decode_huffman_slow[1]; | |
| } private_impl; | |
| struct { | |
| uint32_t f_huffs[2][1024]; | |
| uint8_t f_history[33025]; | |
| uint8_t f_code_lengths[320]; | |
| struct { | |
| uint32_t v_final; | |
| } s_decode_blocks[1]; | |
| struct { | |
| uint32_t v_length; | |
| uint64_t scratch; | |
| } s_decode_uncompressed[1]; | |
| struct { | |
| uint32_t v_bits; | |
| uint32_t v_n_bits; | |
| uint32_t v_n_lit; | |
| uint32_t v_n_dist; | |
| uint32_t v_n_clen; | |
| uint32_t v_i; | |
| uint32_t v_mask; | |
| uint32_t v_n_extra_bits; | |
| uint8_t v_rep_symbol; | |
| uint32_t v_rep_count; | |
| } s_init_dynamic_huffman[1]; | |
| struct { | |
| uint32_t v_bits; | |
| uint32_t v_n_bits; | |
| uint32_t v_table_entry_n_bits; | |
| uint32_t v_lmask; | |
| uint32_t v_dmask; | |
| uint32_t v_redir_top; | |
| uint32_t v_redir_mask; | |
| uint32_t v_length; | |
| uint32_t v_dist_minus_1; | |
| uint64_t scratch; | |
| } s_decode_huffman_slow[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_deflate__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_deflate__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__io_transformer::unique_ptr | |
| alloc_as__wuffs_base__io_transformer() { | |
| return wuffs_base__io_transformer::unique_ptr( | |
| wuffs_deflate__decoder__alloc_as__wuffs_base__io_transformer(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_deflate__decoder__struct() = delete; | |
| wuffs_deflate__decoder__struct(const wuffs_deflate__decoder__struct&) = delete; | |
| wuffs_deflate__decoder__struct& operator=( | |
| const wuffs_deflate__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_deflate__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__io_transformer* | |
| upcast_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| add_history( | |
| wuffs_base__slice_u8 a_hist) { | |
| return wuffs_deflate__decoder__add_history(this, a_hist); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_deflate__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_deflate__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_deflate__decoder__transform_io(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_deflate__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_lzw__error__bad_code[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_lzw__decoder__struct wuffs_lzw__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_lzw__decoder__initialize( | |
| wuffs_lzw__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_lzw__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_lzw__decoder* | |
| wuffs_lzw__decoder__alloc(); | |
| static inline wuffs_base__io_transformer* | |
| wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)(wuffs_lzw__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__io_transformer* | |
| wuffs_lzw__decoder__upcast_as__wuffs_base__io_transformer( | |
| wuffs_lzw__decoder* p) { | |
| return (wuffs_base__io_transformer*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_lzw__decoder__set_quirk_enabled( | |
| wuffs_lzw__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_lzw__decoder__set_literal_width( | |
| wuffs_lzw__decoder* self, | |
| uint32_t a_lw); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_lzw__decoder__workbuf_len( | |
| const wuffs_lzw__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_lzw__decoder__transform_io( | |
| wuffs_lzw__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 | |
| wuffs_lzw__decoder__flush( | |
| wuffs_lzw__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_lzw__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__io_transformer; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_set_literal_width_arg; | |
| uint32_t f_literal_width; | |
| uint32_t f_clear_code; | |
| uint32_t f_end_code; | |
| uint32_t f_save_code; | |
| uint32_t f_prev_code; | |
| uint32_t f_width; | |
| uint32_t f_bits; | |
| uint32_t f_n_bits; | |
| uint32_t f_output_ri; | |
| uint32_t f_output_wi; | |
| uint32_t f_read_from_return_value; | |
| uint16_t f_prefixes[4096]; | |
| uint32_t p_transform_io[1]; | |
| uint32_t p_write_to[1]; | |
| } private_impl; | |
| struct { | |
| uint8_t f_suffixes[4096][8]; | |
| uint16_t f_lm1s[4096]; | |
| uint8_t f_output[8199]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_lzw__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_lzw__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__io_transformer::unique_ptr | |
| alloc_as__wuffs_base__io_transformer() { | |
| return wuffs_base__io_transformer::unique_ptr( | |
| wuffs_lzw__decoder__alloc_as__wuffs_base__io_transformer(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_lzw__decoder__struct() = delete; | |
| wuffs_lzw__decoder__struct(const wuffs_lzw__decoder__struct&) = delete; | |
| wuffs_lzw__decoder__struct& operator=( | |
| const wuffs_lzw__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_lzw__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__io_transformer* | |
| upcast_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_lzw__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_literal_width( | |
| uint32_t a_lw) { | |
| return wuffs_lzw__decoder__set_literal_width(this, a_lw); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_lzw__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_lzw__decoder__transform_io(this, a_dst, a_src, a_workbuf); | |
| } | |
| inline wuffs_base__slice_u8 | |
| flush() { | |
| return wuffs_lzw__decoder__flush(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_lzw__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_gif__error__bad_extension_label[]; | |
| extern const char wuffs_gif__error__bad_frame_size[]; | |
| extern const char wuffs_gif__error__bad_graphic_control[]; | |
| extern const char wuffs_gif__error__bad_header[]; | |
| extern const char wuffs_gif__error__bad_literal_width[]; | |
| extern const char wuffs_gif__error__bad_palette[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| #define WUFFS_GIF__QUIRK_DELAY_NUM_DECODED_FRAMES 1041635328 | |
| #define WUFFS_GIF__QUIRK_FIRST_FRAME_LOCAL_PALETTE_MEANS_BLACK_BACKGROUND 1041635329 | |
| #define WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR 1041635330 | |
| #define WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA 1041635331 | |
| #define WUFFS_GIF__QUIRK_IMAGE_BOUNDS_ARE_STRICT 1041635332 | |
| #define WUFFS_GIF__QUIRK_REJECT_EMPTY_FRAME 1041635333 | |
| #define WUFFS_GIF__QUIRK_REJECT_EMPTY_PALETTE 1041635334 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_gif__decoder__struct wuffs_gif__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_gif__decoder__initialize( | |
| wuffs_gif__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_gif__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_gif__decoder* | |
| wuffs_gif__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_gif__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_gif__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_gif__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_gif__decoder__set_quirk_enabled( | |
| wuffs_gif__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gif__decoder__decode_image_config( | |
| wuffs_gif__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_gif__decoder__set_report_metadata( | |
| wuffs_gif__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gif__decoder__tell_me_more( | |
| wuffs_gif__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_gif__decoder__num_animation_loops( | |
| const wuffs_gif__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_gif__decoder__num_decoded_frame_configs( | |
| const wuffs_gif__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_gif__decoder__num_decoded_frames( | |
| const wuffs_gif__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_gif__decoder__frame_dirty_rect( | |
| const wuffs_gif__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_gif__decoder__workbuf_len( | |
| const wuffs_gif__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gif__decoder__restart_frame( | |
| wuffs_gif__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gif__decoder__decode_frame_config( | |
| wuffs_gif__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gif__decoder__decode_frame( | |
| wuffs_gif__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_gif__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint8_t f_call_sequence; | |
| bool f_report_metadata_iccp; | |
| bool f_report_metadata_xmp; | |
| uint32_t f_metadata_fourcc; | |
| uint64_t f_metadata_io_position; | |
| bool f_quirks[7]; | |
| bool f_delayed_num_decoded_frames; | |
| bool f_previous_lzw_decode_ended_abruptly; | |
| bool f_seen_header; | |
| bool f_has_global_palette; | |
| uint8_t f_interlace; | |
| bool f_seen_num_animation_loops_value; | |
| uint32_t f_num_animation_loops_value; | |
| uint32_t f_background_color_u32_argb_premul; | |
| uint32_t f_black_color_u32_argb_premul; | |
| bool f_gc_has_transparent_index; | |
| uint8_t f_gc_transparent_index; | |
| uint8_t f_gc_disposal; | |
| uint64_t f_gc_duration; | |
| uint64_t f_frame_config_io_position; | |
| uint64_t f_num_decoded_frame_configs_value; | |
| uint64_t f_num_decoded_frames_value; | |
| uint32_t f_frame_rect_x0; | |
| uint32_t f_frame_rect_y0; | |
| uint32_t f_frame_rect_x1; | |
| uint32_t f_frame_rect_y1; | |
| uint32_t f_dst_x; | |
| uint32_t f_dst_y; | |
| uint32_t f_dirty_max_excl_y; | |
| uint64_t f_compressed_ri; | |
| uint64_t f_compressed_wi; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_tell_me_more[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_skip_frame[1]; | |
| uint32_t p_decode_frame[1]; | |
| uint32_t p_decode_up_to_id_part1[1]; | |
| uint32_t p_decode_header[1]; | |
| uint32_t p_decode_lsd[1]; | |
| uint32_t p_decode_extension[1]; | |
| uint32_t p_skip_blocks[1]; | |
| uint32_t p_decode_ae[1]; | |
| uint32_t p_decode_gc[1]; | |
| uint32_t p_decode_id_part0[1]; | |
| uint32_t p_decode_id_part1[1]; | |
| uint32_t p_decode_id_part2[1]; | |
| } private_impl; | |
| struct { | |
| uint8_t f_compressed[4096]; | |
| uint8_t f_palettes[2][1024]; | |
| uint8_t f_dst_palette[1024]; | |
| wuffs_lzw__decoder f_lzw; | |
| struct { | |
| uint32_t v_background_color; | |
| } s_decode_frame_config[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_skip_frame[1]; | |
| struct { | |
| uint8_t v_c[6]; | |
| uint32_t v_i; | |
| } s_decode_header[1]; | |
| struct { | |
| uint8_t v_flags; | |
| uint8_t v_background_color_index; | |
| uint32_t v_num_palette_entries; | |
| uint32_t v_i; | |
| uint64_t scratch; | |
| } s_decode_lsd[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_skip_blocks[1]; | |
| struct { | |
| uint8_t v_block_size; | |
| bool v_is_animexts; | |
| bool v_is_netscape; | |
| bool v_is_iccp; | |
| bool v_is_xmp; | |
| uint64_t scratch; | |
| } s_decode_ae[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_gc[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_id_part0[1]; | |
| struct { | |
| uint8_t v_which_palette; | |
| uint32_t v_num_palette_entries; | |
| uint32_t v_i; | |
| uint64_t scratch; | |
| } s_decode_id_part1[1]; | |
| struct { | |
| uint64_t v_block_size; | |
| bool v_need_block_size; | |
| uint64_t scratch; | |
| } s_decode_id_part2[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_gif__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_gif__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_gif__decoder__struct() = delete; | |
| wuffs_gif__decoder__struct(const wuffs_gif__decoder__struct&) = delete; | |
| wuffs_gif__decoder__struct& operator=( | |
| const wuffs_gif__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_gif__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_gif__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_gif__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_gif__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_gif__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_gif__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_gif__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_gif__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_gif__decoder__frame_dirty_rect(this); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_gif__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_gif__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_gif__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_gif__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_gzip__error__bad_checksum[]; | |
| extern const char wuffs_gzip__error__bad_compression_method[]; | |
| extern const char wuffs_gzip__error__bad_encoding_flags[]; | |
| extern const char wuffs_gzip__error__bad_header[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_gzip__decoder__struct wuffs_gzip__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_gzip__decoder__initialize( | |
| wuffs_gzip__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_gzip__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_gzip__decoder* | |
| wuffs_gzip__decoder__alloc(); | |
| static inline wuffs_base__io_transformer* | |
| wuffs_gzip__decoder__alloc_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)(wuffs_gzip__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__io_transformer* | |
| wuffs_gzip__decoder__upcast_as__wuffs_base__io_transformer( | |
| wuffs_gzip__decoder* p) { | |
| return (wuffs_base__io_transformer*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_gzip__decoder__set_quirk_enabled( | |
| wuffs_gzip__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_gzip__decoder__workbuf_len( | |
| const wuffs_gzip__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_gzip__decoder__transform_io( | |
| wuffs_gzip__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_gzip__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__io_transformer; | |
| wuffs_base__vtable null_vtable; | |
| bool f_ignore_checksum; | |
| uint32_t p_transform_io[1]; | |
| } private_impl; | |
| struct { | |
| wuffs_crc32__ieee_hasher f_checksum; | |
| wuffs_deflate__decoder f_flate; | |
| struct { | |
| uint8_t v_flags; | |
| uint32_t v_checksum_got; | |
| uint32_t v_decoded_length_got; | |
| uint32_t v_checksum_want; | |
| uint64_t scratch; | |
| } s_transform_io[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_gzip__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_gzip__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__io_transformer::unique_ptr | |
| alloc_as__wuffs_base__io_transformer() { | |
| return wuffs_base__io_transformer::unique_ptr( | |
| wuffs_gzip__decoder__alloc_as__wuffs_base__io_transformer(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_gzip__decoder__struct() = delete; | |
| wuffs_gzip__decoder__struct(const wuffs_gzip__decoder__struct&) = delete; | |
| wuffs_gzip__decoder__struct& operator=( | |
| const wuffs_gzip__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_gzip__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__io_transformer* | |
| upcast_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_gzip__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_gzip__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_gzip__decoder__transform_io(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_gzip__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_json__error__bad_c0_control_code[]; | |
| extern const char wuffs_json__error__bad_utf_8[]; | |
| extern const char wuffs_json__error__bad_backslash_escape[]; | |
| extern const char wuffs_json__error__bad_input[]; | |
| extern const char wuffs_json__error__bad_new_line_in_a_string[]; | |
| extern const char wuffs_json__error__bad_quirk_combination[]; | |
| extern const char wuffs_json__error__unsupported_number_length[]; | |
| extern const char wuffs_json__error__unsupported_recursion_depth[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| #define WUFFS_JSON__DECODER_DEPTH_MAX_INCL 1024 | |
| #define WUFFS_JSON__DECODER_DST_TOKEN_BUFFER_LENGTH_MIN_INCL 1 | |
| #define WUFFS_JSON__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 100 | |
| #define WUFFS_JSON__QUIRK_ALLOW_ASCII_CONTROL_CODES 1225364480 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A 1225364481 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U 1225364482 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E 1225364483 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_NEW_LINE 1225364484 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK 1225364485 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE 1225364486 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V 1225364487 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS 1225364489 | |
| #define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO 1225364490 | |
| #define WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK 1225364491 | |
| #define WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE 1225364492 | |
| #define WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA 1225364493 | |
| #define WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS 1225364494 | |
| #define WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR 1225364495 | |
| #define WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK 1225364496 | |
| #define WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER 1225364497 | |
| #define WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF 1225364498 | |
| #define WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T 1225364499 | |
| #define WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE 1225364500 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_json__decoder__struct wuffs_json__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_json__decoder__initialize( | |
| wuffs_json__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_json__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_json__decoder* | |
| wuffs_json__decoder__alloc(); | |
| static inline wuffs_base__token_decoder* | |
| wuffs_json__decoder__alloc_as__wuffs_base__token_decoder() { | |
| return (wuffs_base__token_decoder*)(wuffs_json__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__token_decoder* | |
| wuffs_json__decoder__upcast_as__wuffs_base__token_decoder( | |
| wuffs_json__decoder* p) { | |
| return (wuffs_base__token_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_json__decoder__set_quirk_enabled( | |
| wuffs_json__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_json__decoder__workbuf_len( | |
| const wuffs_json__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_json__decoder__decode_tokens( | |
| wuffs_json__decoder* self, | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_json__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__token_decoder; | |
| wuffs_base__vtable null_vtable; | |
| bool f_quirks[21]; | |
| bool f_allow_leading_ars; | |
| bool f_allow_leading_ubom; | |
| bool f_end_of_data; | |
| uint8_t f_trailer_stop; | |
| uint8_t f_comment_type; | |
| uint32_t p_decode_tokens[1]; | |
| uint32_t p_decode_leading[1]; | |
| uint32_t p_decode_comment[1]; | |
| uint32_t p_decode_inf_nan[1]; | |
| uint32_t p_decode_trailer[1]; | |
| } private_impl; | |
| struct { | |
| uint32_t f_stack[32]; | |
| struct { | |
| uint32_t v_depth; | |
| uint32_t v_expect; | |
| uint32_t v_expect_after_value; | |
| } s_decode_tokens[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_json__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_json__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__token_decoder::unique_ptr | |
| alloc_as__wuffs_base__token_decoder() { | |
| return wuffs_base__token_decoder::unique_ptr( | |
| wuffs_json__decoder__alloc_as__wuffs_base__token_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_json__decoder__struct() = delete; | |
| wuffs_json__decoder__struct(const wuffs_json__decoder__struct&) = delete; | |
| wuffs_json__decoder__struct& operator=( | |
| const wuffs_json__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_json__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__token_decoder* | |
| upcast_as__wuffs_base__token_decoder() { | |
| return (wuffs_base__token_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_json__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_json__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| decode_tokens( | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_json__decoder__decode_tokens(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_json__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_nie__error__bad_header[]; | |
| extern const char wuffs_nie__error__unsupported_nie_file[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_NIE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_nie__decoder__struct wuffs_nie__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_nie__decoder__initialize( | |
| wuffs_nie__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_nie__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_nie__decoder* | |
| wuffs_nie__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_nie__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_nie__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_nie__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_nie__decoder__set_quirk_enabled( | |
| wuffs_nie__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_nie__decoder__decode_image_config( | |
| wuffs_nie__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_nie__decoder__decode_frame_config( | |
| wuffs_nie__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_nie__decoder__decode_frame( | |
| wuffs_nie__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_nie__decoder__frame_dirty_rect( | |
| const wuffs_nie__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_nie__decoder__num_animation_loops( | |
| const wuffs_nie__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_nie__decoder__num_decoded_frame_configs( | |
| const wuffs_nie__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_nie__decoder__num_decoded_frames( | |
| const wuffs_nie__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_nie__decoder__restart_frame( | |
| wuffs_nie__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_nie__decoder__set_report_metadata( | |
| wuffs_nie__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_nie__decoder__tell_me_more( | |
| wuffs_nie__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_nie__decoder__workbuf_len( | |
| const wuffs_nie__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_nie__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_pixfmt; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint8_t f_call_sequence; | |
| uint32_t f_dst_x; | |
| uint32_t f_dst_y; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_decode_frame[1]; | |
| } private_impl; | |
| struct { | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_image_config[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_nie__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_nie__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_nie__decoder__struct() = delete; | |
| wuffs_nie__decoder__struct(const wuffs_nie__decoder__struct&) = delete; | |
| wuffs_nie__decoder__struct& operator=( | |
| const wuffs_nie__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_nie__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_nie__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_nie__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_nie__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_nie__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_nie__decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_nie__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_nie__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_nie__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_nie__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_nie__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_nie__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_nie__decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_nie__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_zlib__note__dictionary_required[]; | |
| extern const char wuffs_zlib__error__bad_checksum[]; | |
| extern const char wuffs_zlib__error__bad_compression_method[]; | |
| extern const char wuffs_zlib__error__bad_compression_window_size[]; | |
| extern const char wuffs_zlib__error__bad_parity_check[]; | |
| extern const char wuffs_zlib__error__incorrect_dictionary[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2113790976 | |
| #define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_zlib__decoder__struct wuffs_zlib__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_zlib__decoder__initialize( | |
| wuffs_zlib__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_zlib__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_zlib__decoder* | |
| wuffs_zlib__decoder__alloc(); | |
| static inline wuffs_base__io_transformer* | |
| wuffs_zlib__decoder__alloc_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)(wuffs_zlib__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__io_transformer* | |
| wuffs_zlib__decoder__upcast_as__wuffs_base__io_transformer( | |
| wuffs_zlib__decoder* p) { | |
| return (wuffs_base__io_transformer*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_zlib__decoder__dictionary_id( | |
| const wuffs_zlib__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_zlib__decoder__add_dictionary( | |
| wuffs_zlib__decoder* self, | |
| wuffs_base__slice_u8 a_dict); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_zlib__decoder__set_quirk_enabled( | |
| wuffs_zlib__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_zlib__decoder__workbuf_len( | |
| const wuffs_zlib__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_zlib__decoder__transform_io( | |
| wuffs_zlib__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_zlib__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__io_transformer; | |
| wuffs_base__vtable null_vtable; | |
| bool f_bad_call_sequence; | |
| bool f_header_complete; | |
| bool f_got_dictionary; | |
| bool f_want_dictionary; | |
| bool f_quirks[1]; | |
| bool f_ignore_checksum; | |
| uint32_t f_dict_id_got; | |
| uint32_t f_dict_id_want; | |
| uint32_t p_transform_io[1]; | |
| } private_impl; | |
| struct { | |
| wuffs_adler32__hasher f_checksum; | |
| wuffs_adler32__hasher f_dict_id_hasher; | |
| wuffs_deflate__decoder f_flate; | |
| struct { | |
| uint32_t v_checksum_got; | |
| uint64_t scratch; | |
| } s_transform_io[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_zlib__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_zlib__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__io_transformer::unique_ptr | |
| alloc_as__wuffs_base__io_transformer() { | |
| return wuffs_base__io_transformer::unique_ptr( | |
| wuffs_zlib__decoder__alloc_as__wuffs_base__io_transformer(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_zlib__decoder__struct() = delete; | |
| wuffs_zlib__decoder__struct(const wuffs_zlib__decoder__struct&) = delete; | |
| wuffs_zlib__decoder__struct& operator=( | |
| const wuffs_zlib__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_zlib__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__io_transformer* | |
| upcast_as__wuffs_base__io_transformer() { | |
| return (wuffs_base__io_transformer*)this; | |
| } | |
| inline uint32_t | |
| dictionary_id() const { | |
| return wuffs_zlib__decoder__dictionary_id(this); | |
| } | |
| inline wuffs_base__empty_struct | |
| add_dictionary( | |
| wuffs_base__slice_u8 a_dict) { | |
| return wuffs_zlib__decoder__add_dictionary(this, a_dict); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_zlib__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_zlib__decoder__workbuf_len(this); | |
| } | |
| inline wuffs_base__status | |
| transform_io( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| return wuffs_zlib__decoder__transform_io(this, a_dst, a_src, a_workbuf); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_zlib__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_png__error__bad_animation_sequence_number[]; | |
| extern const char wuffs_png__error__bad_checksum[]; | |
| extern const char wuffs_png__error__bad_chunk[]; | |
| extern const char wuffs_png__error__bad_filter[]; | |
| extern const char wuffs_png__error__bad_header[]; | |
| extern const char wuffs_png__error__bad_text_chunk_not_latin_1[]; | |
| extern const char wuffs_png__error__missing_palette[]; | |
| extern const char wuffs_png__error__unsupported_cgbi_extension[]; | |
| extern const char wuffs_png__error__unsupported_png_compression_method[]; | |
| extern const char wuffs_png__error__unsupported_png_file[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 2251799562027015 | |
| #define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_png__decoder__struct wuffs_png__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_png__decoder__initialize( | |
| wuffs_png__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_png__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_png__decoder* | |
| wuffs_png__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_png__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_png__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_png__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_png__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_png__decoder__set_quirk_enabled( | |
| wuffs_png__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_png__decoder__decode_image_config( | |
| wuffs_png__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_png__decoder__decode_frame_config( | |
| wuffs_png__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_png__decoder__decode_frame( | |
| wuffs_png__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_png__decoder__frame_dirty_rect( | |
| const wuffs_png__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_png__decoder__num_animation_loops( | |
| const wuffs_png__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_png__decoder__num_decoded_frame_configs( | |
| const wuffs_png__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_png__decoder__num_decoded_frames( | |
| const wuffs_png__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_png__decoder__restart_frame( | |
| wuffs_png__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_png__decoder__set_report_metadata( | |
| wuffs_png__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_png__decoder__tell_me_more( | |
| wuffs_png__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_png__decoder__workbuf_len( | |
| const wuffs_png__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_png__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint64_t f_pass_bytes_per_row; | |
| uint64_t f_workbuf_wi; | |
| uint64_t f_workbuf_hist_pos_base; | |
| uint64_t f_overall_workbuf_length; | |
| uint64_t f_pass_workbuf_length; | |
| uint8_t f_call_sequence; | |
| bool f_report_metadata_chrm; | |
| bool f_report_metadata_exif; | |
| bool f_report_metadata_gama; | |
| bool f_report_metadata_iccp; | |
| bool f_report_metadata_kvp; | |
| bool f_report_metadata_srgb; | |
| bool f_ignore_checksum; | |
| uint8_t f_depth; | |
| uint8_t f_color_type; | |
| uint8_t f_filter_distance; | |
| uint8_t f_interlace_pass; | |
| bool f_seen_actl; | |
| bool f_seen_chrm; | |
| bool f_seen_fctl; | |
| bool f_seen_exif; | |
| bool f_seen_gama; | |
| bool f_seen_iccp; | |
| bool f_seen_idat; | |
| bool f_seen_ihdr; | |
| bool f_seen_plte; | |
| bool f_seen_srgb; | |
| bool f_seen_trns; | |
| bool f_metadata_is_zlib_compressed; | |
| bool f_zlib_is_dirty; | |
| uint32_t f_chunk_type; | |
| uint8_t f_chunk_type_array[4]; | |
| uint32_t f_chunk_length; | |
| uint64_t f_remap_transparency; | |
| uint32_t f_dst_pixfmt; | |
| uint32_t f_src_pixfmt; | |
| uint32_t f_num_animation_frames_value; | |
| uint32_t f_num_animation_loops_value; | |
| uint32_t f_num_decoded_frame_configs_value; | |
| uint32_t f_num_decoded_frames_value; | |
| uint32_t f_frame_rect_x0; | |
| uint32_t f_frame_rect_y0; | |
| uint32_t f_frame_rect_x1; | |
| uint32_t f_frame_rect_y1; | |
| uint32_t f_first_rect_x0; | |
| uint32_t f_first_rect_y0; | |
| uint32_t f_first_rect_x1; | |
| uint32_t f_first_rect_y1; | |
| uint64_t f_frame_config_io_position; | |
| uint64_t f_first_config_io_position; | |
| uint64_t f_frame_duration; | |
| uint64_t f_first_duration; | |
| uint8_t f_frame_disposal; | |
| uint8_t f_first_disposal; | |
| bool f_frame_overwrite_instead_of_blend; | |
| bool f_first_overwrite_instead_of_blend; | |
| uint32_t f_next_animation_seq_num; | |
| uint32_t f_metadata_flavor; | |
| uint32_t f_metadata_fourcc; | |
| uint64_t f_metadata_x; | |
| uint64_t f_metadata_y; | |
| uint64_t f_metadata_z; | |
| uint32_t f_ztxt_ri; | |
| uint32_t f_ztxt_wi; | |
| uint64_t f_ztxt_hist_pos; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| wuffs_base__empty_struct (*choosy_filter_1)( | |
| wuffs_png__decoder* self, | |
| wuffs_base__slice_u8 a_curr); | |
| wuffs_base__empty_struct (*choosy_filter_3)( | |
| wuffs_png__decoder* self, | |
| wuffs_base__slice_u8 a_curr, | |
| wuffs_base__slice_u8 a_prev); | |
| wuffs_base__empty_struct (*choosy_filter_4)( | |
| wuffs_png__decoder* self, | |
| wuffs_base__slice_u8 a_curr, | |
| wuffs_base__slice_u8 a_prev); | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_decode_ihdr[1]; | |
| uint32_t p_decode_other_chunk[1]; | |
| uint32_t p_decode_actl[1]; | |
| uint32_t p_decode_chrm[1]; | |
| uint32_t p_decode_fctl[1]; | |
| uint32_t p_decode_gama[1]; | |
| uint32_t p_decode_iccp[1]; | |
| uint32_t p_decode_plte[1]; | |
| uint32_t p_decode_srgb[1]; | |
| uint32_t p_decode_trns[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_skip_frame[1]; | |
| uint32_t p_decode_frame[1]; | |
| uint32_t p_decode_pass[1]; | |
| uint32_t p_tell_me_more[1]; | |
| wuffs_base__status (*choosy_filter_and_swizzle)( | |
| wuffs_png__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__slice_u8 a_workbuf); | |
| } private_impl; | |
| struct { | |
| wuffs_crc32__ieee_hasher f_crc32; | |
| wuffs_zlib__decoder f_zlib; | |
| uint8_t f_dst_palette[1024]; | |
| uint8_t f_src_palette[1024]; | |
| struct { | |
| uint32_t v_checksum_have; | |
| uint64_t scratch; | |
| } s_decode_image_config[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_ihdr[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_other_chunk[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_actl[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_chrm[1]; | |
| struct { | |
| uint32_t v_x0; | |
| uint32_t v_x1; | |
| uint32_t v_y1; | |
| uint64_t scratch; | |
| } s_decode_fctl[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_gama[1]; | |
| struct { | |
| uint32_t v_num_entries; | |
| uint32_t v_i; | |
| uint64_t scratch; | |
| } s_decode_plte[1]; | |
| struct { | |
| uint32_t v_i; | |
| uint32_t v_n; | |
| uint64_t scratch; | |
| } s_decode_trns[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_frame_config[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_skip_frame[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_frame[1]; | |
| struct { | |
| uint64_t scratch; | |
| } s_decode_pass[1]; | |
| struct { | |
| wuffs_base__status v_zlib_status; | |
| uint64_t scratch; | |
| } s_tell_me_more[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_png__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_png__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_png__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_png__decoder__struct() = delete; | |
| wuffs_png__decoder__struct(const wuffs_png__decoder__struct&) = delete; | |
| wuffs_png__decoder__struct& operator=( | |
| const wuffs_png__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_png__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_png__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_png__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_png__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_png__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_png__decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_png__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_png__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_png__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_png__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_png__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_png__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_png__decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_png__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_tga__error__bad_header[]; | |
| extern const char wuffs_tga__error__bad_run_length_encoding[]; | |
| extern const char wuffs_tga__error__unsupported_tga_file[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_TGA__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_tga__decoder__struct wuffs_tga__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_tga__decoder__initialize( | |
| wuffs_tga__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_tga__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_tga__decoder* | |
| wuffs_tga__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_tga__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_tga__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_tga__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_tga__decoder__set_quirk_enabled( | |
| wuffs_tga__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_tga__decoder__decode_image_config( | |
| wuffs_tga__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_tga__decoder__decode_frame_config( | |
| wuffs_tga__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_tga__decoder__decode_frame( | |
| wuffs_tga__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_tga__decoder__frame_dirty_rect( | |
| const wuffs_tga__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_tga__decoder__num_animation_loops( | |
| const wuffs_tga__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_tga__decoder__num_decoded_frame_configs( | |
| const wuffs_tga__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_tga__decoder__num_decoded_frames( | |
| const wuffs_tga__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_tga__decoder__restart_frame( | |
| wuffs_tga__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_tga__decoder__set_report_metadata( | |
| wuffs_tga__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_tga__decoder__tell_me_more( | |
| wuffs_tga__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_tga__decoder__workbuf_len( | |
| const wuffs_tga__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_tga__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint8_t f_call_sequence; | |
| uint8_t f_header_id_length; | |
| uint8_t f_header_color_map_type; | |
| uint8_t f_header_image_type; | |
| uint16_t f_header_color_map_first_entry_index; | |
| uint16_t f_header_color_map_length; | |
| uint8_t f_header_color_map_entry_size; | |
| uint8_t f_header_pixel_depth; | |
| uint8_t f_header_image_descriptor; | |
| bool f_opaque; | |
| uint32_t f_scratch_bytes_per_pixel; | |
| uint32_t f_src_bytes_per_pixel; | |
| uint32_t f_src_pixfmt; | |
| uint64_t f_frame_config_io_position; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_decode_frame[1]; | |
| } private_impl; | |
| struct { | |
| uint8_t f_dst_palette[1024]; | |
| uint8_t f_src_palette[1024]; | |
| uint8_t f_scratch[4]; | |
| struct { | |
| uint32_t v_i; | |
| uint64_t scratch; | |
| } s_decode_image_config[1]; | |
| struct { | |
| uint64_t v_dst_bytes_per_pixel; | |
| uint32_t v_dst_x; | |
| uint32_t v_dst_y; | |
| uint64_t v_mark; | |
| uint32_t v_num_pixels32; | |
| uint32_t v_lit_length; | |
| uint32_t v_run_length; | |
| uint64_t v_num_dst_bytes; | |
| uint64_t scratch; | |
| } s_decode_frame[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_tga__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_tga__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_tga__decoder__struct() = delete; | |
| wuffs_tga__decoder__struct(const wuffs_tga__decoder__struct&) = delete; | |
| wuffs_tga__decoder__struct& operator=( | |
| const wuffs_tga__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_tga__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_tga__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_tga__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_tga__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_tga__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_tga__decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_tga__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_tga__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_tga__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_tga__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_tga__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_tga__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_tga__decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_tga__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| // ---------------- Status Codes | |
| extern const char wuffs_wbmp__error__bad_header[]; | |
| // ---------------- Public Consts | |
| #define WUFFS_WBMP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 | |
| // ---------------- Struct Declarations | |
| typedef struct wuffs_wbmp__decoder__struct wuffs_wbmp__decoder; | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Public Initializer Prototypes | |
| // For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, | |
| // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". | |
| // | |
| // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. | |
| // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. | |
| wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| wuffs_wbmp__decoder__initialize( | |
| wuffs_wbmp__decoder* self, | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options); | |
| size_t | |
| sizeof__wuffs_wbmp__decoder(); | |
| // ---------------- Allocs | |
| // These functions allocate and initialize Wuffs structs. They return NULL if | |
| // memory allocation fails. If they return non-NULL, there is no need to call | |
| // wuffs_foo__bar__initialize, but the caller is responsible for eventually | |
| // calling free on the returned pointer. That pointer is effectively a C++ | |
| // std::unique_ptr<T, decltype(&free)>. | |
| wuffs_wbmp__decoder* | |
| wuffs_wbmp__decoder__alloc(); | |
| static inline wuffs_base__image_decoder* | |
| wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)(wuffs_wbmp__decoder__alloc()); | |
| } | |
| // ---------------- Upcasts | |
| static inline wuffs_base__image_decoder* | |
| wuffs_wbmp__decoder__upcast_as__wuffs_base__image_decoder( | |
| wuffs_wbmp__decoder* p) { | |
| return (wuffs_base__image_decoder*)p; | |
| } | |
| // ---------------- Public Function Prototypes | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_wbmp__decoder__set_quirk_enabled( | |
| wuffs_wbmp__decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_wbmp__decoder__decode_image_config( | |
| wuffs_wbmp__decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_wbmp__decoder__decode_frame_config( | |
| wuffs_wbmp__decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_wbmp__decoder__decode_frame( | |
| wuffs_wbmp__decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_wbmp__decoder__frame_dirty_rect( | |
| const wuffs_wbmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_wbmp__decoder__num_animation_loops( | |
| const wuffs_wbmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_wbmp__decoder__num_decoded_frame_configs( | |
| const wuffs_wbmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_wbmp__decoder__num_decoded_frames( | |
| const wuffs_wbmp__decoder* self); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_wbmp__decoder__restart_frame( | |
| wuffs_wbmp__decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_wbmp__decoder__set_report_metadata( | |
| wuffs_wbmp__decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_wbmp__decoder__tell_me_more( | |
| wuffs_wbmp__decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src); | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_wbmp__decoder__workbuf_len( | |
| const wuffs_wbmp__decoder* self); | |
| #ifdef __cplusplus | |
| } // extern "C" | |
| #endif | |
| // ---------------- Struct Definitions | |
| // These structs' fields, and the sizeof them, are private implementation | |
| // details that aren't guaranteed to be stable across Wuffs versions. | |
| // | |
| // See https://en.wikipedia.org/wiki/Opaque_pointer#C | |
| #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| struct wuffs_wbmp__decoder__struct { | |
| // Do not access the private_impl's or private_data's fields directly. There | |
| // is no API/ABI compatibility or safety guarantee if you do so. Instead, use | |
| // the wuffs_foo__bar__baz functions. | |
| // | |
| // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct | |
| // can be stack allocated when WUFFS_IMPLEMENTATION is defined. | |
| struct { | |
| uint32_t magic; | |
| uint32_t active_coroutine; | |
| wuffs_base__vtable vtable_for__wuffs_base__image_decoder; | |
| wuffs_base__vtable null_vtable; | |
| uint32_t f_width; | |
| uint32_t f_height; | |
| uint8_t f_call_sequence; | |
| uint64_t f_frame_config_io_position; | |
| wuffs_base__pixel_swizzler f_swizzler; | |
| uint32_t p_decode_image_config[1]; | |
| uint32_t p_decode_frame_config[1]; | |
| uint32_t p_decode_frame[1]; | |
| } private_impl; | |
| struct { | |
| struct { | |
| uint32_t v_i; | |
| uint32_t v_x32; | |
| } s_decode_image_config[1]; | |
| struct { | |
| uint64_t v_dst_bytes_per_pixel; | |
| uint32_t v_dst_x; | |
| uint32_t v_dst_y; | |
| uint8_t v_src[1]; | |
| uint8_t v_c; | |
| } s_decode_frame[1]; | |
| } private_data; | |
| #ifdef __cplusplus | |
| #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| using unique_ptr = std::unique_ptr<wuffs_wbmp__decoder, decltype(&free)>; | |
| // On failure, the alloc_etc functions return nullptr. They don't throw. | |
| static inline unique_ptr | |
| alloc() { | |
| return unique_ptr(wuffs_wbmp__decoder__alloc(), &free); | |
| } | |
| static inline wuffs_base__image_decoder::unique_ptr | |
| alloc_as__wuffs_base__image_decoder() { | |
| return wuffs_base__image_decoder::unique_ptr( | |
| wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder(), &free); | |
| } | |
| #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| #if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| // Disallow constructing or copying an object via standard C++ mechanisms, | |
| // e.g. the "new" operator, as this struct is intentionally opaque. Its total | |
| // size and field layout is not part of the public, stable, memory-safe API. | |
| // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and | |
| // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as | |
| // their first argument) rather than tweaking bar.private_impl.qux fields. | |
| // | |
| // In C, we can just leave wuffs_foo__bar as an incomplete type (unless | |
| // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in | |
| // order to provide convenience methods. These forward on "this", so that you | |
| // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". | |
| wuffs_wbmp__decoder__struct() = delete; | |
| wuffs_wbmp__decoder__struct(const wuffs_wbmp__decoder__struct&) = delete; | |
| wuffs_wbmp__decoder__struct& operator=( | |
| const wuffs_wbmp__decoder__struct&) = delete; | |
| #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) | |
| #if !defined(WUFFS_IMPLEMENTATION) | |
| // As above, the size of the struct is not part of the public API, and unless | |
| // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap | |
| // allocated, not stack allocated. Its size is not intended to be known at | |
| // compile time, but it is unfortunately divulged as a side effect of | |
| // defining C++ convenience methods. Use "sizeof__T()", calling the function, | |
| // instead of "sizeof T", invoking the operator. To make the two values | |
| // different, so that passing the latter will be rejected by the initialize | |
| // function, we add an arbitrary amount of dead weight. | |
| uint8_t dead_weight[123000000]; // 123 MB. | |
| #endif // !defined(WUFFS_IMPLEMENTATION) | |
| inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT | |
| initialize( | |
| size_t sizeof_star_self, | |
| uint64_t wuffs_version, | |
| uint32_t options) { | |
| return wuffs_wbmp__decoder__initialize( | |
| this, sizeof_star_self, wuffs_version, options); | |
| } | |
| inline wuffs_base__image_decoder* | |
| upcast_as__wuffs_base__image_decoder() { | |
| return (wuffs_base__image_decoder*)this; | |
| } | |
| inline wuffs_base__empty_struct | |
| set_quirk_enabled( | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| return wuffs_wbmp__decoder__set_quirk_enabled(this, a_quirk, a_enabled); | |
| } | |
| inline wuffs_base__status | |
| decode_image_config( | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_wbmp__decoder__decode_image_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame_config( | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_wbmp__decoder__decode_frame_config(this, a_dst, a_src); | |
| } | |
| inline wuffs_base__status | |
| decode_frame( | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| return wuffs_wbmp__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } | |
| inline wuffs_base__rect_ie_u32 | |
| frame_dirty_rect() const { | |
| return wuffs_wbmp__decoder__frame_dirty_rect(this); | |
| } | |
| inline uint32_t | |
| num_animation_loops() const { | |
| return wuffs_wbmp__decoder__num_animation_loops(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frame_configs() const { | |
| return wuffs_wbmp__decoder__num_decoded_frame_configs(this); | |
| } | |
| inline uint64_t | |
| num_decoded_frames() const { | |
| return wuffs_wbmp__decoder__num_decoded_frames(this); | |
| } | |
| inline wuffs_base__status | |
| restart_frame( | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| return wuffs_wbmp__decoder__restart_frame(this, a_index, a_io_position); | |
| } | |
| inline wuffs_base__empty_struct | |
| set_report_metadata( | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| return wuffs_wbmp__decoder__set_report_metadata(this, a_fourcc, a_report); | |
| } | |
| inline wuffs_base__status | |
| tell_me_more( | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| return wuffs_wbmp__decoder__tell_me_more(this, a_dst, a_minfo, a_src); | |
| } | |
| inline wuffs_base__range_ii_u64 | |
| workbuf_len() const { | |
| return wuffs_wbmp__decoder__workbuf_len(this); | |
| } | |
| #endif // __cplusplus | |
| }; // struct wuffs_wbmp__decoder__struct | |
| #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) | |
| #if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| // ---------------- Auxiliary - Base | |
| // Auxiliary code is discussed at | |
| // https://github.com/google/wuffs/blob/main/doc/note/auxiliary-code.md | |
| #include <stdio.h> | |
| #include <string> | |
| namespace wuffs_aux { | |
| using IOBuffer = wuffs_base__io_buffer; | |
| // MemOwner represents ownership of some memory. Dynamically allocated memory | |
| // (e.g. from malloc or new) is typically paired with free or delete, invoked | |
| // when the std::unique_ptr is destroyed. Statically allocated memory might use | |
| // MemOwner(nullptr, &free), even if that statically allocated memory is not | |
| // nullptr, since calling free(nullptr) is a no-op. | |
| using MemOwner = std::unique_ptr<void, decltype(&free)>; | |
| namespace sync_io { | |
| // -------- | |
| // DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array. | |
| // It owns that backing array and will free it in its destructor. | |
| // | |
| // The array size can be explicitly extended (by calling the grow method) but, | |
| // unlike a C++ std::vector, there is no implicit extension (e.g. by calling | |
| // std::vector::insert) and its maximum size is capped by the max_incl | |
| // constructor argument. | |
| // | |
| // It contains an IOBuffer-typed field whose reader side provides access to | |
| // previously written bytes and whose writer side provides access to the | |
| // allocated but not-yet-written-to slack space. For Go programmers, this slack | |
| // space is roughly analogous to the s[len(s):cap(s)] space of a slice s. | |
| class DynIOBuffer { | |
| public: | |
| enum GrowResult { | |
| OK = 0, | |
| FailedMaxInclExceeded = 1, | |
| FailedOutOfMemory = 2, | |
| }; | |
| // m_buf holds the dynamically sized byte array and its read/write indexes: | |
| // - m_buf.meta.wi is roughly analogous to a Go slice's length. | |
| // - m_buf.data.len is roughly analogous to a Go slice's capacity. It is | |
| // also equal to the m_buf.data.ptr malloc/realloc size. | |
| // | |
| // Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as | |
| // they are conceptually private to this class), but they can modify the | |
| // bytes referenced by that pointer-length pair (e.g. compactions). | |
| IOBuffer m_buf; | |
| // m_max_incl is an inclusive upper bound on the backing array size. | |
| const uint64_t m_max_incl; | |
| // Constructor and destructor. | |
| explicit DynIOBuffer(uint64_t max_incl); | |
| ~DynIOBuffer(); | |
| // Drop frees the byte array and resets m_buf. The DynIOBuffer can still be | |
| // used after a drop call. It just restarts from zero. | |
| void drop(); | |
| // grow ensures that the byte array size is at least min_incl and at most | |
| // max_incl. It returns FailedMaxInclExceeded if that would require | |
| // allocating more than max_incl bytes, including the case where (min_incl > | |
| // max_incl). It returns FailedOutOfMemory if memory allocation failed. | |
| GrowResult grow(uint64_t min_incl); | |
| private: | |
| // Delete the copy and assign constructors. | |
| DynIOBuffer(const DynIOBuffer&) = delete; | |
| DynIOBuffer& operator=(const DynIOBuffer&) = delete; | |
| static uint64_t round_up(uint64_t min_incl, uint64_t max_incl); | |
| }; | |
| // -------- | |
| class Input { | |
| public: | |
| virtual ~Input(); | |
| virtual IOBuffer* BringsItsOwnIOBuffer(); | |
| virtual std::string CopyIn(IOBuffer* dst) = 0; | |
| }; | |
| // -------- | |
| // FileInput is an Input that reads from a file source. | |
| // | |
| // It does not take responsibility for closing the file when done. | |
| class FileInput : public Input { | |
| public: | |
| FileInput(FILE* f); | |
| virtual std::string CopyIn(IOBuffer* dst); | |
| private: | |
| FILE* m_f; | |
| // Delete the copy and assign constructors. | |
| FileInput(const FileInput&) = delete; | |
| FileInput& operator=(const FileInput&) = delete; | |
| }; | |
| // -------- | |
| // MemoryInput is an Input that reads from an in-memory source. | |
| // | |
| // It does not take responsibility for freeing the memory when done. | |
| class MemoryInput : public Input { | |
| public: | |
| MemoryInput(const char* ptr, size_t len); | |
| MemoryInput(const uint8_t* ptr, size_t len); | |
| virtual IOBuffer* BringsItsOwnIOBuffer(); | |
| virtual std::string CopyIn(IOBuffer* dst); | |
| private: | |
| IOBuffer m_io; | |
| // Delete the copy and assign constructors. | |
| MemoryInput(const MemoryInput&) = delete; | |
| MemoryInput& operator=(const MemoryInput&) = delete; | |
| }; | |
| // -------- | |
| } // namespace sync_io | |
| } // namespace wuffs_aux | |
| // ---------------- Auxiliary - CBOR | |
| namespace wuffs_aux { | |
| struct DecodeCborResult { | |
| DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0); | |
| std::string error_message; | |
| uint64_t cursor_position; | |
| }; | |
| class DecodeCborCallbacks { | |
| public: | |
| virtual ~DecodeCborCallbacks(); | |
| // AppendXxx are called for leaf nodes: literals, numbers, strings, etc. | |
| virtual std::string AppendNull() = 0; | |
| virtual std::string AppendUndefined() = 0; | |
| virtual std::string AppendBool(bool val) = 0; | |
| virtual std::string AppendF64(double val) = 0; | |
| virtual std::string AppendI64(int64_t val) = 0; | |
| virtual std::string AppendU64(uint64_t val) = 0; | |
| virtual std::string AppendByteString(std::string&& val) = 0; | |
| virtual std::string AppendTextString(std::string&& val) = 0; | |
| virtual std::string AppendMinus1MinusX(uint64_t val) = 0; | |
| virtual std::string AppendCborSimpleValue(uint8_t val) = 0; | |
| virtual std::string AppendCborTag(uint64_t val) = 0; | |
| // Push and Pop are called for container nodes: CBOR arrays (lists) and CBOR | |
| // maps (dictionaries). | |
| // | |
| // The flags bits combine exactly one of: | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT | |
| // and exactly one of: | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT | |
| virtual std::string Push(uint32_t flags) = 0; | |
| virtual std::string Pop(uint32_t flags) = 0; | |
| // Done is always the last Callback method called by DecodeCbor, whether or | |
| // not parsing the input as CBOR encountered an error. Even when successful, | |
| // trailing data may remain in input and buffer. | |
| // | |
| // Do not keep a reference to buffer or buffer.data.ptr after Done returns, | |
| // as DecodeCbor may then de-allocate the backing array. | |
| // | |
| // The default Done implementation is a no-op. | |
| virtual void // | |
| Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer); | |
| }; | |
| // The FooArgBar types add structure to Foo's optional arguments. They wrap | |
| // inner representations for several reasons: | |
| // - It provides a home for the DefaultValue static method, for Foo callers | |
| // that want to override some but not all optional arguments. | |
| // - It provides the "Bar" name at Foo call sites, which can help self- | |
| // document Foo calls with many arguemnts. | |
| // - It provides some type safety against accidentally transposing or omitting | |
| // adjacent fundamentally-numeric-typed optional arguments. | |
| // DecodeCborArgQuirks wraps an optional argument to DecodeCbor. | |
| struct DecodeCborArgQuirks { | |
| explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0); | |
| explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len); | |
| // DefaultValue returns an empty slice. | |
| static DecodeCborArgQuirks DefaultValue(); | |
| wuffs_base__slice_u32 repr; | |
| }; | |
| // DecodeCbor calls callbacks based on the CBOR-formatted data in input. | |
| // | |
| // On success, the returned error_message is empty and cursor_position counts | |
| // the number of bytes consumed. On failure, error_message is non-empty and | |
| // cursor_position is the location of the error. That error may be a content | |
| // error (invalid CBOR) or an input error (e.g. network failure). | |
| DecodeCborResult // | |
| DecodeCbor(DecodeCborCallbacks& callbacks, | |
| sync_io::Input& input, | |
| DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue()); | |
| } // namespace wuffs_aux | |
| // ---------------- Auxiliary - Image | |
| namespace wuffs_aux { | |
| struct DecodeImageResult { | |
| DecodeImageResult(MemOwner&& pixbuf_mem_owner0, | |
| wuffs_base__pixel_buffer pixbuf0, | |
| std::string&& error_message0); | |
| DecodeImageResult(std::string&& error_message0); | |
| MemOwner pixbuf_mem_owner; | |
| wuffs_base__pixel_buffer pixbuf; | |
| std::string error_message; | |
| }; | |
| // DecodeImageCallbacks are the callbacks given to DecodeImage. They are always | |
| // called in this order: | |
| // 1. SelectDecoder | |
| // 2. HandleMetadata | |
| // 3. SelectPixfmt | |
| // 4. AllocPixbuf | |
| // 5. AllocWorkbuf | |
| // 6. Done | |
| // | |
| // It may return early - the third callback might not be invoked if the second | |
| // one fails - but the final callback (Done) is always invoked. | |
| class DecodeImageCallbacks { | |
| public: | |
| // AllocPixbufResult holds a memory allocation (the result of malloc or new, | |
| // a statically allocated pointer, etc), or an error message. The memory is | |
| // de-allocated when mem_owner goes out of scope and is destroyed. | |
| struct AllocPixbufResult { | |
| AllocPixbufResult(MemOwner&& mem_owner0, wuffs_base__pixel_buffer pixbuf0); | |
| AllocPixbufResult(std::string&& error_message0); | |
| MemOwner mem_owner; | |
| wuffs_base__pixel_buffer pixbuf; | |
| std::string error_message; | |
| }; | |
| // AllocWorkbufResult holds a memory allocation (the result of malloc or new, | |
| // a statically allocated pointer, etc), or an error message. The memory is | |
| // de-allocated when mem_owner goes out of scope and is destroyed. | |
| struct AllocWorkbufResult { | |
| AllocWorkbufResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 workbuf0); | |
| AllocWorkbufResult(std::string&& error_message0); | |
| MemOwner mem_owner; | |
| wuffs_base__slice_u8 workbuf; | |
| std::string error_message; | |
| }; | |
| virtual ~DecodeImageCallbacks(); | |
| // SelectDecoder returns the image decoder for the input data's file format. | |
| // Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat). | |
| // | |
| // Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF], | |
| // such as WUFFS_BASE__FOURCC__JPEG. A zero FourCC value means that Wuffs' | |
| // standard library did not recognize the image format but if SelectDecoder | |
| // was overridden, it may examine the input data's starting bytes and still | |
| // provide its own image decoder, e.g. for an exotic image file format that's | |
| // not in Wuffs' standard library. The prefix_etc fields have the same | |
| // meaning as wuffs_base__magic_number_guess_fourcc arguments. SelectDecoder | |
| // implementations should not modify prefix_data's contents. | |
| // | |
| // SelectDecoder might be called more than once, since some image file | |
| // formats can wrap others. For example, a nominal BMP file can actually | |
| // contain a JPEG or a PNG. | |
| // | |
| // The default SelectDecoder accepts the FOURCC codes listed below. For | |
| // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance | |
| // of the ETC file format is optional (for each value of ETC) and depends on | |
| // the corresponding module to be enabled at compile time (i.e. #define'ing | |
| // WUFFS_CONFIG__MODULE__ETC). | |
| // - WUFFS_BASE__FOURCC__BMP | |
| // - WUFFS_BASE__FOURCC__GIF | |
| // - WUFFS_BASE__FOURCC__NIE | |
| // - WUFFS_BASE__FOURCC__PNG | |
| // - WUFFS_BASE__FOURCC__TGA | |
| // - WUFFS_BASE__FOURCC__WBMP | |
| virtual wuffs_base__image_decoder::unique_ptr // | |
| SelectDecoder(uint32_t fourcc, | |
| wuffs_base__slice_u8 prefix_data, | |
| bool prefix_closed); | |
| // HandleMetadata acknowledges image metadata. minfo.flavor will be one of: | |
| // - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH | |
| // - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED | |
| // If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those | |
| // bytes should not be retained beyond the the HandleMetadata call. | |
| // | |
| // minfo.metadata__fourcc() will typically match one of the | |
| // DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM | | |
| // REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC | |
| // will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA. | |
| // | |
| // It returns an error message, or an empty string on success. | |
| virtual std::string // | |
| HandleMetadata(const wuffs_base__more_information& minfo, | |
| wuffs_base__slice_u8 raw); | |
| // SelectPixfmt returns the destination pixel format for AllocPixbuf. It | |
| // should return wuffs_base__make_pixel_format(etc) called with one of: | |
| // - WUFFS_BASE__PIXEL_FORMAT__BGR_565 | |
| // - WUFFS_BASE__PIXEL_FORMAT__BGR | |
| // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL | |
| // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE | |
| // - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL | |
| // - WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL | |
| // - WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL | |
| // or return image_config.pixcfg.pixel_format(). The latter means to use the | |
| // image file's natural pixel format. For example, GIF images' natural pixel | |
| // format is an indexed one. | |
| // | |
| // Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat). | |
| // | |
| // The default SelectPixfmt implementation returns | |
| // wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) which | |
| // is 4 bytes per pixel (8 bits per channel × 4 channels). | |
| virtual wuffs_base__pixel_format // | |
| SelectPixfmt(const wuffs_base__image_config& image_config); | |
| // AllocPixbuf allocates the pixel buffer. | |
| // | |
| // allow_uninitialized_memory will be true if a valid background_color was | |
| // passed to DecodeImage, since the pixel buffer's contents will be | |
| // overwritten with that color after AllocPixbuf returns. | |
| // | |
| // The default AllocPixbuf implementation allocates either uninitialized or | |
| // zeroed memory. Zeroed memory typically corresponds to filling with opaque | |
| // black or transparent black, depending on the pixel format. | |
| virtual AllocPixbufResult // | |
| AllocPixbuf(const wuffs_base__image_config& image_config, | |
| bool allow_uninitialized_memory); | |
| // AllocWorkbuf allocates the work buffer. The allocated buffer's length | |
| // should be at least len_range.min_incl, but larger allocations (up to | |
| // len_range.max_incl) may have better performance (by using more memory). | |
| // | |
| // The default AllocWorkbuf implementation allocates len_range.max_incl bytes | |
| // of either uninitialized or zeroed memory. | |
| virtual AllocWorkbufResult // | |
| AllocWorkbuf(wuffs_base__range_ii_u64 len_range, | |
| bool allow_uninitialized_memory); | |
| // Done is always the last Callback method called by DecodeImage, whether or | |
| // not parsing the input encountered an error. Even when successful, trailing | |
| // data may remain in input and buffer. | |
| // | |
| // The image_decoder is the one returned by SelectDecoder (if SelectDecoder | |
| // was successful), or a no-op unique_ptr otherwise. Like any unique_ptr, | |
| // ownership moves to the Done implementation. | |
| // | |
| // Do not keep a reference to buffer or buffer.data.ptr after Done returns, | |
| // as DecodeImage may then de-allocate the backing array. | |
| // | |
| // The default Done implementation is a no-op, other than running the | |
| // image_decoder unique_ptr destructor. | |
| virtual void // | |
| Done(DecodeImageResult& result, | |
| sync_io::Input& input, | |
| IOBuffer& buffer, | |
| wuffs_base__image_decoder::unique_ptr image_decoder); | |
| }; | |
| extern const char DecodeImage_BufferIsTooShort[]; | |
| extern const char DecodeImage_MaxInclDimensionExceeded[]; | |
| extern const char DecodeImage_MaxInclMetadataLengthExceeded[]; | |
| extern const char DecodeImage_OutOfMemory[]; | |
| extern const char DecodeImage_UnexpectedEndOfFile[]; | |
| extern const char DecodeImage_UnsupportedImageFormat[]; | |
| extern const char DecodeImage_UnsupportedMetadata[]; | |
| extern const char DecodeImage_UnsupportedPixelBlend[]; | |
| extern const char DecodeImage_UnsupportedPixelConfiguration[]; | |
| extern const char DecodeImage_UnsupportedPixelFormat[]; | |
| // The FooArgBar types add structure to Foo's optional arguments. They wrap | |
| // inner representations for several reasons: | |
| // - It provides a home for the DefaultValue static method, for Foo callers | |
| // that want to override some but not all optional arguments. | |
| // - It provides the "Bar" name at Foo call sites, which can help self- | |
| // document Foo calls with many arguemnts. | |
| // - It provides some type safety against accidentally transposing or omitting | |
| // adjacent fundamentally-numeric-typed optional arguments. | |
| // DecodeImageArgQuirks wraps an optional argument to DecodeImage. | |
| struct DecodeImageArgQuirks { | |
| explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0); | |
| explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len); | |
| // DefaultValue returns an empty slice. | |
| static DecodeImageArgQuirks DefaultValue(); | |
| wuffs_base__slice_u32 repr; | |
| }; | |
| // DecodeImageArgFlags wraps an optional argument to DecodeImage. | |
| struct DecodeImageArgFlags { | |
| explicit DecodeImageArgFlags(uint64_t repr0); | |
| // DefaultValue returns 0. | |
| static DecodeImageArgFlags DefaultValue(); | |
| // TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, EXIF, | |
| // GAMA, ICCP, KVP, SRGB and XMP. | |
| // Background Color. | |
| static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001; | |
| // Primary Chromaticities and White Point. | |
| static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002; | |
| // Exchangeable Image File Format. | |
| static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004; | |
| // Gamma Correction. | |
| static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008; | |
| // International Color Consortium Profile. | |
| static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010; | |
| // Key-Value Pair. | |
| // | |
| // For PNG files, this includes iTXt, tEXt and zTXt chunks. In the | |
| // HandleMetadata callback, the raw argument contains UTF-8 strings. | |
| static constexpr uint64_t REPORT_METADATA_KVP = 0x0020; | |
| // Modification Time. | |
| static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040; | |
| // Offset (2-Dimensional). | |
| static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080; | |
| // Physical Dimensions. | |
| static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100; | |
| // Standard Red Green Blue (Rendering Intent). | |
| static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200; | |
| // Extensible Metadata Platform. | |
| static constexpr uint64_t REPORT_METADATA_XMP = 0x0400; | |
| uint64_t repr; | |
| }; | |
| // DecodeImageArgPixelBlend wraps an optional argument to DecodeImage. | |
| struct DecodeImageArgPixelBlend { | |
| explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0); | |
| // DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC. | |
| static DecodeImageArgPixelBlend DefaultValue(); | |
| wuffs_base__pixel_blend repr; | |
| }; | |
| // DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage. | |
| struct DecodeImageArgBackgroundColor { | |
| explicit DecodeImageArgBackgroundColor( | |
| wuffs_base__color_u32_argb_premul repr0); | |
| // DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul. | |
| static DecodeImageArgBackgroundColor DefaultValue(); | |
| wuffs_base__color_u32_argb_premul repr; | |
| }; | |
| // DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage. | |
| struct DecodeImageArgMaxInclDimension { | |
| explicit DecodeImageArgMaxInclDimension(uint32_t repr0); | |
| // DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels. | |
| static DecodeImageArgMaxInclDimension DefaultValue(); | |
| uint32_t repr; | |
| }; | |
| // DecodeImageArgMaxInclMetadataLength wraps an optional argument to | |
| // DecodeImage. | |
| struct DecodeImageArgMaxInclMetadataLength { | |
| explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0); | |
| // DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB. | |
| static DecodeImageArgMaxInclMetadataLength DefaultValue(); | |
| uint64_t repr; | |
| }; | |
| // DecodeImage decodes the image data in input. A variety of image file formats | |
| // can be decoded, depending on what callbacks.SelectDecoder returns. | |
| // | |
| // For animated formats, only the first frame is returned, since the API is | |
| // simpler for synchronous I/O and having DecodeImage only return when | |
| // completely done, but rendering animation often involves handling other | |
| // events in between animation frames. To decode multiple frames of animated | |
| // images, or for asynchronous I/O (e.g. when decoding an image streamed over | |
| // the network), use Wuffs' lower level C API instead of its higher level, | |
| // simplified C++ API (the wuffs_aux API). | |
| // | |
| // The DecodeImageResult's fields depend on whether decoding succeeded: | |
| // - On total success, the error_message is empty and pixbuf.pixcfg.is_valid() | |
| // is true. | |
| // - On partial success (e.g. the input file was truncated but we are still | |
| // able to decode some of the pixels), error_message is non-empty but | |
| // pixbuf.pixcfg.is_valid() is still true. It is up to the caller whether to | |
| // accept or reject partial success. | |
| // - On failure, the error_message is non_empty and pixbuf.pixcfg.is_valid() | |
| // is false. | |
| // | |
| // The callbacks allocate the pixel buffer memory and work buffer memory. On | |
| // success, pixel buffer memory ownership is passed to the DecodeImage caller | |
| // as the returned pixbuf_mem_owner. Regardless of success or failure, the work | |
| // buffer memory is deleted. | |
| // | |
| // The pixel_blend (one of the constants listed below) determines how to | |
| // composite the decoded image over the pixel buffer's original pixels (as | |
| // returned by callbacks.AllocPixbuf): | |
| // - WUFFS_BASE__PIXEL_BLEND__SRC | |
| // - WUFFS_BASE__PIXEL_BLEND__SRC_OVER | |
| // | |
| // The background_color is used to fill the pixel buffer after | |
| // callbacks.AllocPixbuf returns, if it is valid in the | |
| // wuffs_base__color_u32_argb_premul__is_valid sense. The default value, | |
| // 0x0000_0001, is not valid since its Blue channel value (0x01) is greater | |
| // than its Alpha channel value (0x00). A valid background_color will typically | |
| // be overwritten when pixel_blend is WUFFS_BASE__PIXEL_BLEND__SRC, but might | |
| // still be visible on partial (not total) success or when pixel_blend is | |
| // WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque. | |
| // | |
| // Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's | |
| // width or height is greater than max_incl_dimension or if any opted-in (via | |
| // flags bits) metadata is longer than max_incl_metadata_length. | |
| DecodeImageResult // | |
| DecodeImage(DecodeImageCallbacks& callbacks, | |
| sync_io::Input& input, | |
| DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(), | |
| DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(), | |
| DecodeImageArgPixelBlend pixel_blend = | |
| DecodeImageArgPixelBlend::DefaultValue(), | |
| DecodeImageArgBackgroundColor background_color = | |
| DecodeImageArgBackgroundColor::DefaultValue(), | |
| DecodeImageArgMaxInclDimension max_incl_dimension = | |
| DecodeImageArgMaxInclDimension::DefaultValue(), | |
| DecodeImageArgMaxInclMetadataLength max_incl_metadata_length = | |
| DecodeImageArgMaxInclMetadataLength::DefaultValue()); | |
| } // namespace wuffs_aux | |
| // ---------------- Auxiliary - JSON | |
| namespace wuffs_aux { | |
| struct DecodeJsonResult { | |
| DecodeJsonResult(std::string&& error_message0, uint64_t cursor_position0); | |
| std::string error_message; | |
| uint64_t cursor_position; | |
| }; | |
| class DecodeJsonCallbacks { | |
| public: | |
| virtual ~DecodeJsonCallbacks(); | |
| // AppendXxx are called for leaf nodes: literals, numbers and strings. For | |
| // strings, the Callbacks implementation is responsible for tracking map keys | |
| // versus other values. | |
| virtual std::string AppendNull() = 0; | |
| virtual std::string AppendBool(bool val) = 0; | |
| virtual std::string AppendF64(double val) = 0; | |
| virtual std::string AppendI64(int64_t val) = 0; | |
| virtual std::string AppendTextString(std::string&& val) = 0; | |
| // Push and Pop are called for container nodes: JSON arrays (lists) and JSON | |
| // objects (dictionaries). | |
| // | |
| // The flags bits combine exactly one of: | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT | |
| // and exactly one of: | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST | |
| // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT | |
| virtual std::string Push(uint32_t flags) = 0; | |
| virtual std::string Pop(uint32_t flags) = 0; | |
| // Done is always the last Callback method called by DecodeJson, whether or | |
| // not parsing the input as JSON encountered an error. Even when successful, | |
| // trailing data may remain in input and buffer. See "Unintuitive JSON | |
| // Parsing" (https://nullprogram.com/blog/2019/12/28/) which discusses JSON | |
| // parsing and when it stops. | |
| // | |
| // Do not keep a reference to buffer or buffer.data.ptr after Done returns, | |
| // as DecodeJson may then de-allocate the backing array. | |
| // | |
| // The default Done implementation is a no-op. | |
| virtual void // | |
| Done(DecodeJsonResult& result, sync_io::Input& input, IOBuffer& buffer); | |
| }; | |
| extern const char DecodeJson_BadJsonPointer[]; | |
| extern const char DecodeJson_NoMatch[]; | |
| // The FooArgBar types add structure to Foo's optional arguments. They wrap | |
| // inner representations for several reasons: | |
| // - It provides a home for the DefaultValue static method, for Foo callers | |
| // that want to override some but not all optional arguments. | |
| // - It provides the "Bar" name at Foo call sites, which can help self- | |
| // document Foo calls with many arguemnts. | |
| // - It provides some type safety against accidentally transposing or omitting | |
| // adjacent fundamentally-numeric-typed optional arguments. | |
| // DecodeJsonArgQuirks wraps an optional argument to DecodeJson. | |
| struct DecodeJsonArgQuirks { | |
| explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0); | |
| explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len); | |
| // DefaultValue returns an empty slice. | |
| static DecodeJsonArgQuirks DefaultValue(); | |
| wuffs_base__slice_u32 repr; | |
| }; | |
| // DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson. | |
| struct DecodeJsonArgJsonPointer { | |
| explicit DecodeJsonArgJsonPointer(std::string repr0); | |
| // DefaultValue returns an empty string. | |
| static DecodeJsonArgJsonPointer DefaultValue(); | |
| std::string repr; | |
| }; | |
| // DecodeJson calls callbacks based on the JSON-formatted data in input. | |
| // | |
| // On success, the returned error_message is empty and cursor_position counts | |
| // the number of bytes consumed. On failure, error_message is non-empty and | |
| // cursor_position is the location of the error. That error may be a content | |
| // error (invalid JSON) or an input error (e.g. network failure). | |
| // | |
| // json_pointer is a query in the JSON Pointer (RFC 6901) syntax. The callbacks | |
| // run for the input's sub-node that matches the query. DecodeJson_NoMatch is | |
| // returned if no matching sub-node was found. The empty query matches the | |
| // input's root node, consistent with JSON Pointer semantics. | |
| // | |
| // The JSON Pointer implementation is greedy: duplicate keys are not rejected | |
| // but only the first match for each '/'-separated fragment is followed. | |
| DecodeJsonResult // | |
| DecodeJson(DecodeJsonCallbacks& callbacks, | |
| sync_io::Input& input, | |
| DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(), | |
| DecodeJsonArgJsonPointer json_pointer = | |
| DecodeJsonArgJsonPointer::DefaultValue()); | |
| } // namespace wuffs_aux | |
| #endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR) | |
| // ‼ WUFFS C HEADER ENDS HERE. | |
| #ifdef WUFFS_IMPLEMENTATION | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| // ---------------- Fundamentals | |
| // WUFFS_BASE__MAGIC is a magic number to check that initializers are called. | |
| // It's not foolproof, given C doesn't automatically zero memory before use, | |
| // but it should catch 99.99% of cases. | |
| // | |
| // Its (non-zero) value is arbitrary, based on md5sum("wuffs"). | |
| #define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71) | |
| // WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable | |
| // error was previously encountered. | |
| // | |
| // Its (non-zero) value is arbitrary, based on md5sum("disabled"). | |
| #define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2) | |
| // Use switch cases for coroutine suspension points, similar to the technique | |
| // in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html | |
| // | |
| // The implicit fallthrough is intentional. | |
| // | |
| // We use trivial macros instead of an explicit assignment and case statement | |
| // so that clang-format doesn't get confused by the unusual "case"s. | |
| #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:; | |
| #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \ | |
| coro_susp_point = n; \ | |
| case n:; | |
| #define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ | |
| if (!status.repr) { \ | |
| goto ok; \ | |
| } else if (*status.repr != '$') { \ | |
| goto exit; \ | |
| } \ | |
| coro_susp_point = n; \ | |
| goto suspend; \ | |
| case n:; | |
| // The "defined(__clang__)" isn't redundant. While vanilla clang defines | |
| // __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not. | |
| #if defined(__GNUC__) || defined(__clang__) | |
| #define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1)) | |
| #define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0)) | |
| #else | |
| #define WUFFS_BASE__LIKELY(expr) (expr) | |
| #define WUFFS_BASE__UNLIKELY(expr) (expr) | |
| #endif | |
| // -------- | |
| static inline wuffs_base__empty_struct // | |
| wuffs_base__ignore_status(wuffs_base__status z) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| static inline wuffs_base__status // | |
| wuffs_base__status__ensure_not_a_suspension(wuffs_base__status z) { | |
| if (z.repr && (*z.repr == '$')) { | |
| z.repr = wuffs_base__error__cannot_return_a_suspension; | |
| } | |
| return z; | |
| } | |
| // -------- | |
| // wuffs_base__iterate_total_advance returns the exclusive pointer-offset at | |
| // which iteration should stop. The overall slice has length total_len, each | |
| // iteration's sub-slice has length iter_len and are placed iter_advance apart. | |
| // | |
| // The iter_advance may not be larger than iter_len. The iter_advance may be | |
| // smaller than iter_len, in which case the sub-slices will overlap. | |
| // | |
| // The return value r satisfies ((0 <= r) && (r <= total_len)). | |
| // | |
| // For example, if total_len = 15, iter_len = 5 and iter_advance = 3, there are | |
| // four iterations at offsets 0, 3, 6 and 9. This function returns 12. | |
| // | |
| // 0123456789012345 | |
| // [....] | |
| // [....] | |
| // [....] | |
| // [....] | |
| // $ | |
| // 0123456789012345 | |
| // | |
| // For example, if total_len = 15, iter_len = 5 and iter_advance = 5, there are | |
| // three iterations at offsets 0, 5 and 10. This function returns 15. | |
| // | |
| // 0123456789012345 | |
| // [....] | |
| // [....] | |
| // [....] | |
| // $ | |
| // 0123456789012345 | |
| static inline size_t // | |
| wuffs_base__iterate_total_advance(size_t total_len, | |
| size_t iter_len, | |
| size_t iter_advance) { | |
| if (total_len >= iter_len) { | |
| size_t n = total_len - iter_len; | |
| return ((n / iter_advance) * iter_advance) + iter_advance; | |
| } | |
| return 0; | |
| } | |
| // ---------------- Numeric Types | |
| extern const uint8_t wuffs_base__low_bits_mask__u8[8]; | |
| extern const uint16_t wuffs_base__low_bits_mask__u16[16]; | |
| extern const uint32_t wuffs_base__low_bits_mask__u32[32]; | |
| extern const uint64_t wuffs_base__low_bits_mask__u64[64]; | |
| #define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n]) | |
| #define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n]) | |
| #define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n]) | |
| #define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[n]) | |
| // -------- | |
| static inline void // | |
| wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { | |
| *x = wuffs_base__u8__sat_add(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { | |
| *x = wuffs_base__u8__sat_sub(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { | |
| *x = wuffs_base__u16__sat_add(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { | |
| *x = wuffs_base__u16__sat_sub(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { | |
| *x = wuffs_base__u32__sat_add(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { | |
| *x = wuffs_base__u32__sat_sub(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { | |
| *x = wuffs_base__u64__sat_add(*x, y); | |
| } | |
| static inline void // | |
| wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { | |
| *x = wuffs_base__u64__sat_sub(*x, y); | |
| } | |
| // ---------------- Slices and Tables | |
| // wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) { | |
| if (((uint64_t)(s.len)) > up_to) { | |
| s.len = ((size_t)up_to); | |
| } | |
| return s; | |
| } | |
| // wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) { | |
| if (((uint64_t)(s.len)) > up_to) { | |
| s.ptr += ((uint64_t)(s.len)) - up_to; | |
| s.len = ((size_t)up_to); | |
| } | |
| return s; | |
| } | |
| // wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len) | |
| // where len is the minimum of dst.len and src.len. | |
| // | |
| // Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty | |
| // slice) is valid and results in a no-op. | |
| static inline uint64_t // | |
| wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 src) { | |
| size_t len = dst.len < src.len ? dst.len : src.len; | |
| if (len > 0) { | |
| memmove(dst.ptr, src.ptr, len); | |
| } | |
| return len; | |
| } | |
| // -------- | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) { | |
| if (y < t.height) { | |
| return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width); | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| // ---------------- Slices and Tables (Utility) | |
| #define wuffs_base__utility__empty_slice_u8 wuffs_base__empty_slice_u8 | |
| // ---------------- Ranges and Rects | |
| static inline uint32_t // | |
| wuffs_base__range_ii_u32__get_min_incl(const wuffs_base__range_ii_u32* r) { | |
| return r->min_incl; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__range_ii_u32__get_max_incl(const wuffs_base__range_ii_u32* r) { | |
| return r->max_incl; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__range_ie_u32__get_min_incl(const wuffs_base__range_ie_u32* r) { | |
| return r->min_incl; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__range_ie_u32__get_max_excl(const wuffs_base__range_ie_u32* r) { | |
| return r->max_excl; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__range_ii_u64__get_min_incl(const wuffs_base__range_ii_u64* r) { | |
| return r->min_incl; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__range_ii_u64__get_max_incl(const wuffs_base__range_ii_u64* r) { | |
| return r->max_incl; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__range_ie_u64__get_min_incl(const wuffs_base__range_ie_u64* r) { | |
| return r->min_incl; | |
| } | |
| static inline uint64_t // | |
| wuffs_base__range_ie_u64__get_max_excl(const wuffs_base__range_ie_u64* r) { | |
| return r->max_excl; | |
| } | |
| // ---------------- Ranges and Rects (Utility) | |
| #define wuffs_base__utility__empty_range_ii_u32 wuffs_base__empty_range_ii_u32 | |
| #define wuffs_base__utility__empty_range_ie_u32 wuffs_base__empty_range_ie_u32 | |
| #define wuffs_base__utility__empty_range_ii_u64 wuffs_base__empty_range_ii_u64 | |
| #define wuffs_base__utility__empty_range_ie_u64 wuffs_base__empty_range_ie_u64 | |
| #define wuffs_base__utility__empty_rect_ii_u32 wuffs_base__empty_rect_ii_u32 | |
| #define wuffs_base__utility__empty_rect_ie_u32 wuffs_base__empty_rect_ie_u32 | |
| #define wuffs_base__utility__make_range_ii_u32 wuffs_base__make_range_ii_u32 | |
| #define wuffs_base__utility__make_range_ie_u32 wuffs_base__make_range_ie_u32 | |
| #define wuffs_base__utility__make_range_ii_u64 wuffs_base__make_range_ii_u64 | |
| #define wuffs_base__utility__make_range_ie_u64 wuffs_base__make_range_ie_u64 | |
| #define wuffs_base__utility__make_rect_ii_u32 wuffs_base__make_rect_ii_u32 | |
| #define wuffs_base__utility__make_rect_ie_u32 wuffs_base__make_rect_ie_u32 | |
| // ---------------- I/O | |
| static inline uint64_t // | |
| wuffs_base__io__count_since(uint64_t mark, uint64_t index) { | |
| if (index >= mark) { | |
| return index - mark; | |
| } | |
| return 0; | |
| } | |
| // TODO: drop the "const" in "const uint8_t* ptr". Some though required about | |
| // the base.io_reader.since method returning a mutable "slice base.u8". | |
| #if defined(__GNUC__) | |
| #pragma GCC diagnostic push | |
| #pragma GCC diagnostic ignored "-Wcast-qual" | |
| #endif | |
| static inline wuffs_base__slice_u8 // | |
| wuffs_base__io__since(uint64_t mark, uint64_t index, const uint8_t* ptr) { | |
| if (index >= mark) { | |
| return wuffs_base__make_slice_u8(((uint8_t*)ptr) + mark, | |
| ((size_t)(index - mark))); | |
| } | |
| return wuffs_base__make_slice_u8(NULL, 0); | |
| } | |
| #if defined(__GNUC__) | |
| #pragma GCC diagnostic pop | |
| #endif | |
| // -------- | |
| static inline void // | |
| wuffs_base__io_reader__limit(const uint8_t** ptr_io2_r, | |
| const uint8_t* iop_r, | |
| uint64_t limit) { | |
| if (((uint64_t)(*ptr_io2_r - iop_r)) > limit) { | |
| *ptr_io2_r = iop_r + limit; | |
| } | |
| } | |
| static inline uint32_t // | |
| wuffs_base__io_reader__limited_copy_u32_to_slice(const uint8_t** ptr_iop_r, | |
| const uint8_t* io2_r, | |
| uint32_t length, | |
| wuffs_base__slice_u8 dst) { | |
| const uint8_t* iop_r = *ptr_iop_r; | |
| size_t n = dst.len; | |
| if (n > length) { | |
| n = length; | |
| } | |
| if (n > ((size_t)(io2_r - iop_r))) { | |
| n = (size_t)(io2_r - iop_r); | |
| } | |
| if (n > 0) { | |
| memmove(dst.ptr, iop_r, n); | |
| *ptr_iop_r += n; | |
| } | |
| return (uint32_t)(n); | |
| } | |
| // wuffs_base__io_reader__match7 returns whether the io_reader's upcoming bytes | |
| // start with the given prefix (up to 7 bytes long). It is peek-like, not | |
| // read-like, in that there are no side-effects. | |
| // | |
| // The low 3 bits of a hold the prefix length, n. | |
| // | |
| // The high 56 bits of a hold the prefix itself, in little-endian order. The | |
| // first prefix byte is in bits 8..=15, the second prefix byte is in bits | |
| // 16..=23, etc. The high (8 * (7 - n)) bits are ignored. | |
| // | |
| // There are three possible return values: | |
| // - 0 means success. | |
| // - 1 means inconclusive, equivalent to "$short read". | |
| // - 2 means failure. | |
| static inline uint32_t // | |
| wuffs_base__io_reader__match7(const uint8_t* iop_r, | |
| const uint8_t* io2_r, | |
| wuffs_base__io_buffer* r, | |
| uint64_t a) { | |
| uint32_t n = a & 7; | |
| a >>= 8; | |
| if ((io2_r - iop_r) >= 8) { | |
| uint64_t x = wuffs_base__peek_u64le__no_bounds_check(iop_r); | |
| uint32_t shift = 8 * (8 - n); | |
| return ((a << shift) == (x << shift)) ? 0 : 2; | |
| } | |
| for (; n > 0; n--) { | |
| if (iop_r >= io2_r) { | |
| return (r && r->meta.closed) ? 2 : 1; | |
| } else if (*iop_r != ((uint8_t)(a))) { | |
| return 2; | |
| } | |
| iop_r++; | |
| a >>= 8; | |
| } | |
| return 0; | |
| } | |
| static inline wuffs_base__io_buffer* // | |
| wuffs_base__io_reader__set(wuffs_base__io_buffer* b, | |
| const uint8_t** ptr_iop_r, | |
| const uint8_t** ptr_io0_r, | |
| const uint8_t** ptr_io1_r, | |
| const uint8_t** ptr_io2_r, | |
| wuffs_base__slice_u8 data, | |
| uint64_t history_position) { | |
| b->data = data; | |
| b->meta.wi = data.len; | |
| b->meta.ri = 0; | |
| b->meta.pos = history_position; | |
| b->meta.closed = false; | |
| *ptr_iop_r = data.ptr; | |
| *ptr_io0_r = data.ptr; | |
| *ptr_io1_r = data.ptr; | |
| *ptr_io2_r = data.ptr + data.len; | |
| return b; | |
| } | |
| // -------- | |
| static inline uint64_t // | |
| wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w, | |
| uint8_t* io2_w, | |
| wuffs_base__slice_u8 src) { | |
| uint8_t* iop_w = *ptr_iop_w; | |
| size_t n = src.len; | |
| if (n > ((size_t)(io2_w - iop_w))) { | |
| n = (size_t)(io2_w - iop_w); | |
| } | |
| if (n > 0) { | |
| memmove(iop_w, src.ptr, n); | |
| *ptr_iop_w += n; | |
| } | |
| return (uint64_t)(n); | |
| } | |
| static inline void // | |
| wuffs_base__io_writer__limit(uint8_t** ptr_io2_w, | |
| uint8_t* iop_w, | |
| uint64_t limit) { | |
| if (((uint64_t)(*ptr_io2_w - iop_w)) > limit) { | |
| *ptr_io2_w = iop_w + limit; | |
| } | |
| } | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w, | |
| uint8_t* io0_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| uint32_t distance) { | |
| if (!distance) { | |
| return 0; | |
| } | |
| uint8_t* p = *ptr_iop_w; | |
| if ((size_t)(p - io0_w) < (size_t)(distance)) { | |
| return 0; | |
| } | |
| uint8_t* q = p - distance; | |
| size_t n = (size_t)(io2_w - p); | |
| if ((size_t)(length) > n) { | |
| length = (uint32_t)(n); | |
| } else { | |
| n = (size_t)(length); | |
| } | |
| // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that | |
| // is mostly because 3 is the minimum length for the deflate format. This | |
| // function implementation shouldn't overfit to that one format. Perhaps the | |
| // limited_copy_u32_from_history Wuffs method should also take an unroll hint | |
| // argument, and the cgen can look if that argument is the constant | |
| // expression '3'. | |
| // | |
| // See also wuffs_base__io_writer__limited_copy_u32_from_history_fast below. | |
| for (; n >= 3; n -= 3) { | |
| *p++ = *q++; | |
| *p++ = *q++; | |
| *p++ = *q++; | |
| } | |
| for (; n; n--) { | |
| *p++ = *q++; | |
| } | |
| *ptr_iop_w = p; | |
| return length; | |
| } | |
| // wuffs_base__io_writer__limited_copy_u32_from_history_fast is like the | |
| // wuffs_base__io_writer__limited_copy_u32_from_history function above, but has | |
| // stronger pre-conditions. | |
| // | |
| // The caller needs to prove that: | |
| // - length <= (io2_w - *ptr_iop_w) | |
| // - distance >= 1 | |
| // - distance <= (*ptr_iop_w - io0_w) | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w, | |
| uint8_t* io0_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| uint32_t distance) { | |
| uint8_t* p = *ptr_iop_w; | |
| uint8_t* q = p - distance; | |
| uint32_t n = length; | |
| for (; n >= 3; n -= 3) { | |
| *p++ = *q++; | |
| *p++ = *q++; | |
| *p++ = *q++; | |
| } | |
| for (; n; n--) { | |
| *p++ = *q++; | |
| } | |
| *ptr_iop_w = p; | |
| return length; | |
| } | |
| // wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast | |
| // copies the previous byte (the one immediately before *ptr_iop_w), copying 8 | |
| // byte chunks at a time. Each chunk contains 8 repetitions of the same byte. | |
| // | |
| // In terms of number of bytes copied, length is rounded up to a multiple of 8. | |
| // As a special case, a zero length rounds up to 8 (even though 0 is already a | |
| // multiple of 8), since there is always at least one 8 byte chunk copied. | |
| // | |
| // In terms of advancing *ptr_iop_w, length is not rounded up. | |
| // | |
| // The caller needs to prove that: | |
| // - (length + 8) <= (io2_w - *ptr_iop_w) | |
| // - distance == 1 | |
| // - distance <= (*ptr_iop_w - io0_w) | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast( | |
| uint8_t** ptr_iop_w, | |
| uint8_t* io0_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| uint32_t distance) { | |
| uint8_t* p = *ptr_iop_w; | |
| uint64_t x = p[-1]; | |
| x |= x << 8; | |
| x |= x << 16; | |
| x |= x << 32; | |
| uint32_t n = length; | |
| while (1) { | |
| wuffs_base__poke_u64le__no_bounds_check(p, x); | |
| if (n <= 8) { | |
| p += n; | |
| break; | |
| } | |
| p += 8; | |
| n -= 8; | |
| } | |
| *ptr_iop_w = p; | |
| return length; | |
| } | |
| // wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is | |
| // like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function | |
| // above, but copies 8 byte chunks at a time. | |
| // | |
| // In terms of number of bytes copied, length is rounded up to a multiple of 8. | |
| // As a special case, a zero length rounds up to 8 (even though 0 is already a | |
| // multiple of 8), since there is always at least one 8 byte chunk copied. | |
| // | |
| // In terms of advancing *ptr_iop_w, length is not rounded up. | |
| // | |
| // The caller needs to prove that: | |
| // - (length + 8) <= (io2_w - *ptr_iop_w) | |
| // - distance >= 8 | |
| // - distance <= (*ptr_iop_w - io0_w) | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast( | |
| uint8_t** ptr_iop_w, | |
| uint8_t* io0_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| uint32_t distance) { | |
| uint8_t* p = *ptr_iop_w; | |
| uint8_t* q = p - distance; | |
| uint32_t n = length; | |
| while (1) { | |
| memcpy(p, q, 8); | |
| if (n <= 8) { | |
| p += n; | |
| break; | |
| } | |
| p += 8; | |
| q += 8; | |
| n -= 8; | |
| } | |
| *ptr_iop_w = p; | |
| return length; | |
| } | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_reader(uint8_t** ptr_iop_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| const uint8_t** ptr_iop_r, | |
| const uint8_t* io2_r) { | |
| uint8_t* iop_w = *ptr_iop_w; | |
| size_t n = length; | |
| if (n > ((size_t)(io2_w - iop_w))) { | |
| n = (size_t)(io2_w - iop_w); | |
| } | |
| const uint8_t* iop_r = *ptr_iop_r; | |
| if (n > ((size_t)(io2_r - iop_r))) { | |
| n = (size_t)(io2_r - iop_r); | |
| } | |
| if (n > 0) { | |
| memmove(iop_w, iop_r, n); | |
| *ptr_iop_w += n; | |
| *ptr_iop_r += n; | |
| } | |
| return (uint32_t)(n); | |
| } | |
| static inline uint32_t // | |
| wuffs_base__io_writer__limited_copy_u32_from_slice(uint8_t** ptr_iop_w, | |
| uint8_t* io2_w, | |
| uint32_t length, | |
| wuffs_base__slice_u8 src) { | |
| uint8_t* iop_w = *ptr_iop_w; | |
| size_t n = src.len; | |
| if (n > length) { | |
| n = length; | |
| } | |
| if (n > ((size_t)(io2_w - iop_w))) { | |
| n = (size_t)(io2_w - iop_w); | |
| } | |
| if (n > 0) { | |
| memmove(iop_w, src.ptr, n); | |
| *ptr_iop_w += n; | |
| } | |
| return (uint32_t)(n); | |
| } | |
| static inline wuffs_base__io_buffer* // | |
| wuffs_base__io_writer__set(wuffs_base__io_buffer* b, | |
| uint8_t** ptr_iop_w, | |
| uint8_t** ptr_io0_w, | |
| uint8_t** ptr_io1_w, | |
| uint8_t** ptr_io2_w, | |
| wuffs_base__slice_u8 data, | |
| uint64_t history_position) { | |
| b->data = data; | |
| b->meta.wi = 0; | |
| b->meta.ri = 0; | |
| b->meta.pos = history_position; | |
| b->meta.closed = false; | |
| *ptr_iop_w = data.ptr; | |
| *ptr_io0_w = data.ptr; | |
| *ptr_io1_w = data.ptr; | |
| *ptr_io2_w = data.ptr + data.len; | |
| return b; | |
| } | |
| // ---------------- I/O (Utility) | |
| #define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader | |
| #define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer | |
| // ---------------- Tokens | |
| // ---------------- Tokens (Utility) | |
| // ---------------- Memory Allocation | |
| // ---------------- Images | |
| WUFFS_BASE__MAYBE_STATIC uint64_t // | |
| wuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader( | |
| const wuffs_base__pixel_swizzler* p, | |
| uint32_t up_to_num_pixels, | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| const uint8_t** ptr_iop_r, | |
| const uint8_t* io2_r); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t // | |
| wuffs_base__pixel_swizzler__swizzle_interleaved_from_reader( | |
| const wuffs_base__pixel_swizzler* p, | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| const uint8_t** ptr_iop_r, | |
| const uint8_t* io2_r); | |
| WUFFS_BASE__MAYBE_STATIC uint64_t // | |
| wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black( | |
| const wuffs_base__pixel_swizzler* p, | |
| wuffs_base__slice_u8 dst, | |
| wuffs_base__slice_u8 dst_palette, | |
| uint64_t num_pixels); | |
| // ---------------- Images (Utility) | |
| #define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format | |
| // ---------------- String Conversions | |
| // ---------------- Unicode and UTF-8 | |
| // ---------------- | |
| #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \ | |
| defined(WUFFS_CONFIG__MODULE__BASE__CORE) | |
| const uint8_t wuffs_base__low_bits_mask__u8[8] = { | |
| 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, | |
| }; | |
| const uint16_t wuffs_base__low_bits_mask__u16[16] = { | |
| 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, | |
| 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, | |
| }; | |
| const uint32_t wuffs_base__low_bits_mask__u32[32] = { | |
| 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, | |
| 0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, | |
| 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF, | |
| 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF, | |
| 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF, | |
| 0x3FFFFFFF, 0x7FFFFFFF, | |
| }; | |
| const uint64_t wuffs_base__low_bits_mask__u64[64] = { | |
| 0x0000000000000000, 0x0000000000000001, 0x0000000000000003, | |
| 0x0000000000000007, 0x000000000000000F, 0x000000000000001F, | |
| 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF, | |
| 0x00000000000001FF, 0x00000000000003FF, 0x00000000000007FF, | |
| 0x0000000000000FFF, 0x0000000000001FFF, 0x0000000000003FFF, | |
| 0x0000000000007FFF, 0x000000000000FFFF, 0x000000000001FFFF, | |
| 0x000000000003FFFF, 0x000000000007FFFF, 0x00000000000FFFFF, | |
| 0x00000000001FFFFF, 0x00000000003FFFFF, 0x00000000007FFFFF, | |
| 0x0000000000FFFFFF, 0x0000000001FFFFFF, 0x0000000003FFFFFF, | |
| 0x0000000007FFFFFF, 0x000000000FFFFFFF, 0x000000001FFFFFFF, | |
| 0x000000003FFFFFFF, 0x000000007FFFFFFF, 0x00000000FFFFFFFF, | |
| 0x00000001FFFFFFFF, 0x00000003FFFFFFFF, 0x00000007FFFFFFFF, | |
| 0x0000000FFFFFFFFF, 0x0000001FFFFFFFFF, 0x0000003FFFFFFFFF, | |
| 0x0000007FFFFFFFFF, 0x000000FFFFFFFFFF, 0x000001FFFFFFFFFF, | |
| 0x000003FFFFFFFFFF, 0x000007FFFFFFFFFF, 0x00000FFFFFFFFFFF, | |
| 0x00001FFFFFFFFFFF, 0x00003FFFFFFFFFFF, 0x00007FFFFFFFFFFF, | |
| 0x0000FFFFFFFFFFFF, 0x0001FFFFFFFFFFFF, 0x0003FFFFFFFFFFFF, | |
| 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF, 0x001FFFFFFFFFFFFF, | |
| 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF, | |
| 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF, | |
| 0x0FFFFFFFFFFFFFFF, 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF, | |
| 0x7FFFFFFFFFFFFFFF, | |
| }; | |
| const uint32_t wuffs_base__pixel_format__bits_per_channel[16] = { | |
| 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, | |
| 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40, | |
| }; | |
| const char wuffs_base__note__i_o_redirect[] = "@base: I/O redirect"; | |
| const char wuffs_base__note__end_of_data[] = "@base: end of data"; | |
| const char wuffs_base__note__metadata_reported[] = "@base: metadata reported"; | |
| const char wuffs_base__suspension__even_more_information[] = "$base: even more information"; | |
| const char wuffs_base__suspension__mispositioned_read[] = "$base: mispositioned read"; | |
| const char wuffs_base__suspension__mispositioned_write[] = "$base: mispositioned write"; | |
| const char wuffs_base__suspension__short_read[] = "$base: short read"; | |
| const char wuffs_base__suspension__short_write[] = "$base: short write"; | |
| const char wuffs_base__error__bad_i_o_position[] = "#base: bad I/O position"; | |
| const char wuffs_base__error__bad_argument_length_too_short[] = "#base: bad argument (length too short)"; | |
| const char wuffs_base__error__bad_argument[] = "#base: bad argument"; | |
| const char wuffs_base__error__bad_call_sequence[] = "#base: bad call sequence"; | |
| const char wuffs_base__error__bad_data[] = "#base: bad data"; | |
| const char wuffs_base__error__bad_receiver[] = "#base: bad receiver"; | |
| const char wuffs_base__error__bad_restart[] = "#base: bad restart"; | |
| const char wuffs_base__error__bad_sizeof_receiver[] = "#base: bad sizeof receiver"; | |
| const char wuffs_base__error__bad_vtable[] = "#base: bad vtable"; | |
| const char wuffs_base__error__bad_workbuf_length[] = "#base: bad workbuf length"; | |
| const char wuffs_base__error__bad_wuffs_version[] = "#base: bad wuffs version"; | |
| const char wuffs_base__error__cannot_return_a_suspension[] = "#base: cannot return a suspension"; | |
| const char wuffs_base__error__disabled_by_previous_error[] = "#base: disabled by previous error"; | |
| const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[] = "#base: initialize falsely claimed already zeroed"; | |
| const char wuffs_base__error__initialize_not_called[] = "#base: initialize not called"; | |
| const char wuffs_base__error__interleaved_coroutine_calls[] = "#base: interleaved coroutine calls"; | |
| const char wuffs_base__error__no_more_information[] = "#base: no more information"; | |
| const char wuffs_base__error__not_enough_data[] = "#base: not enough data"; | |
| const char wuffs_base__error__out_of_bounds[] = "#base: out of bounds"; | |
| const char wuffs_base__error__unsupported_method[] = "#base: unsupported method"; | |
| const char wuffs_base__error__unsupported_option[] = "#base: unsupported option"; | |
| const char wuffs_base__error__unsupported_pixel_swizzler_option[] = "#base: unsupported pixel swizzler option"; | |
| const char wuffs_base__error__too_much_data[] = "#base: too much data"; | |
| const char wuffs_base__hasher_u32__vtable_name[] = "{vtable}wuffs_base__hasher_u32"; | |
| const char wuffs_base__image_decoder__vtable_name[] = "{vtable}wuffs_base__image_decoder"; | |
| const char wuffs_base__io_transformer__vtable_name[] = "{vtable}wuffs_base__io_transformer"; | |
| const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token_decoder"; | |
| #endif // !defined(WUFFS_CONFIG__MODULES) || | |
| // defined(WUFFS_CONFIG__MODULE__BASE) || | |
| // defined(WUFFS_CONFIG__MODULE__BASE__CORE) | |
| #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \ | |
| defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES) | |
| // ---------------- Interface Definitions. | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__hasher_u32__set_quirk_enabled( | |
| wuffs_base__hasher_u32* self, | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| if (!self) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__hasher_u32__vtable_name) { | |
| const wuffs_base__hasher_u32__func_ptrs* func_ptrs = | |
| (const wuffs_base__hasher_u32__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->set_quirk_enabled)(self, a_quirk, a_enabled); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_base__hasher_u32__update_u32( | |
| wuffs_base__hasher_u32* self, | |
| wuffs_base__slice_u8 a_x) { | |
| if (!self) { | |
| return 0; | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return 0; | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__hasher_u32__vtable_name) { | |
| const wuffs_base__hasher_u32__func_ptrs* func_ptrs = | |
| (const wuffs_base__hasher_u32__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->update_u32)(self, a_x); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return 0; | |
| } | |
| // -------- | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_frame( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__pixel_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__pixel_blend a_blend, | |
| wuffs_base__slice_u8 a_workbuf, | |
| wuffs_base__decode_frame_options* a_opts) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->decode_frame)(self, a_dst, a_src, a_blend, a_workbuf, a_opts); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_frame_config( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__frame_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->decode_frame_config)(self, a_dst, a_src); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__decode_image_config( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__image_config* a_dst, | |
| wuffs_base__io_buffer* a_src) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->decode_image_config)(self, a_dst, a_src); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 | |
| wuffs_base__image_decoder__frame_dirty_rect( | |
| const wuffs_base__image_decoder* self) { | |
| if (!self) { | |
| return wuffs_base__utility__empty_rect_ie_u32(); | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return wuffs_base__utility__empty_rect_ie_u32(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->frame_dirty_rect)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__utility__empty_rect_ie_u32(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC uint32_t | |
| wuffs_base__image_decoder__num_animation_loops( | |
| const wuffs_base__image_decoder* self) { | |
| if (!self) { | |
| return 0; | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return 0; | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->num_animation_loops)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return 0; | |
| } | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_base__image_decoder__num_decoded_frame_configs( | |
| const wuffs_base__image_decoder* self) { | |
| if (!self) { | |
| return 0; | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return 0; | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->num_decoded_frame_configs)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return 0; | |
| } | |
| WUFFS_BASE__MAYBE_STATIC uint64_t | |
| wuffs_base__image_decoder__num_decoded_frames( | |
| const wuffs_base__image_decoder* self) { | |
| if (!self) { | |
| return 0; | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return 0; | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->num_decoded_frames)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return 0; | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__restart_frame( | |
| wuffs_base__image_decoder* self, | |
| uint64_t a_index, | |
| uint64_t a_io_position) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->restart_frame)(self, a_index, a_io_position); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__image_decoder__set_quirk_enabled( | |
| wuffs_base__image_decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| if (!self) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->set_quirk_enabled)(self, a_quirk, a_enabled); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__image_decoder__set_report_metadata( | |
| wuffs_base__image_decoder* self, | |
| uint32_t a_fourcc, | |
| bool a_report) { | |
| if (!self) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->set_report_metadata)(self, a_fourcc, a_report); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__image_decoder__tell_me_more( | |
| wuffs_base__image_decoder* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__more_information* a_minfo, | |
| wuffs_base__io_buffer* a_src) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->tell_me_more)(self, a_dst, a_minfo, a_src); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__image_decoder__workbuf_len( | |
| const wuffs_base__image_decoder* self) { | |
| if (!self) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__image_decoder__vtable_name) { | |
| const wuffs_base__image_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__image_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->workbuf_len)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| // -------- | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__io_transformer__set_quirk_enabled( | |
| wuffs_base__io_transformer* self, | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| if (!self) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__io_transformer__vtable_name) { | |
| const wuffs_base__io_transformer__func_ptrs* func_ptrs = | |
| (const wuffs_base__io_transformer__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->set_quirk_enabled)(self, a_quirk, a_enabled); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__io_transformer__transform_io( | |
| wuffs_base__io_transformer* self, | |
| wuffs_base__io_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__io_transformer__vtable_name) { | |
| const wuffs_base__io_transformer__func_ptrs* func_ptrs = | |
| (const wuffs_base__io_transformer__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->transform_io)(self, a_dst, a_src, a_workbuf); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__io_transformer__workbuf_len( | |
| const wuffs_base__io_transformer* self) { | |
| if (!self) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__io_transformer__vtable_name) { | |
| const wuffs_base__io_transformer__func_ptrs* func_ptrs = | |
| (const wuffs_base__io_transformer__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->workbuf_len)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| // -------- | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__status | |
| wuffs_base__token_decoder__decode_tokens( | |
| wuffs_base__token_decoder* self, | |
| wuffs_base__token_buffer* a_dst, | |
| wuffs_base__io_buffer* a_src, | |
| wuffs_base__slice_u8 a_workbuf) { | |
| if (!self) { | |
| return wuffs_base__make_status(wuffs_base__error__bad_receiver); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_status( | |
| (self->private_impl.magic == WUFFS_BASE__DISABLED) | |
| ? wuffs_base__error__disabled_by_previous_error | |
| : wuffs_base__error__initialize_not_called); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { | |
| const wuffs_base__token_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->decode_tokens)(self, a_dst, a_src, a_workbuf); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_status(wuffs_base__error__bad_vtable); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct | |
| wuffs_base__token_decoder__set_quirk_enabled( | |
| wuffs_base__token_decoder* self, | |
| uint32_t a_quirk, | |
| bool a_enabled) { | |
| if (!self) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| if (self->private_impl.magic != WUFFS_BASE__MAGIC) { | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { | |
| const wuffs_base__token_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->set_quirk_enabled)(self, a_quirk, a_enabled); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__make_empty_struct(); | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 | |
| wuffs_base__token_decoder__workbuf_len( | |
| const wuffs_base__token_decoder* self) { | |
| if (!self) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && | |
| (self->private_impl.magic != WUFFS_BASE__DISABLED)) { | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| const wuffs_base__vtable* v = &self->private_impl.first_vtable; | |
| int i; | |
| for (i = 0; i < 63; i++) { | |
| if (v->vtable_name == wuffs_base__token_decoder__vtable_name) { | |
| const wuffs_base__token_decoder__func_ptrs* func_ptrs = | |
| (const wuffs_base__token_decoder__func_ptrs*)(v->function_pointers); | |
| return (*func_ptrs->workbuf_len)(self); | |
| } else if (v->vtable_name == NULL) { | |
| break; | |
| } | |
| v++; | |
| } | |
| return wuffs_base__utility__empty_range_ii_u64(); | |
| } | |
| #endif // !defined(WUFFS_CONFIG__MODULES) || | |
| // defined(WUFFS_CONFIG__MODULE__BASE) || | |
| // defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES) | |
| #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \ | |
| defined(WUFFS_CONFIG__MODULE__BASE__FLOATCONV) | |
| // ---------------- IEEE 754 Floating Point | |
| // The etc__hpd_left_shift and etc__powers_of_5 tables were printed by | |
| // script/print-hpd-left-shift.go. That script has an optional -comments flag, | |
| // whose output is not copied here, which prints further detail. | |
| // | |
| // These tables are used in | |
| // wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits. | |
| // wuffs_base__private_implementation__hpd_left_shift[i] encodes the number of | |
| // new digits created after multiplying a positive integer by (1 << i): the | |
| // additional length in the decimal representation. For example, shifting "234" | |
| // by 3 (equivalent to multiplying by 8) will produce "1872". Going from a | |
| // 3-length string to a 4-length string means that 1 new digit was added (and | |
| // existing digits may have changed). | |
| // | |
| // Shifting by i can add either N or N-1 new digits, depending on whether the | |
| // original positive integer compares >= or < to the i'th power of 5 (as 10 | |
| // equals 2 * 5). Comparison is lexicographic, not numerical. | |
| // | |
| // For example, shifting by 4 (i.e. multiplying by 16) can add 1 or 2 new | |
| // digits, depending on a lexicographic comparison to (5 ** 4), i.e. "625": | |
| // - ("1" << 4) is "16", which adds 1 new digit. | |
| // - ("5678" << 4) is "90848", which adds 1 new digit. | |
| // - ("624" << 4) is "9984", which adds 1 new digit. | |
| // - ("62498" << 4) is "999968", which adds 1 new digit. | |
| // - ("625" << 4) is "10000", which adds 2 new digits. | |
| // - ("625001" << 4) is "10000016", which adds 2 new digits. | |
| // - ("7008" << 4) is "112128", which adds 2 new digits. | |
| // - ("99" << 4) is "1584", which adds 2 new digits. | |
| // | |
| // Thus, when i is 4, N is 2 and (5 ** i) is "625". This etc__hpd_left_shift | |
| // array encodes this as: | |
| // - etc__hpd_left_shift[4] is 0x1006 = (2 << 11) | 0x0006. | |
| // - etc__hpd_left_shift[5] is 0x1009 = (? << 11) | 0x0009. | |
| // where the ? isn't relevant for i == 4. | |
| // | |
| // The high 5 bits of etc__hpd_left_shift[i] is N, the higher of the two | |
| // possible number of new digits. The low 11 bits are an offset into the | |
| // etc__powers_of_5 array (of length 0x051C, so offsets fit in 11 bits). When i | |
| // is 4, its offset and the next one is 6 and 9, and etc__powers_of_5[6 .. 9] | |
| // is the string "\x06\x02\x05", so the relevant power of 5 is "625". | |
| // | |
| // Thanks to Ken Thompson for the original idea. | |
| static const uint16_t wuffs_base__private_implementation__hpd_left_shift[65] = { | |
| 0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817, | |
| 0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067, | |
| 0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF, | |
| 0x4902, 0x4915, 0x4929, 0x513E, 0x5153, 0x5169, 0x5180, 0x5998, 0x59B0, | |
| 0x59C9, 0x61E3, 0x61FD, 0x6218, 0x6A34, 0x6A50, 0x6A6D, 0x6A8B, 0x72AA, | |
| 0x72C9, 0x72E9, 0x7B0A, 0x7B2B, 0x7B4D, 0x8370, 0x8393, 0x83B7, 0x83DC, | |
| 0x8C02, 0x8C28, 0x8C4F, 0x9477, 0x949F, 0x94C8, 0x9CF2, 0x051C, 0x051C, | |
| 0x051C, 0x051C, | |
| }; | |
| // wuffs_base__private_implementation__powers_of_5 contains the powers of 5, | |
| // concatenated together: "5", "25", "125", "625", "3125", etc. | |
| static const uint8_t wuffs_base__private_implementation__powers_of_5[0x051C] = { | |
| 5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3, 9, | |
| 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8, 1, 2, | |
| 5, 2, 4, 4, 1, 4, 0, 6, 2, 5, 1, 2, 2, 0, 7, 0, 3, 1, 2, 5, 6, 1, 0, 3, 5, | |
| 1, 5, 6, 2, 5, 3, 0, 5, 1, 7, 5, 7, 8, 1, 2, 5, 1, 5, 2, 5, 8, 7, 8, 9, 0, | |
| 6, 2, 5, 7, 6, 2, 9, 3, 9, 4, 5, 3, 1, 2, 5, 3, 8, 1, 4, 6, 9, 7, 2, 6, 5, | |
| 6, 2, 5, 1, 9, 0, 7, 3, 4, 8, 6, 3, 2, 8, 1, 2, 5, 9, 5, 3, 6, 7, 4, 3, 1, | |
| 6, 4, 0, 6, 2, 5, 4, 7, 6, 8, 3, 7, 1, 5, 8, 2, 0, 3, 1, 2, 5, 2, 3, 8, 4, | |
| 1, 8, 5, 7, 9, 1, 0, 1, 5, 6, 2, 5, 1, 1, 9, 2, 0, 9, 2, 8, 9, 5, 5, 0, 7, | |
| 8, 1, 2, 5, 5, 9, 6, 0, 4, 6, 4, 4, 7, 7, 5, 3, 9, 0, 6, 2, 5, 2, 9, 8, 0, | |
| 2, 3, 2, 2, 3, 8, 7, 6, 9, 5, 3, 1, 2, 5, 1, 4, 9, 0, 1, 1, 6, 1, 1, 9, 3, | |
| 8, 4, 7, 6, 5, 6, 2, 5, 7, 4, 5, 0, 5, 8, 0, 5, 9, 6, 9, 2, 3, 8, 2, 8, 1, | |
| 2, 5, 3, 7, 2, 5, 2, 9, 0, 2, 9, 8, 4, 6, 1, 9, 1, 4, 0, 6, 2, 5, 1, 8, 6, | |
| 2, 6, 4, 5, 1, 4, 9, 2, 3, 0, 9, 5, 7, 0, 3, 1, 2, 5, 9, 3, 1, 3, 2, 2, 5, | |
| 7, 4, 6, 1, 5, 4, 7, 8, 5, 1, 5, 6, 2, 5, 4, 6, 5, 6, 6, 1, 2, 8, 7, 3, 0, | |
| 7, 7, 3, 9, 2, 5, 7, 8, 1, 2, 5, 2, 3, 2, 8, 3, 0, 6, 4, 3, 6, 5, 3, 8, 6, | |
| 9, 6, 2, 8, 9, 0, 6, 2, 5, 1, 1, 6, 4, 1, 5, 3, 2, 1, 8, 2, 6, 9, 3, 4, 8, | |
| 1, 4, 4, 5, 3, 1, 2, 5, 5, 8, 2, 0, 7, 6, 6, 0, 9, 1, 3, 4, 6, 7, 4, 0, 7, | |
| 2, 2, 6, 5, 6, 2, 5, 2, 9, 1, 0, 3, 8, 3, 0, 4, 5, 6, 7, 3, 3, 7, 0, 3, 6, | |
| 1, 3, 2, 8, 1, 2, 5, 1, 4, 5, 5, 1, 9, 1, 5, 2, 2, 8, 3, 6, 6, 8, 5, 1, 8, | |
| 0, 6, 6, 4, 0, 6, 2, 5, 7, 2, 7, 5, 9, 5, 7, 6, 1, 4, 1, 8, 3, 4, 2, 5, 9, | |
| 0, 3, 3, 2, 0, 3, 1, 2, 5, 3, 6, 3, 7, 9, 7, 8, 8, 0, 7, 0, 9, 1, 7, 1, 2, | |
| 9, 5, 1, 6, 6, 0, 1, 5, 6, 2, 5, 1, 8, 1, 8, 9, 8, 9, 4, 0, 3, 5, 4, 5, 8, | |
| 5, 6, 4, 7, 5, 8, 3, 0, 0, 7, 8, 1, 2, 5, 9, 0, 9, 4, 9, 4, 7, 0, 1, 7, 7, | |
| 2, 9, 2, 8, 2, 3, 7, 9, 1, 5, 0, 3, 9, 0, 6, 2, 5, 4, 5, 4, 7, 4, 7, 3, 5, | |
| 0, 8, 8, 6, 4, 6, 4, 1, 1, 8, 9, 5, 7, 5, 1, 9, 5, 3, 1, 2, 5, 2, 2, 7, 3, | |
| 7, 3, 6, 7, 5, 4, 4, 3, 2, 3, 2, 0, 5, 9, 4, 7, 8, 7, 5, 9, 7, 6, 5, 6, 2, | |
| 5, 1, 1, 3, 6, 8, 6, 8, 3, 7, 7, 2, 1, 6, 1, 6, 0, 2, 9, 7, 3, 9, 3, 7, 9, | |
| 8, 8, 2, 8, 1, 2, 5, 5, 6, 8, 4, 3, 4, 1, 8, 8, 6, 0, 8, 0, 8, 0, 1, 4, 8, | |
| 6, 9, 6, 8, 9, 9, 4, 1, 4, 0, 6, 2, 5, 2, 8, 4, 2, 1, 7, 0, 9, 4, 3, 0, 4, | |
| 0, 4, 0, 0, 7, 4, 3, 4, 8, 4, 4, 9, 7, 0, 7, 0, 3, 1, 2, 5, 1, 4, 2, 1, 0, | |
| 8, 5, 4, 7, 1, 5, 2, 0, 2, 0, 0, 3, 7, 1, 7, 4, 2, 2, 4, 8, 5, 3, 5, 1, 5, | |
| 6, 2, 5, 7, 1, 0, 5, 4, 2, 7, 3, 5, 7, 6, 0, 1, 0, 0, 1, 8, 5, 8, 7, 1, 1, | |
| 2, 4, 2, 6, 7, 5, 7, 8, 1, 2, 5, 3, 5, 5, 2, 7, 1, 3, 6, 7, 8, 8, 0, 0, 5, | |
| 0, 0, 9, 2, 9, 3, 5, 5, 6, 2, 1, 3, 3, 7, 8, 9, 0, 6, 2, 5, 1, 7, 7, 6, 3, | |
| 5, 6, 8, 3, 9, 4, 0, 0, 2, 5, 0, 4, 6, 4, 6, 7, 7, 8, 1, 0, 6, 6, 8, 9, 4, | |
| 5, 3, 1, 2, 5, 8, 8, 8, 1, 7, 8, 4, 1, 9, 7, 0, 0, 1, 2, 5, 2, 3, 2, 3, 3, | |
| 8, 9, 0, 5, 3, 3, 4, 4, 7, 2, 6, 5, 6, 2, 5, 4, 4, 4, 0, 8, 9, 2, 0, 9, 8, | |
| 5, 0, 0, 6, 2, 6, 1, 6, 1, 6, 9, 4, 5, 2, 6, 6, 7, 2, 3, 6, 3, 2, 8, 1, 2, | |
| 5, 2, 2, 2, 0, 4, 4, 6, 0, 4, 9, 2, 5, 0, 3, 1, 3, 0, 8, 0, 8, 4, 7, 2, 6, | |
| 3, 3, 3, 6, 1, 8, 1, 6, 4, 0, 6, 2, 5, 1, 1, 1, 0, 2, 2, 3, 0, 2, 4, 6, 2, | |
| 5, 1, 5, 6, 5, 4, 0, 4, 2, 3, 6, 3, 1, 6, 6, 8, 0, 9, 0, 8, 2, 0, 3, 1, 2, | |
| 5, 5, 5, 5, 1, 1, 1, 5, 1, 2, 3, 1, 2, 5, 7, 8, 2, 7, 0, 2, 1, 1, 8, 1, 5, | |
| 8, 3, 4, 0, 4, 5, 4, 1, 0, 1, 5, 6, 2, 5, 2, 7, 7, 5, 5, 5, 7, 5, 6, 1, 5, | |
| 6, 2, 8, 9, 1, 3, 5, 1, 0, 5, 9, 0, 7, 9, 1, 7, 0, 2, 2, 7, 0, 5, 0, 7, 8, | |
| 1, 2, 5, 1, 3, 8, 7, 7, 7, 8, 7, 8, 0, 7, 8, 1, 4, 4, 5, 6, 7, 5, 5, 2, 9, | |
| 5, 3, 9, 5, 8, 5, 1, 1, 3, 5, 2, 5, 3, 9, 0, 6, 2, 5, 6, 9, 3, 8, 8, 9, 3, | |
| 9, 0, 3, 9, 0, 7, 2, 2, 8, 3, 7, 7, 6, 4, 7, 6, 9, 7, 9, 2, 5, 5, 6, 7, 6, | |
| 2, 6, 9, 5, 3, 1, 2, 5, 3, 4, 6, 9, 4, 4, 6, 9, 5, 1, 9, 5, 3, 6, 1, 4, 1, | |
| 8, 8, 8, 2, 3, 8, 4, 8, 9, 6, 2, 7, 8, 3, 8, 1, 3, 4, 7, 6, 5, 6, 2, 5, 1, | |
| 7, 3, 4, 7, 2, 3, 4, 7, 5, 9, 7, 6, 8, 0, 7, 0, 9, 4, 4, 1, 1, 9, 2, 4, 4, | |
| 8, 1, 3, 9, 1, 9, 0, 6, 7, 3, 8, 2, 8, 1, 2, 5, 8, 6, 7, 3, 6, 1, 7, 3, 7, | |
| 9, 8, 8, 4, 0, 3, 5, 4, 7, 2, 0, 5, 9, 6, 2, 2, 4, 0, 6, 9, 5, 9, 5, 3, 3, | |
| 6, 9, 1, 4, 0, 6, 2, 5, | |
| }; | |
| // -------- | |
| // wuffs_base__private_implementation__powers_of_10 contains truncated | |
| // approximations to the powers of 10, ranging from 1e-307 to 1e+288 inclusive, | |
| // as 596 pairs of uint64_t values (a 128-bit mantissa). | |
| // | |
| // There's also an implicit third column (implied by a linear formula involving | |
| // the base-10 exponent) that is the base-2 exponent, biased by a magic | |
| // constant. That constant (1214 or 0x04BE) equals 1023 + 191. 1023 is the bias | |
| // for IEEE 754 double-precision floating point. 191 is ((3 * 64) - 1) and | |
| // wuffs_base__private_implementation__parse_number_f64_eisel_lemire works with | |
| // multiples-of-64-bit mantissas. | |
| // | |
| // For example, the third row holds the approximation to 1e-305: | |
| // 0xE0B62E29_29ABA83C_331ACDAB_FE94DE87 * (2 ** (0x0049 - 0x04BE)) | |
| // | |
| // Similarly, 1e+4 is approximated by: | |
| // 0x9C400000_00000000_00000000_00000000 * (2 ** (0x044C - 0x04BE)) | |
| // | |
| // Similarly, 1e+68 is approximated by: | |
| // 0xED63A231_D4C4FB27_4CA7AAA8_63EE4BDD * (2 ** (0x0520 - 0x04BE)) | |
| // | |
| // This table was generated by by script/print-mpb-powers-of-10.go | |
| static const uint64_t wuffs_base__private_implementation__powers_of_10[596][2] = | |
| { | |
| {0xA5D3B6D479F8E056, 0x8FD0C16206306BAB}, // 1e-307 | |
| {0x8F48A4899877186C, 0xB3C4F1BA87BC8696}, // 1e-306 | |
| {0x331ACDABFE94DE87, 0xE0B62E2929ABA83C}, // 1e-305 | |
| {0x9FF0C08B7F1D0B14, 0x8C71DCD9BA0B4925}, // 1e-304 | |
| {0x07ECF0AE5EE44DD9, 0xAF8E5410288E1B6F}, // 1e-303 | |
| {0xC9E82CD9F69D6150, 0xDB71E91432B1A24A}, // 1e-302 | |
| {0xBE311C083A225CD2, 0x892731AC9FAF056E}, // 1e-301 | |
| {0x6DBD630A48AAF406, 0xAB70FE17C79AC6CA}, // 1e-300 | |
| {0x092CBBCCDAD5B108, 0xD64D3D9DB981787D}, // 1e-299 | |
| {0x25BBF56008C58EA5, 0x85F0468293F0EB4E}, // 1e-298 | |
| {0xAF2AF2B80AF6F24E, 0xA76C582338ED2621}, // 1e-297 | |
| {0x1AF5AF660DB4AEE1, 0xD1476E2C07286FAA}, // 1e-296 | |
| {0x50D98D9FC890ED4D, 0x82CCA4DB847945CA}, // 1e-295 | |
| {0xE50FF107BAB528A0, 0xA37FCE126597973C}, // 1e-294 | |
| {0x1E53ED49A96272C8, 0xCC5FC196FEFD7D0C}, // 1e-293 | |
| {0x25E8E89C13BB0F7A, 0xFF77B1FCBEBCDC4F}, // 1e-292 | |
| {0x77B191618C54E9AC, 0x9FAACF3DF73609B1}, // 1e-291 | |
| {0xD59DF5B9EF6A2417, 0xC795830D75038C1D}, // 1e-290 | |
| {0x4B0573286B44AD1D, 0xF97AE3D0D2446F25}, // 1e-289 | |
| {0x4EE367F9430AEC32, 0x9BECCE62836AC577}, // 1e-288 | |
| {0x229C41F793CDA73F, 0xC2E801FB244576D5}, // 1e-287 | |
| {0x6B43527578C1110F, 0xF3A20279ED56D48A}, // 1e-286 | |
| {0x830A13896B78AAA9, 0x9845418C345644D6}, // 1e-285 | |
| {0x23CC986BC656D553, 0xBE5691EF416BD60C}, // 1e-284 | |
| {0x2CBFBE86B7EC8AA8, 0xEDEC366B11C6CB8F}, // 1e-283 | |
| {0x7BF7D71432F3D6A9, 0x94B3A202EB1C3F39}, // 1e-282 | |
| {0xDAF5CCD93FB0CC53, 0xB9E08A83A5E34F07}, // 1e-281 | |
| {0xD1B3400F8F9CFF68, 0xE858AD248F5C22C9}, // 1e-280 | |
| {0x23100809B9C21FA1, 0x91376C36D99995BE}, // 1e-279 | |
| {0xABD40A0C2832A78A, 0xB58547448FFFFB2D}, // 1e-278 | |
| {0x16C90C8F323F516C, 0xE2E69915B3FFF9F9}, // 1e-277 | |
| {0xAE3DA7D97F6792E3, 0x8DD01FAD907FFC3B}, // 1e-276 | |
| {0x99CD11CFDF41779C, 0xB1442798F49FFB4A}, // 1e-275 | |
| {0x40405643D711D583, 0xDD95317F31C7FA1D}, // 1e-274 | |
| {0x482835EA666B2572, 0x8A7D3EEF7F1CFC52}, // 1e-273 | |
| {0xDA3243650005EECF, 0xAD1C8EAB5EE43B66}, // 1e-272 | |
| {0x90BED43E40076A82, 0xD863B256369D4A40}, // 1e-271 | |
| {0x5A7744A6E804A291, 0x873E4F75E2224E68}, // 1e-270 | |
| {0x711515D0A205CB36, 0xA90DE3535AAAE202}, // 1e-269 | |
| {0x0D5A5B44CA873E03, 0xD3515C2831559A83}, // 1e-268 | |
| {0xE858790AFE9486C2, 0x8412D9991ED58091}, // 1e-267 | |
| {0x626E974DBE39A872, 0xA5178FFF668AE0B6}, // 1e-266 | |
| {0xFB0A3D212DC8128F, 0xCE5D73FF402D98E3}, // 1e-265 | |
| {0x7CE66634BC9D0B99, 0x80FA687F881C7F8E}, // 1e-264 | |
| {0x1C1FFFC1EBC44E80, 0xA139029F6A239F72}, // 1e-263 | |
| {0xA327FFB266B56220, 0xC987434744AC874E}, // 1e-262 | |
| {0x4BF1FF9F0062BAA8, 0xFBE9141915D7A922}, // 1e-261 | |
| {0x6F773FC3603DB4A9, 0x9D71AC8FADA6C9B5}, // 1e-260 | |
| {0xCB550FB4384D21D3, 0xC4CE17B399107C22}, // 1e-259 | |
| {0x7E2A53A146606A48, 0xF6019DA07F549B2B}, // 1e-258 | |
| {0x2EDA7444CBFC426D, 0x99C102844F94E0FB}, // 1e-257 | |
| {0xFA911155FEFB5308, 0xC0314325637A1939}, // 1e-256 | |
| {0x793555AB7EBA27CA, 0xF03D93EEBC589F88}, // 1e-255 | |
| {0x4BC1558B2F3458DE, 0x96267C7535B763B5}, // 1e-254 | |
| {0x9EB1AAEDFB016F16, 0xBBB01B9283253CA2}, // 1e-253 | |
| {0x465E15A979C1CADC, 0xEA9C227723EE8BCB}, // 1e-252 | |
| {0x0BFACD89EC191EC9, 0x92A1958A7675175F}, // 1e-251 | |
| {0xCEF980EC671F667B, 0xB749FAED14125D36}, // 1e-250 | |
| {0x82B7E12780E7401A, 0xE51C79A85916F484}, // 1e-249 | |
| {0xD1B2ECB8B0908810, 0x8F31CC0937AE58D2}, // 1e-248 | |
| {0x861FA7E6DCB4AA15, 0xB2FE3F0B8599EF07}, // 1e-247 | |
| {0x67A791E093E1D49A, 0xDFBDCECE67006AC9}, // 1e-246 | |
| {0xE0C8BB2C5C6D24E0, 0x8BD6A141006042BD}, // 1e-245 | |
| {0x58FAE9F773886E18, 0xAECC49914078536D}, // 1e-244 | |
| {0xAF39A475506A899E, 0xDA7F5BF590966848}, // 1e-243 | |
| {0x6D8406C952429603, 0x888F99797A5E012D}, // 1e-242 | |
| {0xC8E5087BA6D33B83, 0xAAB37FD7D8F58178}, // 1e-241 | |
| {0xFB1E4A9A90880A64, 0xD5605FCDCF32E1D6}, // 1e-240 | |
| {0x5CF2EEA09A55067F, 0x855C3BE0A17FCD26}, // 1e-239 | |
| {0xF42FAA48C0EA481E, 0xA6B34AD8C9DFC06F}, // 1e-238 | |
| {0xF13B94DAF124DA26, 0xD0601D8EFC57B08B}, // 1e-237 | |
| {0x76C53D08D6B70858, 0x823C12795DB6CE57}, // 1e-236 | |
| {0x54768C4B0C64CA6E, 0xA2CB1717B52481ED}, // 1e-235 | |
| {0xA9942F5DCF7DFD09, 0xCB7DDCDDA26DA268}, // 1e-234 | |
| {0xD3F93B35435D7C4C, 0xFE5D54150B090B02}, // 1e-233 | |
| {0xC47BC5014A1A6DAF, 0x9EFA548D26E5A6E1}, // 1e-232 | |
| {0x359AB6419CA1091B, 0xC6B8E9B0709F109A}, // 1e-231 | |
| {0xC30163D203C94B62, 0xF867241C8CC6D4C0}, // 1e-230 | |
| {0x79E0DE63425DCF1D, 0x9B407691D7FC44F8}, // 1e-229 | |
| {0x985915FC12F542E4, 0xC21094364DFB5636}, // 1e-228 | |
| {0x3E6F5B7B17B2939D, 0xF294B943E17A2BC4}, // 1e-227 | |
| {0xA705992CEECF9C42, 0x979CF3CA6CEC5B5A}, // 1e-226 | |
| {0x50C6FF782A838353, 0xBD8430BD08277231}, // 1e-225 | |
| {0xA4F8BF5635246428, 0xECE53CEC4A314EBD}, // 1e-224 | |
| {0x871B7795E136BE99, 0x940F4613AE5ED136}, // 1e-223 | |
| {0x28E2557B59846E3F, 0xB913179899F68584}, // 1e-222 | |
| {0x331AEADA2FE589CF, 0xE757DD7EC07426E5}, // 1e-221 | |
| {0x3FF0D2C85DEF7621, 0x9096EA6F3848984F}, // 1e-220 | |
| {0x0FED077A756B53A9, 0xB4BCA50B065ABE63}, // 1e-219 | |
| {0xD3E8495912C62894, 0xE1EBCE4DC7F16DFB}, // 1e-218 | |
| {0x64712DD7ABBBD95C, 0x8D3360F09CF6E4BD}, // 1e-217 | |
| {0xBD8D794D96AACFB3, 0xB080392CC4349DEC}, // 1e-216 | |
| {0xECF0D7A0FC5583A0, 0xDCA04777F541C567}, // 1e-215 | |
| {0xF41686C49DB57244, 0x89E42CAAF9491B60}, // 1e-214 | |
| {0x311C2875C522CED5, 0xAC5D37D5B79B6239}, // 1e-213 | |
| {0x7D633293366B828B, 0xD77485CB25823AC7}, // 1e-212 | |
| {0xAE5DFF9C02033197, 0x86A8D39EF77164BC}, // 1e-211 | |
| {0xD9F57F830283FDFC, 0xA8530886B54DBDEB}, // 1e-210 | |
| {0xD072DF63C324FD7B, 0xD267CAA862A12D66}, // 1e-209 | |
| {0x4247CB9E59F71E6D, 0x8380DEA93DA4BC60}, // 1e-208 | |
| {0x52D9BE85F074E608, 0xA46116538D0DEB78}, // 1e-207 | |
| {0x67902E276C921F8B, 0xCD795BE870516656}, // 1e-206 | |
| {0x00BA1CD8A3DB53B6, 0x806BD9714632DFF6}, // 1e-205 | |
| {0x80E8A40ECCD228A4, 0xA086CFCD97BF97F3}, // 1e-204 | |
| {0x6122CD128006B2CD, 0xC8A883C0FDAF7DF0}, // 1e-203 | |
| {0x796B805720085F81, 0xFAD2A4B13D1B5D6C}, // 1e-202 | |
| {0xCBE3303674053BB0, 0x9CC3A6EEC6311A63}, // 1e-201 | |
| {0xBEDBFC4411068A9C, 0xC3F490AA77BD60FC}, // 1e-200 | |
| {0xEE92FB5515482D44, 0xF4F1B4D515ACB93B}, // 1e-199 | |
| {0x751BDD152D4D1C4A, 0x991711052D8BF3C5}, // 1e-198 | |
| {0xD262D45A78A0635D, 0xBF5CD54678EEF0B6}, // 1e-197 | |
| {0x86FB897116C87C34, 0xEF340A98172AACE4}, // 1e-196 | |
| {0xD45D35E6AE3D4DA0, 0x9580869F0E7AAC0E}, // 1e-195 | |
| {0x8974836059CCA109, 0xBAE0A846D2195712}, // 1e-194 | |
| {0x2BD1A438703FC94B, 0xE998D258869FACD7}, // 1e-193 | |
| {0x7B6306A34627DDCF, 0x91FF83775423CC06}, // 1e-192 | |
| {0x1A3BC84C17B1D542, 0xB67F6455292CBF08}, // 1e-191 | |
| {0x20CABA5F1D9E4A93, 0xE41F3D6A7377EECA}, // 1e-190 | |
| {0x547EB47B7282EE9C, 0x8E938662882AF53E}, // 1e-189 | |
| {0xE99E619A4F23AA43, 0xB23867FB2A35B28D}, // 1e-188 | |
| {0x6405FA00E2EC94D4, 0xDEC681F9F4C31F31}, // 1e-187 | |
| {0xDE83BC408DD3DD04, 0x8B3C113C38F9F37E}, // 1e-186 | |
| {0x9624AB50B148D445, 0xAE0B158B4738705E}, // 1e-185 | |
| {0x3BADD624DD9B0957, 0xD98DDAEE19068C76}, // 1e-184 | |
| {0xE54CA5D70A80E5D6, 0x87F8A8D4CFA417C9}, // 1e-183 | |
| {0x5E9FCF4CCD211F4C, 0xA9F6D30A038D1DBC}, // 1e-182 | |
| {0x7647C3200069671F, 0xD47487CC8470652B}, // 1e-181 | |
| {0x29ECD9F40041E073, 0x84C8D4DFD2C63F3B}, // 1e-180 | |
| {0xF468107100525890, 0xA5FB0A17C777CF09}, // 1e-179 | |
| {0x7182148D4066EEB4, 0xCF79CC9DB955C2CC}, // 1e-178 | |
| {0xC6F14CD848405530, 0x81AC1FE293D599BF}, // 1e-177 | |
| {0xB8ADA00E5A506A7C, 0xA21727DB38CB002F}, // 1e-176 | |
| {0xA6D90811F0E4851C, 0xCA9CF1D206FDC03B}, // 1e-175 | |
| {0x908F4A166D1DA663, 0xFD442E4688BD304A}, // 1e-174 | |
| {0x9A598E4E043287FE, 0x9E4A9CEC15763E2E}, // 1e-173 | |
| {0x40EFF1E1853F29FD, 0xC5DD44271AD3CDBA}, // 1e-172 | |
| {0xD12BEE59E68EF47C, 0xF7549530E188C128}, // 1e-171 | |
| {0x82BB74F8301958CE, 0x9A94DD3E8CF578B9}, // 1e-170 | |
| {0xE36A52363C1FAF01, 0xC13A148E3032D6E7}, // 1e-169 | |
| {0xDC44E6C3CB279AC1, 0xF18899B1BC3F8CA1}, // 1e-168 | |
| {0x29AB103A5EF8C0B9, 0x96F5600F15A7B7E5}, // 1e-167 | |
| {0x7415D448F6B6F0E7, 0xBCB2B812DB11A5DE}, // 1e-166 | |
| {0x111B495B3464AD21, 0xEBDF661791D60F56}, // 1e-165 | |
| {0xCAB10DD900BEEC34, 0x936B9FCEBB25C995}, // 1e-164 | |
| {0x3D5D514F40EEA742, 0xB84687C269EF3BFB}, // 1e-163 | |
| {0x0CB4A5A3112A5112, 0xE65829B3046B0AFA}, // 1e-162 | |
| {0x47F0E785EABA72AB, 0x8FF71A0FE2C2E6DC}, // 1e-161 | |
| {0x59ED216765690F56, 0xB3F4E093DB73A093}, // 1e-160 | |
| {0x306869C13EC3532C, 0xE0F218B8D25088B8}, // 1e-159 | |
| {0x1E414218C73A13FB, 0x8C974F7383725573}, // 1e-158 | |
| {0xE5D1929EF90898FA, 0xAFBD2350644EEACF}, // 1e-157 | |
| {0xDF45F746B74ABF39, 0xDBAC6C247D62A583}, // 1e-156 | |
| {0x6B8BBA8C328EB783, 0x894BC396CE5DA772}, // 1e-155 | |
| {0x066EA92F3F326564, 0xAB9EB47C81F5114F}, // 1e-154 | |
| {0xC80A537B0EFEFEBD, 0xD686619BA27255A2}, // 1e-153 | |
| {0xBD06742CE95F5F36, 0x8613FD0145877585}, // 1e-152 | |
| {0x2C48113823B73704, 0xA798FC4196E952E7}, // 1e-151 | |
| {0xF75A15862CA504C5, 0xD17F3B51FCA3A7A0}, // 1e-150 | |
| {0x9A984D73DBE722FB, 0x82EF85133DE648C4}, // 1e-149 | |
| {0xC13E60D0D2E0EBBA, 0xA3AB66580D5FDAF5}, // 1e-148 | |
| {0x318DF905079926A8, 0xCC963FEE10B7D1B3}, // 1e-147 | |
| {0xFDF17746497F7052, 0xFFBBCFE994E5C61F}, // 1e-146 | |
| {0xFEB6EA8BEDEFA633, 0x9FD561F1FD0F9BD3}, // 1e-145 | |
| {0xFE64A52EE96B8FC0, 0xC7CABA6E7C5382C8}, // 1e-144 | |
| {0x3DFDCE7AA3C673B0, 0xF9BD690A1B68637B}, // 1e-143 | |
| {0x06BEA10CA65C084E, 0x9C1661A651213E2D}, // 1e-142 | |
| {0x486E494FCFF30A62, 0xC31BFA0FE5698DB8}, // 1e-141 | |
| {0x5A89DBA3C3EFCCFA, 0xF3E2F893DEC3F126}, // 1e-140 | |
| {0xF89629465A75E01C, 0x986DDB5C6B3A76B7}, // 1e-139 | |
| {0xF6BBB397F1135823, 0xBE89523386091465}, // 1e-138 | |
| {0x746AA07DED582E2C, 0xEE2BA6C0678B597F}, // 1e-137 | |
| {0xA8C2A44EB4571CDC, 0x94DB483840B717EF}, // 1e-136 | |
| {0x92F34D62616CE413, 0xBA121A4650E4DDEB}, // 1e-135 | |
| {0x77B020BAF9C81D17, 0xE896A0D7E51E1566}, // 1e-134 | |
| {0x0ACE1474DC1D122E, 0x915E2486EF32CD60}, // 1e-133 | |
| {0x0D819992132456BA, 0xB5B5ADA8AAFF80B8}, // 1e-132 | |
| {0x10E1FFF697ED6C69, 0xE3231912D5BF60E6}, // 1e-131 | |
| {0xCA8D3FFA1EF463C1, 0x8DF5EFABC5979C8F}, // 1e-130 | |
| {0xBD308FF8A6B17CB2, 0xB1736B96B6FD83B3}, // 1e-129 | |
| {0xAC7CB3F6D05DDBDE, 0xDDD0467C64BCE4A0}, // 1e-128 | |
| {0x6BCDF07A423AA96B, 0x8AA22C0DBEF60EE4}, // 1e-127 | |
| {0x86C16C98D2C953C6, 0xAD4AB7112EB3929D}, // 1e-126 | |
| {0xE871C7BF077BA8B7, 0xD89D64D57A607744}, // 1e-125 | |
| {0x11471CD764AD4972, 0x87625F056C7C4A8B}, // 1e-124 | |
| {0xD598E40D3DD89BCF, 0xA93AF6C6C79B5D2D}, // 1e-123 | |
| {0x4AFF1D108D4EC2C3, 0xD389B47879823479}, // 1e-122 | |
| {0xCEDF722A585139BA, 0x843610CB4BF160CB}, // 1e-121 | |
| {0xC2974EB4EE658828, 0xA54394FE1EEDB8FE}, // 1e-120 | |
| {0x733D226229FEEA32, 0xCE947A3DA6A9273E}, // 1e-119 | |
| {0x0806357D5A3F525F, 0x811CCC668829B887}, // 1e-118 | |
| {0xCA07C2DCB0CF26F7, 0xA163FF802A3426A8}, // 1e-117 | |
| {0xFC89B393DD02F0B5, 0xC9BCFF6034C13052}, // 1e-116 | |
| {0xBBAC2078D443ACE2, 0xFC2C3F3841F17C67}, // 1e-115 | |
| {0xD54B944B84AA4C0D, 0x9D9BA7832936EDC0}, // 1e-114 | |
| {0x0A9E795E65D4DF11, 0xC5029163F384A931}, // 1e-113 | |
| {0x4D4617B5FF4A16D5, 0xF64335BCF065D37D}, // 1e-112 | |
| {0x504BCED1BF8E4E45, 0x99EA0196163FA42E}, // 1e-111 | |
| {0xE45EC2862F71E1D6, 0xC06481FB9BCF8D39}, // 1e-110 | |
| {0x5D767327BB4E5A4C, 0xF07DA27A82C37088}, // 1e-109 | |
| {0x3A6A07F8D510F86F, 0x964E858C91BA2655}, // 1e-108 | |
| {0x890489F70A55368B, 0xBBE226EFB628AFEA}, // 1e-107 | |
| {0x2B45AC74CCEA842E, 0xEADAB0ABA3B2DBE5}, // 1e-106 | |
| {0x3B0B8BC90012929D, 0x92C8AE6B464FC96F}, // 1e-105 | |
| {0x09CE6EBB40173744, 0xB77ADA0617E3BBCB}, // 1e-104 | |
| {0xCC420A6A101D0515, 0xE55990879DDCAABD}, // 1e-103 | |
| {0x9FA946824A12232D, 0x8F57FA54C2A9EAB6}, // 1e-102 | |
| {0x47939822DC96ABF9, 0xB32DF8E9F3546564}, // 1e-101 | |
| {0x59787E2B93BC56F7, 0xDFF9772470297EBD}, // 1e-100 | |
| {0x57EB4EDB3C55B65A, 0x8BFBEA76C619EF36}, // 1e-99 | |
| {0xEDE622920B6B23F1, 0xAEFAE51477A06B03}, // 1e-98 | |
| {0xE95FAB368E45ECED, 0xDAB99E59958885C4}, // 1e-97 | |
| {0x11DBCB0218EBB414, 0x88B402F7FD75539B}, // 1e-96 | |
| {0xD652BDC29F26A119, 0xAAE103B5FCD2A881}, // 1e-95 | |
| {0x4BE76D3346F0495F, 0xD59944A37C0752A2}, // 1e-94 | |
| {0x6F70A4400C562DDB, 0x857FCAE62D8493A5}, // 1e-93 | |
| {0xCB4CCD500F6BB952, 0xA6DFBD9FB8E5B88E}, // 1e-92 | |
| {0x7E2000A41346A7A7, 0xD097AD07A71F26B2}, // 1e-91 | |
| {0x8ED400668C0C28C8, 0x825ECC24C873782F}, // 1e-90 | |
| {0x728900802F0F32FA, 0xA2F67F2DFA90563B}, // 1e-89 | |
| {0x4F2B40A03AD2FFB9, 0xCBB41EF979346BCA}, // 1e-88 | |
| {0xE2F610C84987BFA8, 0xFEA126B7D78186BC}, // 1e-87 | |
| {0x0DD9CA7D2DF4D7C9, 0x9F24B832E6B0F436}, // 1e-86 | |
| {0x91503D1C79720DBB, 0xC6EDE63FA05D3143}, // 1e-85 | |
| {0x75A44C6397CE912A, 0xF8A95FCF88747D94}, // 1e-84 | |
| {0xC986AFBE3EE11ABA, 0x9B69DBE1B548CE7C}, // 1e-83 | |
| {0xFBE85BADCE996168, 0xC24452DA229B021B}, // 1e-82 | |
| {0xFAE27299423FB9C3, 0xF2D56790AB41C2A2}, // 1e-81 | |
| {0xDCCD879FC967D41A, 0x97C560BA6B0919A5}, // 1e-80 | |
| {0x5400E987BBC1C920, 0xBDB6B8E905CB600F}, // 1e-79 | |
| {0x290123E9AAB23B68, 0xED246723473E3813}, // 1e-78 | |
| {0xF9A0B6720AAF6521, 0x9436C0760C86E30B}, // 1e-77 | |
| {0xF808E40E8D5B3E69, 0xB94470938FA89BCE}, // 1e-76 | |
| {0xB60B1D1230B20E04, 0xE7958CB87392C2C2}, // 1e-75 | |
| {0xB1C6F22B5E6F48C2, 0x90BD77F3483BB9B9}, // 1e-74 | |
| {0x1E38AEB6360B1AF3, 0xB4ECD5F01A4AA828}, // 1e-73 | |
| {0x25C6DA63C38DE1B0, 0xE2280B6C20DD5232}, // 1e-72 | |
| {0x579C487E5A38AD0E, 0x8D590723948A535F}, // 1e-71 | |
| {0x2D835A9DF0C6D851, 0xB0AF48EC79ACE837}, // 1e-70 | |
| {0xF8E431456CF88E65, 0xDCDB1B2798182244}, // 1e-69 | |
| {0x1B8E9ECB641B58FF, 0x8A08F0F8BF0F156B}, // 1e-68 | |
| {0xE272467E3D222F3F, 0xAC8B2D36EED2DAC5}, // 1e-67 | |
| {0x5B0ED81DCC6ABB0F, 0xD7ADF884AA879177}, // 1e-66 | |
| {0x98E947129FC2B4E9, 0x86CCBB52EA94BAEA}, // 1e-65 | |
| {0x3F2398D747B36224, 0xA87FEA27A539E9A5}, // 1e-64 | |
| {0x8EEC7F0D19A03AAD, 0xD29FE4B18E88640E}, // 1e-63 | |
| {0x1953CF68300424AC, 0x83A3EEEEF9153E89}, // 1e-62 | |
| {0x5FA8C3423C052DD7, 0xA48CEAAAB75A8E2B}, // 1e-61 | |
| {0x3792F412CB06794D, 0xCDB02555653131B6}, // 1e-60 | |
| {0xE2BBD88BBEE40BD0, 0x808E17555F3EBF11}, // 1e-59 | |
| {0x5B6ACEAEAE9D0EC4, 0xA0B19D2AB70E6ED6}, // 1e-58 | |
| {0xF245825A5A445275, 0xC8DE047564D20A8B}, // 1e-57 | |
| {0xEED6E2F0F0D56712, 0xFB158592BE068D2E}, // 1e-56 | |
| {0x55464DD69685606B, 0x9CED737BB6C4183D}, // 1e-55 | |
| {0xAA97E14C3C26B886, 0xC428D05AA4751E4C}, // 1e-54 | |
| {0xD53DD99F4B3066A8, 0xF53304714D9265DF}, // 1e-53 | |
| {0xE546A8038EFE4029, 0x993FE2C6D07B7FAB}, // 1e-52 | |
| {0xDE98520472BDD033, 0xBF8FDB78849A5F96}, // 1e-51 | |
| {0x963E66858F6D4440, 0xEF73D256A5C0F77C}, // 1e-50 | |
| {0xDDE7001379A44AA8, 0x95A8637627989AAD}, // 1e-49 | |
| {0x5560C018580D5D52, 0xBB127C53B17EC159}, // 1e-48 | |
| {0xAAB8F01E6E10B4A6, 0xE9D71B689DDE71AF}, // 1e-47 | |
| {0xCAB3961304CA70E8, 0x9226712162AB070D}, // 1e-46 | |
| {0x3D607B97C5FD0D22, 0xB6B00D69BB55C8D1}, // 1e-45 | |
| {0x8CB89A7DB77C506A, 0xE45C10C42A2B3B05}, // 1e-44 | |
| {0x77F3608E92ADB242, 0x8EB98A7A9A5B04E3}, // 1e-43 | |
| {0x55F038B237591ED3, 0xB267ED1940F1C61C}, // 1e-42 | |
| {0x6B6C46DEC52F6688, 0xDF01E85F912E37A3}, // 1e-41 | |
| {0x2323AC4B3B3DA015, 0x8B61313BBABCE2C6}, // 1e-40 | |
| {0xABEC975E0A0D081A, 0xAE397D8AA96C1B77}, // 1e-39 | |
| {0x96E7BD358C904A21, 0xD9C7DCED53C72255}, // 1e-38 | |
| {0x7E50D64177DA2E54, 0x881CEA14545C7575}, // 1e-37 | |
| {0xDDE50BD1D5D0B9E9, 0xAA242499697392D2}, // 1e-36 | |
| {0x955E4EC64B44E864, 0xD4AD2DBFC3D07787}, // 1e-35 | |
| {0xBD5AF13BEF0B113E, 0x84EC3C97DA624AB4}, // 1e-34 | |
| {0xECB1AD8AEACDD58E, 0xA6274BBDD0FADD61}, // 1e-33 | |
| {0x67DE18EDA5814AF2, 0xCFB11EAD453994BA}, // 1e-32 | |
| {0x80EACF948770CED7, 0x81CEB32C4B43FCF4}, // 1e-31 | |
| {0xA1258379A94D028D, 0xA2425FF75E14FC31}, // 1e-30 | |
| {0x096EE45813A04330, 0xCAD2F7F5359A3B3E}, // 1e-29 | |
| {0x8BCA9D6E188853FC, 0xFD87B5F28300CA0D}, // 1e-28 | |
| {0x775EA264CF55347D, 0x9E74D1B791E07E48}, // 1e-27 | |
| {0x95364AFE032A819D, 0xC612062576589DDA}, // 1e-26 | |
| {0x3A83DDBD83F52204, 0xF79687AED3EEC551}, // 1e-25 | |
| {0xC4926A9672793542, 0x9ABE14CD44753B52}, // 1e-24 | |
| {0x75B7053C0F178293, 0xC16D9A0095928A27}, // 1e-23 | |
| {0x5324C68B12DD6338, 0xF1C90080BAF72CB1}, // 1e-22 | |
| {0xD3F6FC16EBCA5E03, 0x971DA05074DA7BEE}, // 1e-21 | |
| {0x88F4BB1CA6BCF584, 0xBCE5086492111AEA}, // 1e-20 | |
| {0x2B31E9E3D06C32E5, 0xEC1E4A7DB69561A5}, // 1e-19 | |
| {0x3AFF322E62439FCF, 0x9392EE8E921D5D07}, // 1e-18 | |
| {0x09BEFEB9FAD487C2, 0xB877AA3236A4B449}, // 1e-17 | |
| {0x4C2EBE687989A9B3, 0xE69594BEC44DE15B}, // 1e-16 | |
| {0x0F9D37014BF60A10, 0x901D7CF73AB0ACD9}, // 1e-15 | |
| {0x538484C19EF38C94, 0xB424DC35095CD80F}, // 1e-14 | |
| {0x2865A5F206B06FB9, 0xE12E13424BB40E13}, // 1e-13 | |
| {0xF93F87B7442E45D3, 0x8CBCCC096F5088CB}, // 1e-12 | |
| {0xF78F69A51539D748, 0xAFEBFF0BCB24AAFE}, // 1e-11 | |
| {0xB573440E5A884D1B, 0xDBE6FECEBDEDD5BE}, // 1e-10 | |
| {0x31680A88F8953030, 0x89705F4136B4A597}, // 1e-9 | |
| {0xFDC20D2B36BA7C3D, 0xABCC77118461CEFC}, // 1e-8 | |
| {0x3D32907604691B4C, 0xD6BF94D5E57A42BC}, // 1e-7 | |
| {0xA63F9A49C2C1B10F, 0x8637BD05AF6C69B5}, // 1e-6 | |
| {0x0FCF80DC33721D53, 0xA7C5AC471B478423}, // 1e-5 | |
| {0xD3C36113404EA4A8, 0xD1B71758E219652B}, // 1e-4 | |
| {0x645A1CAC083126E9, 0x83126E978D4FDF3B}, // 1e-3 | |
| {0x3D70A3D70A3D70A3, 0xA3D70A3D70A3D70A}, // 1e-2 | |
| {0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC}, // 1e-1 | |
| {0x0000000000000000, 0x8000000000000000}, // 1e0 | |
| {0x0000000000000000, 0xA000000000000000}, // 1e1 | |
| {0x0000000000000000, 0xC800000000000000}, // 1e2 | |
| {0x0000000000000000, 0xFA00000000000000}, // 1e3 | |
| {0x0000000000000000, 0x9C40000000000000}, // 1e4 | |
| {0x0000000000000000, 0xC350000000000000}, // 1e5 | |
| {0x0000000000000000, 0xF424000000000000}, // 1e6 | |
| {0x0000000000000000, 0x9896800000000000}, // 1e7 | |
| {0x0000000000000000, 0xBEBC200000000000}, // 1e8 | |
| {0x0000000000000000, 0xEE6B280000000000}, // 1e9 | |
| {0x0000000000000000, 0x9502F90000000000}, // 1e10 | |
| {0x0000000000000000, 0xBA43B74000000000}, // 1e11 | |
| {0x0000000000000000, 0xE8D4A51000000000}, // 1e12 | |
| {0x0000000000000000, 0x9184E72A00000000}, // 1e13 | |
| {0x0000000000000000, 0xB5E620F480000000}, // 1e14 | |
| {0x0000000000000000, 0xE35FA931A0000000}, // 1e15 | |
| {0x0000000000000000, 0x8E1BC9BF04000000}, // 1e16 | |
| {0x0000000000000000, 0xB1A2BC2EC5000000}, // 1e17 | |
| {0x0000000000000000, 0xDE0B6B3A76400000}, // 1e18 | |
| {0x0000000000000000, 0x8AC7230489E80000}, // 1e19 | |
| {0x0000000000000000, 0xAD78EBC5AC620000}, // 1e20 | |
| {0x0000000000000000, 0xD8D726B7177A8000}, // 1e21 | |
| {0x0000000000000000, 0x878678326EAC9000}, // 1e22 | |
| {0x0000000000000000, 0xA968163F0A57B400}, // 1e23 | |
| {0x0000000000000000, 0xD3C21BCECCEDA100}, // 1e24 | |
| {0x0000000000000000, 0x84595161401484A0}, // 1e25 | |
| {0x0000000000000000, 0xA56FA5B99019A5C8}, // 1e26 | |
| {0x0000000000000000, 0xCECB8F27F4200F3A}, // 1e27 | |
| {0x4000000000000000, 0x813F3978F8940984}, // 1e28 | |
| {0x5000000000000000, 0xA18F07D736B90BE5}, // 1e29 | |
| {0xA400000000000000, 0xC9F2C9CD04674EDE}, // 1e30 | |
| {0x4D00000000000000, 0xFC6F7C4045812296}, // 1e31 | |
| {0xF020000000000000, 0x9DC5ADA82B70B59D}, // 1e32 | |
| {0x6C28000000000000, 0xC5371912364CE305}, // 1e33 | |
| {0xC732000000000000, 0xF684DF56C3E01BC6}, // 1e34 | |
| {0x3C7F400000000000, 0x9A130B963A6C115C}, // 1e35 | |
| {0x4B9F100000000000, 0xC097CE7BC90715B3}, // 1e36 | |
| {0x1E86D40000000000, 0xF0BDC21ABB48DB20}, // 1e37 | |
| {0x1314448000000000, 0x96769950B50D88F4}, // 1e38 | |
| {0x17D955A000000000, 0xBC143FA4E250EB31}, // 1e39 | |
| {0x5DCFAB0800000000, 0xEB194F8E1AE525FD}, // 1e40 | |
| {0x5AA1CAE500000000, 0x92EFD1B8D0CF37BE}, // 1e41 | |
| {0xF14A3D9E40000000, 0xB7ABC627050305AD}, // 1e42 | |
| {0x6D9CCD05D0000000, 0xE596B7B0C643C719}, // 1e43 | |
| {0xE4820023A2000000, 0x8F7E32CE7BEA5C6F}, // 1e44 | |
| {0xDDA2802C8A800000, 0xB35DBF821AE4F38B}, // 1e45 | |
| {0xD50B2037AD200000, 0xE0352F62A19E306E}, // 1e46 | |
| {0x4526F422CC340000, 0x8C213D9DA502DE45}, // 1e47 | |
| {0x9670B12B7F410000, 0xAF298D050E4395D6}, // 1e48 | |
| {0x3C0CDD765F114000, 0xDAF3F04651D47B4C}, // 1e49 | |
| {0xA5880A69FB6AC800, 0x88D8762BF324CD0F}, // 1e50 | |
| {0x8EEA0D047A457A00, 0xAB0E93B6EFEE0053}, // 1e51 | |
| {0x72A4904598D6D880, 0xD5D238A4ABE98068}, // 1e52 | |
| {0x47A6DA2B7F864750, 0x85A36366EB71F041}, // 1e53 | |
| {0x999090B65F67D924, 0xA70C3C40A64E6C51}, // 1e54 | |
| {0xFFF4B4E3F741CF6D, 0xD0CF4B50CFE20765}, // 1e55 | |
| {0xBFF8F10E7A8921A4, 0x82818F1281ED449F}, // 1e56 | |
| {0xAFF72D52192B6A0D, 0xA321F2D7226895C7}, // 1e57 | |
| {0x9BF4F8A69F764490, 0xCBEA6F8CEB02BB39}, // 1e58 | |
| {0x02F236D04753D5B4, 0xFEE50B7025C36A08}, // 1e59 | |
| {0x01D762422C946590, 0x9F4F2726179A2245}, // 1e60 | |
| {0x424D3AD2B7B97EF5, 0xC722F0EF9D80AAD6}, // 1e61 | |
| {0xD2E0898765A7DEB2, 0xF8EBAD2B84E0D58B}, // 1e62 | |
| {0x63CC55F49F88EB2F, 0x9B934C3B330C8577}, // 1e63 | |
| {0x3CBF6B71C76B25FB, 0xC2781F49FFCFA6D5}, // 1e64 | |
| {0x8BEF464E3945EF7A, 0xF316271C7FC3908A}, // 1e65 | |
| {0x97758BF0E3CBB5AC, 0x97EDD871CFDA3A56}, // 1e66 | |
| {0x3D52EEED1CBEA317, 0xBDE94E8E43D0C8EC}, // 1e67 | |
| {0x4CA7AAA863EE4BDD, 0xED63A231D4C4FB27}, // 1e68 | |
| {0x8FE8CAA93E74EF6A, 0x945E455F24FB1CF8}, // 1e69 | |
| {0xB3E2FD538E122B44, 0xB975D6B6EE39E436}, // 1e70 | |
| {0x60DBBCA87196B616, 0xE7D34C64A9C85D44}, // 1e71 | |
| {0xBC8955E946FE31CD, 0x90E40FBEEA1D3A4A}, // 1e72 | |
| {0x6BABAB6398BDBE41, 0xB51D13AEA4A488DD}, // 1e73 | |
| {0xC696963C7EED2DD1, 0xE264589A4DCDAB14}, // 1e74 | |
| {0xFC1E1DE5CF543CA2, 0x8D7EB76070A08AEC}, // 1e75 | |
| {0x3B25A55F43294BCB, 0xB0DE65388CC8ADA8}, // 1e76 | |
| {0x49EF0EB713F39EBE, 0xDD15FE86AFFAD912}, // 1e77 | |
| {0x6E3569326C784337, 0x8A2DBF142DFCC7AB}, // 1e78 | |
| {0x49C2C37F07965404, 0xACB92ED9397BF996}, // 1e79 | |
| {0xDC33745EC97BE906, 0xD7E77A8F87DAF7FB}, // 1e80 | |
| {0x69A028BB3DED71A3, 0x86F0AC99B4E8DAFD}, // 1e81 | |
| {0xC40832EA0D68CE0C, 0xA8ACD7C0222311BC}, // 1e82 | |
| {0xF50A3FA490C30190, 0xD2D80DB02AABD62B}, // 1e83 | |
| {0x792667C6DA79E0FA, 0x83C7088E1AAB65DB}, // 1e84 | |
| {0x577001B891185938, 0xA4B8CAB1A1563F52}, // 1e85 | |
| {0xED4C0226B55E6F86, 0xCDE6FD5E09ABCF26}, // 1e86 | |
| {0x544F8158315B05B4, 0x80B05E5AC60B6178}, // 1e87 | |
| {0x696361AE3DB1C721, 0xA0DC75F1778E39D6}, // 1e88 | |
| {0x03BC3A19CD1E38E9, 0xC913936DD571C84C}, // 1e89 | |
| {0x04AB48A04065C723, 0xFB5878494ACE3A5F}, // 1e90 | |
| {0x62EB0D64283F9C76, 0x9D174B2DCEC0E47B}, // 1e91 | |
| {0x3BA5D0BD324F8394, 0xC45D1DF942711D9A}, // 1e92 | |
| {0xCA8F44EC7EE36479, 0xF5746577930D6500}, // 1e93 | |
| {0x7E998B13CF4E1ECB, 0x9968BF6ABBE85F20}, // 1e94 | |
| {0x9E3FEDD8C321A67E, 0xBFC2EF456AE276E8}, // 1e95 | |
| {0xC5CFE94EF3EA101E, 0xEFB3AB16C59B14A2}, // 1e96 | |
| {0xBBA1F1D158724A12, 0x95D04AEE3B80ECE5}, // 1e97 | |
| {0x2A8A6E45AE8EDC97, 0xBB445DA9CA61281F}, // 1e98 | |
| {0xF52D09D71A3293BD, 0xEA1575143CF97226}, // 1e99 | |
| {0x593C2626705F9C56, 0x924D692CA61BE758}, // 1e100 | |
| {0x6F8B2FB00C77836C, 0xB6E0C377CFA2E12E}, // 1e101 | |
| {0x0B6DFB9C0F956447, 0xE498F455C38B997A}, // 1e102 | |
| {0x4724BD4189BD5EAC, 0x8EDF98B59A373FEC}, // 1e103 | |
| {0x58EDEC91EC2CB657, 0xB2977EE300C50FE7}, // 1e104 | |
| {0x2F2967B66737E3ED, 0xDF3D5E9BC0F653E1}, // 1e105 | |
| {0xBD79E0D20082EE74, 0x8B865B215899F46C}, // 1e106 | |
| {0xECD8590680A3AA11, 0xAE67F1E9AEC07187}, // 1e107 | |
| {0xE80E6F4820CC9495, 0xDA01EE641A708DE9}, // 1e108 | |
| {0x3109058D147FDCDD, 0x884134FE908658B2}, // 1e109 | |
| {0xBD4B46F0599FD415, 0xAA51823E34A7EEDE}, // 1e110 | |
| {0x6C9E18AC7007C91A, 0xD4E5E2CDC1D1EA96}, // 1e111 | |
| {0x03E2CF6BC604DDB0, 0x850FADC09923329E}, // 1e112 | |
| {0x84DB8346B786151C, 0xA6539930BF6BFF45}, // 1e113 | |
| {0xE612641865679A63, 0xCFE87F7CEF46FF16}, // 1e114 | |
| {0x4FCB7E8F3F60C07E, 0x81F14FAE158C5F6E}, // 1e115 | |
| {0xE3BE5E330F38F09D, 0xA26DA3999AEF7749}, // 1e116 | |
| {0x5CADF5BFD3072CC5, 0xCB090C8001AB551C}, // 1e117 | |
| {0x73D9732FC7C8F7F6, 0xFDCB4FA002162A63}, // 1e118 | |
| {0x2867E7FDDCDD9AFA, 0x9E9F11C4014DDA7E}, // 1e119 | |
| {0xB281E1FD541501B8, 0xC646D63501A1511D}, // 1e120 | |
| {0x1F225A7CA91A4226, 0xF7D88BC24209A565}, // 1e121 | |
| {0x3375788DE9B06958, 0x9AE757596946075F}, // 1e122 | |
| {0x0052D6B1641C83AE, 0xC1A12D2FC3978937}, // 1e123 | |
| {0xC0678C5DBD23A49A, 0xF209787BB47D6B84}, // 1e124 | |
| {0xF840B7BA963646E0, 0x9745EB4D50CE6332}, // 1e125 | |
| {0xB650E5A93BC3D898, 0xBD176620A501FBFF}, // 1e126 | |
| {0xA3E51F138AB4CEBE, 0xEC5D3FA8CE427AFF}, // 1e127 | |
| {0xC66F336C36B10137, 0x93BA47C980E98CDF}, // 1e128 | |
| {0xB80B0047445D4184, 0xB8A8D9BBE123F017}, // 1e129 | |
| {0xA60DC059157491E5, 0xE6D3102AD96CEC1D}, // 1e130 | |
| {0x87C89837AD68DB2F, 0x9043EA1AC7E41392}, // 1e131 | |
| {0x29BABE4598C311FB, 0xB454E4A179DD1877}, // 1e132 | |
| {0xF4296DD6FEF3D67A, 0xE16A1DC9D8545E94}, // 1e133 | |
| {0x1899E4A65F58660C, 0x8CE2529E2734BB1D}, // 1e134 | |
| {0x5EC05DCFF72E7F8F, 0xB01AE745B101E9E4}, // 1e135 | |
| {0x76707543F4FA1F73, 0xDC21A1171D42645D}, // 1e136 | |
| {0x6A06494A791C53A8, 0x899504AE72497EBA}, // 1e137 | |
| {0x0487DB9D17636892, 0xABFA45DA0EDBDE69}, // 1e138 | |
| {0x45A9D2845D3C42B6, 0xD6F8D7509292D603}, // 1e139 | |
| {0x0B8A2392BA45A9B2, 0x865B86925B9BC5C2}, // 1e140 | |
| {0x8E6CAC7768D7141E, 0xA7F26836F282B732}, // 1e141 | |
| {0x3207D795430CD926, 0xD1EF0244AF2364FF}, // 1e142 | |
| {0x7F44E6BD49E807B8, 0x8335616AED761F1F}, // 1e143 | |
| {0x5F16206C9C6209A6, 0xA402B9C5A8D3A6E7}, // 1e144 | |
| {0x36DBA887C37A8C0F, 0xCD036837130890A1}, // 1e145 | |
| {0xC2494954DA2C9789, 0x802221226BE55A64}, // 1e146 | |
| {0xF2DB9BAA10B7BD6C, 0xA02AA96B06DEB0FD}, // 1e147 | |
| {0x6F92829494E5ACC7, 0xC83553C5C8965D3D}, // 1e148 | |
| {0xCB772339BA1F17F9, 0xFA42A8B73ABBF48C}, // 1e149 | |
| {0xFF2A760414536EFB, 0x9C69A97284B578D7}, // 1e150 | |
| {0xFEF5138519684ABA, 0xC38413CF25E2D70D}, // 1e151 | |
| {0x7EB258665FC25D69, 0xF46518C2EF5B8CD1}, // 1e152 | |
| {0xEF2F773FFBD97A61, 0x98BF2F79D5993802}, // 1e153 | |
| {0xAAFB550FFACFD8FA, 0xBEEEFB584AFF8603}, // 1e154 | |
| {0x95BA2A53F983CF38, 0xEEAABA2E5DBF6784}, // 1e155 | |
| {0xDD945A747BF26183, 0x952AB45CFA97A0B2}, // 1e156 | |
| {0x94F971119AEEF9E4, 0xBA756174393D88DF}, // 1e157 | |
| {0x7A37CD5601AAB85D, 0xE912B9D1478CEB17}, // 1e158 | |
| {0xAC62E055C10AB33A, 0x91ABB422CCB812EE}, // 1e159 | |
| {0x577B986B314D6009, 0xB616A12B7FE617AA}, // 1e160 | |
| {0xED5A7E85FDA0B80B, 0xE39C49765FDF9D94}, // 1e161 | |
| {0x14588F13BE847307, 0x8E41ADE9FBEBC27D}, // 1e162 | |
| {0x596EB2D8AE258FC8, 0xB1D219647AE6B31C}, // 1e163 | |
| {0x6FCA5F8ED9AEF3BB, 0xDE469FBD99A05FE3}, // 1e164 | |
| {0x25DE7BB9480D5854, 0x8AEC23D680043BEE}, // 1e165 | |
| {0xAF561AA79A10AE6A, 0xADA72CCC20054AE9}, // 1e166 | |
| {0x1B2BA1518094DA04, 0xD910F7FF28069DA4}, // 1e167 | |
| {0x90FB44D2F05D0842, 0x87AA9AFF79042286}, // 1e168 | |
| {0x353A1607AC744A53, 0xA99541BF57452B28}, // 1e169 | |
| {0x42889B8997915CE8, 0xD3FA922F2D1675F2}, // 1e170 | |
| {0x69956135FEBADA11, 0x847C9B5D7C2E09B7}, // 1e171 | |
| {0x43FAB9837E699095, 0xA59BC234DB398C25}, // 1e172 | |
| {0x94F967E45E03F4BB, 0xCF02B2C21207EF2E}, // 1e173 | |
| {0x1D1BE0EEBAC278F5, 0x8161AFB94B44F57D}, // 1e174 | |
| {0x6462D92A69731732, 0xA1BA1BA79E1632DC}, // 1e175 | |
| {0x7D7B8F7503CFDCFE, 0xCA28A291859BBF93}, // 1e176 | |
| {0x5CDA735244C3D43E, 0xFCB2CB35E702AF78}, // 1e177 | |
| {0x3A0888136AFA64A7, 0x9DEFBF01B061ADAB}, // 1e178 | |
| {0x088AAA1845B8FDD0, 0xC56BAEC21C7A1916}, // 1e179 | |
| {0x8AAD549E57273D45, 0xF6C69A72A3989F5B}, // 1e180 | |
| {0x36AC54E2F678864B, 0x9A3C2087A63F6399}, // 1e181 | |
| {0x84576A1BB416A7DD, 0xC0CB28A98FCF3C7F}, // 1e182 | |
| {0x656D44A2A11C51D5, 0xF0FDF2D3F3C30B9F}, // 1e183 | |
| {0x9F644AE5A4B1B325, 0x969EB7C47859E743}, // 1e184 | |
| {0x873D5D9F0DDE1FEE, 0xBC4665B596706114}, // 1e185 | |
| {0xA90CB506D155A7EA, 0xEB57FF22FC0C7959}, // 1e186 | |
| {0x09A7F12442D588F2, 0x9316FF75DD87CBD8}, // 1e187 | |
| {0x0C11ED6D538AEB2F, 0xB7DCBF5354E9BECE}, // 1e188 | |
| {0x8F1668C8A86DA5FA, 0xE5D3EF282A242E81}, // 1e189 | |
| {0xF96E017D694487BC, 0x8FA475791A569D10}, // 1e190 | |
| {0x37C981DCC395A9AC, 0xB38D92D760EC4455}, // 1e191 | |
| {0x85BBE253F47B1417, 0xE070F78D3927556A}, // 1e192 | |
| {0x93956D7478CCEC8E, 0x8C469AB843B89562}, // 1e193 | |
| {0x387AC8D1970027B2, 0xAF58416654A6BABB}, // 1e194 | |
| {0x06997B05FCC0319E, 0xDB2E51BFE9D0696A}, // 1e195 | |
| {0x441FECE3BDF81F03, 0x88FCF317F22241E2}, // 1e196 | |
| {0xD527E81CAD7626C3, 0xAB3C2FDDEEAAD25A}, // 1e197 | |
| {0x8A71E223D8D3B074, 0xD60B3BD56A5586F1}, // 1e198 | |
| {0xF6872D5667844E49, 0x85C7056562757456}, // 1e199 | |
| {0xB428F8AC016561DB, 0xA738C6BEBB12D16C}, // 1e200 | |
| {0xE13336D701BEBA52, 0xD106F86E69D785C7}, // 1e201 | |
| {0xECC0024661173473, 0x82A45B450226B39C}, // 1e202 | |
| {0x27F002D7F95D0190, 0xA34D721642B06084}, // 1e203 | |
| {0x31EC038DF7B441F4, 0xCC20CE9BD35C78A5}, // 1e204 | |
| {0x7E67047175A15271, 0xFF290242C83396CE}, // 1e205 | |
| {0x0F0062C6E984D386, 0x9F79A169BD203E41}, // 1e206 | |
| {0x52C07B78A3E60868, 0xC75809C42C684DD1}, // 1e207 | |
| {0xA7709A56CCDF8A82, 0xF92E0C3537826145}, // 1e208 | |
| {0x88A66076400BB691, 0x9BBCC7A142B17CCB}, // 1e209 | |
| {0x6ACFF893D00EA435, 0xC2ABF989935DDBFE}, // 1e210 | |
| {0x0583F6B8C4124D43, 0xF356F7EBF83552FE}, // 1e211 | |
| {0xC3727A337A8B704A, 0x98165AF37B2153DE}, // 1e212 | |
| {0x744F18C0592E4C5C, 0xBE1BF1B059E9A8D6}, // 1e213 | |
| {0x1162DEF06F79DF73, 0xEDA2EE1C7064130C}, // 1e214 | |
| {0x8ADDCB5645AC2BA8, 0x9485D4D1C63E8BE7}, // 1e215 | |
| {0x6D953E2BD7173692, 0xB9A74A0637CE2EE1}, // 1e216 | |
| {0xC8FA8DB6CCDD0437, 0xE8111C87C5C1BA99}, // 1e217 | |
| {0x1D9C9892400A22A2, 0x910AB1D4DB9914A0}, // 1e218 | |
| {0x2503BEB6D00CAB4B, 0xB54D5E4A127F59C8}, // 1e219 | |
| {0x2E44AE64840FD61D, 0xE2A0B5DC971F303A}, // 1e220 | |
| {0x5CEAECFED289E5D2, 0x8DA471A9DE737E24}, // 1e221 | |
| {0x7425A83E872C5F47, 0xB10D8E1456105DAD}, // 1e222 | |
| {0xD12F124E28F77719, 0xDD50F1996B947518}, // 1e223 | |
| {0x82BD6B70D99AAA6F, 0x8A5296FFE33CC92F}, // 1e224 | |
| {0x636CC64D1001550B, 0xACE73CBFDC0BFB7B}, // 1e225 | |
| {0x3C47F7E05401AA4E, 0xD8210BEFD30EFA5A}, // 1e226 | |
| {0x65ACFAEC34810A71, 0x8714A775E3E95C78}, // 1e227 | |
| {0x7F1839A741A14D0D, 0xA8D9D1535CE3B396}, // 1e228 | |
| {0x1EDE48111209A050, 0xD31045A8341CA07C}, // 1e229 | |
| {0x934AED0AAB460432, 0x83EA2B892091E44D}, // 1e230 | |
| {0xF81DA84D5617853F, 0xA4E4B66B68B65D60}, // 1e231 | |
| {0x36251260AB9D668E, 0xCE1DE40642E3F4B9}, // 1e232 | |
| {0xC1D72B7C6B426019, 0x80D2AE83E9CE78F3}, // 1e233 | |
| {0xB24CF65B8612F81F, 0xA1075A24E4421730}, // 1e234 | |
| {0xDEE033F26797B627, 0xC94930AE1D529CFC}, // 1e235 | |
| {0x169840EF017DA3B1, 0xFB9B7CD9A4A7443C}, // 1e236 | |
| {0x8E1F289560EE864E, 0x9D412E0806E88AA5}, // 1e237 | |
| {0xF1A6F2BAB92A27E2, 0xC491798A08A2AD4E}, // 1e238 | |
| {0xAE10AF696774B1DB, 0xF5B5D7EC8ACB58A2}, // 1e239 | |
| {0xACCA6DA1E0A8EF29, 0x9991A6F3D6BF1765}, // 1e240 | |
| {0x17FD090A58D32AF3, 0xBFF610B0CC6EDD3F}, // 1e241 | |
| {0xDDFC4B4CEF07F5B0, 0xEFF394DCFF8A948E}, // 1e242 | |
| {0x4ABDAF101564F98E, 0x95F83D0A1FB69CD9}, // 1e243 | |
| {0x9D6D1AD41ABE37F1, 0xBB764C4CA7A4440F}, // 1e244 | |
| {0x84C86189216DC5ED, 0xEA53DF5FD18D5513}, // 1e245 | |
| {0x32FD3CF5B4E49BB4, 0x92746B9BE2F8552C}, // 1e246 | |
| {0x3FBC8C33221DC2A1, 0xB7118682DBB66A77}, // 1e247 | |
| {0x0FABAF3FEAA5334A, 0xE4D5E82392A40515}, // 1e248 | |
| {0x29CB4D87F2A7400E, 0x8F05B1163BA6832D}, // 1e249 | |
| {0x743E20E9EF511012, 0xB2C71D5BCA9023F8}, // 1e250 | |
| {0x914DA9246B255416, 0xDF78E4B2BD342CF6}, // 1e251 | |
| {0x1AD089B6C2F7548E, 0x8BAB8EEFB6409C1A}, // 1e252 | |
| {0xA184AC2473B529B1, 0xAE9672ABA3D0C320}, // 1e253 | |
| {0xC9E5D72D90A2741E, 0xDA3C0F568CC4F3E8}, // 1e254 | |
| {0x7E2FA67C7A658892, 0x8865899617FB1871}, // 1e255 | |
| {0xDDBB901B98FEEAB7, 0xAA7EEBFB9DF9DE8D}, // 1e256 | |
| {0x552A74227F3EA565, 0xD51EA6FA85785631}, // 1e257 | |
| {0xD53A88958F87275F, 0x8533285C936B35DE}, // 1e258 | |
| {0x8A892ABAF368F137, 0xA67FF273B8460356}, // 1e259 | |
| {0x2D2B7569B0432D85, 0xD01FEF10A657842C}, // 1e260 | |
| {0x9C3B29620E29FC73, 0x8213F56A67F6B29B}, // 1e261 | |
| {0x8349F3BA91B47B8F, 0xA298F2C501F45F42}, // 1e262 | |
| {0x241C70A936219A73, 0xCB3F2F7642717713}, // 1e263 | |
| {0xED238CD383AA0110, 0xFE0EFB53D30DD4D7}, // 1e264 | |
| {0xF4363804324A40AA, 0x9EC95D1463E8A506}, // 1e265 | |
| {0xB143C6053EDCD0D5, 0xC67BB4597CE2CE48}, // 1e266 | |
| {0xDD94B7868E94050A, 0xF81AA16FDC1B81DA}, // 1e267 | |
| {0xCA7CF2B4191C8326, 0x9B10A4E5E9913128}, // 1e268 | |
| {0xFD1C2F611F63A3F0, 0xC1D4CE1F63F57D72}, // 1e269 | |
| {0xBC633B39673C8CEC, 0xF24A01A73CF2DCCF}, // 1e270 | |
| {0xD5BE0503E085D813, 0x976E41088617CA01}, // 1e271 | |
| {0x4B2D8644D8A74E18, 0xBD49D14AA79DBC82}, // 1e272 | |
| {0xDDF8E7D60ED1219E, 0xEC9C459D51852BA2}, // 1e273 | |
| {0xCABB90E5C942B503, 0x93E1AB8252F33B45}, // 1e274 | |
| {0x3D6A751F3B936243, 0xB8DA1662E7B00A17}, // 1e275 | |
| {0x0CC512670A783AD4, 0xE7109BFBA19C0C9D}, // 1e276 | |
| {0x27FB2B80668B24C5, 0x906A617D450187E2}, // 1e277 | |
| {0xB1F9F660802DEDF6, 0xB484F9DC9641E9DA}, // 1e278 | |
| {0x5E7873F8A0396973, 0xE1A63853BBD26451}, // 1e279 | |
| {0xDB0B487B6423E1E8, 0x8D07E33455637EB2}, // 1e280 | |
| {0x91CE1A9A3D2CDA62, 0xB049DC016ABC5E5F}, // 1e281 | |
| {0x7641A140CC7810FB, 0xDC5C5301C56B75F7}, // 1e282 | |
| {0xA9E904C87FCB0A9D, 0x89B9B3E11B6329BA}, // 1e283 | |
| {0x546345FA9FBDCD44, 0xAC2820D9623BF429}, // 1e284 | |
| {0xA97C177947AD4095, 0xD732290FBACAF133}, // 1e285 | |
| {0x49ED8EABCCCC485D, 0x867F59A9D4BED6C0}, // 1e286 | |
| {0x5C68F256BFFF5A74, 0xA81F301449EE8C70}, // 1e287 | |
| {0x73832EEC6FFF3111, 0xD226FC195C6A2F8C}, // 1e288 | |
| }; | |
| // wuffs_base__private_implementation__f64_powers_of_10 holds powers of 10 that | |
| // can be exactly represented by a float64 (what C calls a double). | |
| static const double wuffs_base__private_implementation__f64_powers_of_10[23] = { | |
| 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, | |
| 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, | |
| }; | |
| // ---------------- IEEE 754 Floating Point | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 // | |
| wuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f) { | |
| uint64_t u = 0; | |
| if (sizeof(uint64_t) == sizeof(double)) { | |
| memcpy(&u, &f, sizeof(uint64_t)); | |
| } | |
| uint16_t neg = ((uint16_t)((u >> 63) << 15)); | |
| u &= 0x7FFFFFFFFFFFFFFF; | |
| uint64_t exp = u >> 52; | |
| uint64_t man = u & 0x000FFFFFFFFFFFFF; | |
| if (exp == 0x7FF) { | |
| if (man == 0) { // Infinity. | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg | 0x7C00; | |
| ret.lossy = false; | |
| return ret; | |
| } | |
| // NaN. Shift the 52 mantissa bits to 10 mantissa bits, keeping the most | |
| // significant mantissa bit (quiet vs signaling NaNs). Also set the low 9 | |
| // bits of ret.value so that the 10-bit mantissa is non-zero. | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg | 0x7DFF | ((uint16_t)(man >> 42)); | |
| ret.lossy = false; | |
| return ret; | |
| } else if (exp > 0x40E) { // Truncate to the largest finite f16. | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg | 0x7BFF; | |
| ret.lossy = true; | |
| return ret; | |
| } else if (exp <= 0x3E6) { // Truncate to zero. | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg; | |
| ret.lossy = (u != 0); | |
| return ret; | |
| } else if (exp <= 0x3F0) { // Normal f64, subnormal f16. | |
| // Convert from a 53-bit mantissa (after realizing the implicit bit) to a | |
| // 10-bit mantissa and then adjust for the exponent. | |
| man |= 0x0010000000000000; | |
| uint32_t shift = ((uint32_t)(1051 - exp)); // 1051 = 0x3F0 + 53 - 10. | |
| uint64_t shifted_man = man >> shift; | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg | ((uint16_t)shifted_man); | |
| ret.lossy = (shifted_man << shift) != man; | |
| return ret; | |
| } | |
| // Normal f64, normal f16. | |
| // Re-bias from 1023 to 15 and shift above f16's 10 mantissa bits. | |
| exp = (exp - 1008) << 10; // 1008 = 1023 - 15 = 0x3FF - 0xF. | |
| // Convert from a 52-bit mantissa (excluding the implicit bit) to a 10-bit | |
| // mantissa (again excluding the implicit bit). We lose some information if | |
| // any of the bottom 42 bits are non-zero. | |
| wuffs_base__lossy_value_u16 ret; | |
| ret.value = neg | ((uint16_t)exp) | ((uint16_t)(man >> 42)); | |
| ret.lossy = (man << 22) != 0; | |
| return ret; | |
| } | |
| WUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 // | |
| wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) { | |
| uint64_t u = 0; | |
| if (sizeof(uint64_t) == sizeof(double)) { | |
| memcpy(&u, &f, sizeof(uint64_t)); | |
| } | |
| uint32_t neg = ((uint32_t)(u >> 63)) << 31; | |
| u &= 0x7FFFFFFFFFFFFFFF; | |
| uint64_t exp = u >> 52; | |
| uint64_t man = u & 0x000FFFFFFFFFFFFF; | |
| if (exp == 0x7FF) { | |
| if (man == 0) { // Infinity. | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg | 0x7F800000; | |
| ret.lossy = false; | |
| return ret; | |
| } | |
| // NaN. Shift the 52 mantissa bits to 23 mantissa bits, keeping the most | |
| // significant mantissa bit (quiet vs signaling NaNs). Also set the low 22 | |
| // bits of ret.value so that the 23-bit mantissa is non-zero. | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg | 0x7FBFFFFF | ((uint32_t)(man >> 29)); | |
| ret.lossy = false; | |
| return ret; | |
| } else if (exp > 0x47E) { // Truncate to the largest finite f32. | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg | 0x7F7FFFFF; | |
| ret.lossy = true; | |
| return ret; | |
| } else if (exp <= 0x369) { // Truncate to zero. | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg; | |
| ret.lossy = (u != 0); | |
| return ret; | |
| } else if (exp <= 0x380) { // Normal f64, subnormal f32. | |
| // Convert from a 53-bit mantissa (after realizing the implicit bit) to a | |
| // 23-bit mantissa and then adjust for the exponent. | |
| man |= 0x0010000000000000; | |
| uint32_t shift = ((uint32_t)(926 - exp)); // 926 = 0x380 + 53 - 23. | |
| uint64_t shifted_man = man >> shift; | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg | ((uint32_t)shifted_man); | |
| ret.lossy = (shifted_man << shift) != man; | |
| return ret; | |
| } | |
| // Normal f64, normal f32. | |
| // Re-bias from 1023 to 127 and shift above f32's 23 mantissa bits. | |
| exp = (exp - 896) << 23; // 896 = 1023 - 127 = 0x3FF - 0x7F. | |
| // Convert from a 52-bit mantissa (excluding the implicit bit) to a 23-bit | |
| // mantissa (again excluding the implicit bit). We lose some information if | |
| // any of the bottom 29 bits are non-zero. | |
| wuffs_base__lossy_value_u32 ret; | |
| ret.value = neg | ((uint32_t)exp) | ((uint32_t)(man >> 29)); | |
| ret.lossy = (man << 35) != 0; | |
| return ret; | |
| } | |
| // -------- | |
| #define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047 | |
| #define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800 | |
| // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N | |
| // such that ((10 << N) < (1 << 64)). | |
| #define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60 | |
| // wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a | |
| // fixed precision floating point decimal number, augmented with ±infinity | |
| // values, but it cannot represent NaN (Not a Number). | |
| // | |
| // "High precision" means that the mantissa holds 800 decimal digits. 800 is | |
| // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION. | |
| // | |
| // An HPD isn't for general purpose arithmetic, only for conversions to and | |
| // from IEEE 754 double-precision floating point, where the largest and | |
| // smallest positive, finite values are approximately 1.8e+308 and 4.9e-324. | |
| // HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047 | |
| // bounds are further away from zero than ±(324 + 800), where 800 and 2047 is | |
| // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and | |
| // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE. | |
| // | |
| // digits[.. num_digits] are the number's digits in big-endian order. The | |
| // uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7' | |
| // is the ASCII value 0x37. | |
| // | |
| // decimal_point is the index (within digits) of the decimal point. It may be | |
| // negative or be larger than num_digits, in which case the explicit digits are | |
| // padded with implicit zeroes. | |
| // | |
| // For example, if num_digits is 3 and digits is "\x07\x08\x09": | |
| // - A decimal_point of -2 means ".00789" | |
| // - A decimal_point of -1 means ".0789" | |
| // - A decimal_point of +0 means ".789" | |
| // - A decimal_point of +1 means "7.89" | |
| // - A decimal_point of +2 means "78.9" | |
| // - A decimal_point of +3 means "789." | |
| // - A decimal_point of +4 means "7890." | |
| // - A decimal_point of +5 means "78900." | |
| // | |
| // As above, a decimal_point higher than +2047 means that the overall value is | |
| // infinity, lower than -2047 means zero. | |
| // | |
| // negative is a sign bit. An HPD can distinguish positive and negative zero. | |
| // | |
| // truncated is whether there are more than | |
| // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at | |
| // least one of those extra digits are non-zero. The existence of long-tail | |
| // digits can affect rounding. | |
| // | |
| // The "all fields are zero" value is valid, and represents the number +0. | |
| typedef struct wuffs_base__private_implementation__high_prec_dec__struct { | |
| uint32_t num_digits; | |
| int32_t decimal_point; | |
| bool negative; | |
| bool truncated; | |
| uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION]; | |
| } wuffs_base__private_implementation__high_prec_dec; | |
| // wuffs_base__private_implementation__high_prec_dec__trim trims trailing | |
| // zeroes from the h->digits[.. h->num_digits] slice. They have no benefit, | |
| // since we explicitly track h->decimal_point. | |
| // | |
| // Preconditions: | |
| // - h is non-NULL. | |
| static inline void // | |
| wuffs_base__private_implementation__high_prec_dec__trim( | |
| wuffs_base__private_implementation__high_prec_dec* h) { | |
| while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) { | |
| h->num_digits--; | |
| } | |
| } | |
| // wuffs_base__private_implementation__high_prec_dec__assign sets h to | |
| // represent the number x. | |
| // | |
| // Preconditions: | |
| // - h is non-NULL. | |
| static void // | |
| wuffs_base__private_implementation__high_prec_dec__assign( | |
| wuffs_base__private_implementation__high_prec_dec* h, | |
| uint64_t x, | |
| bool negative) { | |
| uint32_t n = 0; | |
| // Set h->digits. | |
| if (x > 0) { | |
| // Calculate the digits, working right-to-left. After we determine n (how | |
| // many digits there are), copy from buf to h->digits. | |
| // | |
| // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to | |
| // copy a constant number of bytes than a variable number (20 instead of | |
| // n). Make buf large enough (and start writing to it from the middle) so | |
| // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)]. | |
| uint8_t buf[40] = {0}; | |
| uint8_t* ptr = &buf[ |