#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 <LICENSE-APACHE or

// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license

// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your

// option. This file may not be copied, modified, or distributed

// except according to those terms.

//

// SPDX-License-Identifier: Apache-2.0 OR MIT

#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.

//

// ¡ Some code generation programs can override WUFFS_VERSION.

#define WUFFS_VERSION 0

#define WUFFS_VERSION_MAJOR 0

#define WUFFS_VERSION_MINOR 0

#define WUFFS_VERSION_PATCH 0

#define WUFFS_VERSION_PRE_RELEASE_LABEL "unsupported.snapshot"

#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0

#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0

#define WUFFS_VERSION_STRING "0.0.0+0.00000000"

// ---------------- Private Implementation Macros Re-definition Check

// Users (those who #include the "wuffs-vM.N.c" file) should not define any

// WUFFS_PRIVATE_IMPL__ETC macros, only WUFFS_CONFIG__ETC macros (and

// WUFFS_IMPLEMENTATION). Mucking about with the private implementation macros

// is not supported and may break when upgrading to newer Wuffs versions.

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32) ||       \

    defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON) ||        \

    defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64) ||          \

    defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) ||       \

    defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3) ||       \

    defined(WUFFS_PRIVATE_IMPL__HPD__DECIMAL_POINT__RANGE) || \

    defined(WUFFS_PRIVATE_IMPL__HPD__DIGITS_PRECISION) ||     \

    defined(WUFFS_PRIVATE_IMPL__HPD__SHIFT__MAX_INCL) ||      \

    defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U16) ||        \

    defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U32) ||        \

    defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U64) ||        \

    defined(WUFFS_PRIVATE_IMPL__LOW_BITS_MASK__U8)

#if defined(__GNUC__) || defined(__clang__)

#warning "Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported"

#elif defined(_MSC_VER)

#pragma message("Defining WUFFS_PRIVATE_IMPL__ETC yourself is not supported")

#endif

#endif

// ---------------- Obsolete Macros Check

// std/tga was renamed to std/targa in September 2024 (Wuffs v0.4 alpha).

#if defined(WUFFS_CONFIG__MODULE__TGA)

#if defined(__GNUC__) || defined(__clang__)

#warning "WUFFS_CONFIG__MODULE__TGA was renamed to WUFFS_CONFIG__MODULE__TARGA"

#elif defined(_MSC_VER)

#pragma message( \

    "WUFFS_CONFIG__MODULE__TGA was renamed to WUFFS_CONFIG__MODULE__TARGA")

#endif

#endif

// ---------------- 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_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32

#endif  // defined(__ARM_FEATURE_CRC32)

#if defined(__ARM_NEON)

#include <arm_neon.h>

#define WUFFS_PRIVATE_IMPL__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.

//

// ----

//

// Technically, we could use the SSE family on 32-bit x86, not just 64-bit x86.

// But some intrinsics don't compile in 32-bit mode. It's not worth the hassle.

// https://github.com/google/wuffs/issues/145

#if defined(__x86_64__)

#if !defined(__native_client__)

#include <cpuid.h>

#include <x86intrin.h>

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3

#endif  // !defined(__native_client__)

#endif  // defined(__x86_64__)

#elif defined(_MSC_VER)  // (#if-chain ref AVOID_CPU_ARCH_1)

#if defined(_M_X64)

// On X86_64, Microsoft Visual C/C++ (MSVC) only supports SSE2 by default.

// There are /arch:SSE2, /arch:AVX and /arch:AVX2 compiler flags (the AVX2 one

// is roughly equivalent to X86_64_V3), but there is no /arch:SSE42 compiler

// flag that's equivalent to X86_64_V2.

//

// For getting maximum performance with X86_64 MSVC and Wuffs, pass /arch:AVX2

// (and then test on the oldest hardware you intend to support).

//

// Absent that compiler flag, either define one of the three macros listed

// below or else the X86_64 SIMD code will be disabled and you'll get a #pragma

// message stating this library "performs best with /arch:AVX2". This message

// is harmless and ignorable, in that the non-SIMD code is still correct and

// reasonably performant, but is a reminder that when combining Wuffs and MSVC,

// some compiler configuration is required for maximum performance.

//

//  - WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY

//  - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2 (enables SSE4.2 and below)

//  - WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3 (enables AVX2 and below)

//

// Defining the first one (WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)

// or defining none of those three (the default state) are equivalent (in that

// both disable the SIMD code paths), other than that pragma message.

//

// When defining these WUFFS_CONFIG__ENABLE_ETC macros with MSVC, be aware that

// some users report it leading to ICEs (Internal Compiler Errors), but other

// users report no problems at all (and improved performance). It's unclear

// exactly what combination of SIMD code and MSVC configuration lead to ICEs.

// Do your own testing with your own MSVC version and configuration.

//

// https://github.com/google/wuffs/issues/148

// https://github.com/google/wuffs/issues/151

// https://developercommunity.visualstudio.com/t/fatal--error-C1001:-Internal-compiler-er/10703305

//

// Clang (including clang-cl) and GCC don't need this WUFFS_CONFIG__ETC macro

// machinery, or having the Wuffs-the-library user to fiddle with compiler

// flags, because they support "__attribute__((target(arg)))".

#if defined(__AVX2__) || defined(__clang__) || \

    defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V3)

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3

#elif defined(WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2)

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64

#define WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2

#elif !defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)

#pragma message("Wuffs with MSVC+X64 performs best with /arch:AVX2")

#endif  // defined(__AVX2__) || defined(__clang__) || etc

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

#if defined(WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY)

#error "MSVC_CPU_ARCH simultaneously enabled and disabled"

#endif

#include <intrin.h>

// intrin.h isn't 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

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

#endif  // 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(void) {

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)

  return true;

#else

  return false;

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_CRC32)

}

static inline bool  //

wuffs_base__cpu_arch__have_arm_neon(void) {

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)

  return true;

#else

  return false;

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__ARM_NEON)

}

static inline bool  //

wuffs_base__cpu_arch__have_x86_avx2(void) {

#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && \

    defined(__AVX2__)

  return true;

#else

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  // 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_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler"

#endif  // defined(__GNUC__); defined(_MSC_VER)

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  return false;

#endif  // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) &&

        // defined(__AVX2__)

}

static inline bool  //

wuffs_base__cpu_arch__have_x86_bmi2(void) {

#if defined(__BMI2__)

  return true;

#else

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  // 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_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler"

#endif  // defined(__GNUC__); defined(_MSC_VER)

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  return false;

#endif  // defined(__BMI2__)

}

static inline bool  //

wuffs_base__cpu_arch__have_x86_sse42(void) {

#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)

  return true;

#else

#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  // 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_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler"

#endif  // defined(__GNUC__); defined(_MSC_VER)

#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)

  return false;

#endif  // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)

}

// ---------------- 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__FORCE_INLINE __attribute__((__always_inline__))

#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))

#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))

#elif defined(_MSC_VER)

#define WUFFS_BASE__FORCE_INLINE __forceinline

#define WUFFS_BASE__POTENTIALLY_UNUSED

#define WUFFS_BASE__WARN_UNUSED_RESULT

#else

#define WUFFS_BASE__FORCE_INLINE

#define WUFFS_BASE__POTENTIALLY_UNUSED

#define WUFFS_BASE__WARN_UNUSED_RESULT

#endif

// Clang's "-fsanitize=integer" checks for "unsigned-integer-overflow" even

// though, for *unsigned* integers, it is *not* undefined behavior. The check

// is still made because unsigned integer overflow "is often unintentional".

// https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html

//

// However, for Wuffs' generated C code, unsigned overflow is intentional. The

// programmer has to use "~mod+" instead of a plain "+" operator in Wuffs code.

// Further runtime checks for unsigned integer overflow can add performance

// overhead (fuzzers can then time out) and can raise false negatives, without

// generating much benefits. We disable the "unsigned-integer-overflow" check.

#if defined(__has_feature)

#if __has_feature(undefined_behavior_sanitizer)

#define WUFFS_BASE__GENERATED_C_CODE \

  __attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

#if !defined(WUFFS_BASE__GENERATED_C_CODE)

#define WUFFS_BASE__GENERATED_C_CODE

#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)

// --------

#ifdef __cplusplus

// Wuffs structs are just data, not resources (in the RAII sense). They don't

// subclass anything. They don't have virtual destructors. They don't contain

// pointers to dynamically allocated memory. They don't contain file

// descriptors. And so on. Destroying such a struct (e.g. via a

// wuffs_foo__bar::unique_ptr) can just call free, especially as

// sizeof(wuffs_foo__bar) isn't supposed to be part of the public (stable) API.

struct wuffs_unique_ptr_deleter {

  void operator()(void* p) { free(p); }

};

#endif  // __cplusplus

// --------

#if defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wcast-qual"

#endif

static inline uint8_t*  //

wuffs_base__strip_const_from_u8_ptr(const uint8_t* ptr) {

  return (uint8_t*)ptr;

}

static inline uint16_t*  //

wuffs_base__strip_const_from_u16_ptr(const uint16_t* ptr) {

  return (uint16_t*)ptr;

}

static inline uint32_t*  //

wuffs_base__strip_const_from_u32_ptr(const uint32_t* ptr) {

  return (uint32_t*)ptr;

}

static inline uint64_t*  //

wuffs_base__strip_const_from_u64_ptr(const uint64_t* ptr) {

  return (uint64_t*)ptr;

}

#if defined(__GNUC__)

#pragma GCC diagnostic pop

#endif

// --------

// 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(void) {

  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 bool is_truncated_input_error() 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_workbuf[];

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_wuffs_config_dst_pixel_format_enable_allowlist[];

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__insufficient_history[];

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_image_dimension[];

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 == '$');

}

static inline bool  //

wuffs_base__status__is_truncated_input_error(const wuffs_base__status* z) {

  const char* p = z->repr;

  if (!p || (*p != '#')) {

    return false;

  }

  p++;

  while (1) {

    if (*p == 0) {

      return false;

    } else if (*p++ == ':') {

      break;

    }

  }

  return strcmp(p, " truncated input") == 0;

}

// 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 bool  //

wuffs_base__status::is_truncated_input_error() const {

  return wuffs_base__status__is_truncated_input_error(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.

// Android Binary XML (for resources; see AndroidBinXmlParser.java).

#define WUFFS_BASE__FOURCC__ABXR 0x41425852

// Android Binary XML (for system_server; see BinaryXmlSerializer.java).

#define WUFFS_BASE__FOURCC__ABXS 0x41425853

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

// Ericsson Texture Compression 2 (iPACKMAN).

#define WUFFS_BASE__FOURCC__ETC2 0x45544332

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

// Lzip.

#define WUFFS_BASE__FOURCC__LZIP 0x4C5A4950

// Lempel–Ziv Markov-chain Algorithm.

#define WUFFS_BASE__FOURCC__LZMA 0x4C5A4D41

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

// Netpbm (Portable Anymap).

#define WUFFS_BASE__FOURCC__NPBM 0x4E50424D

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

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

// Thumbhash.

#define WUFFS_BASE__FOURCC__TH 0x54482020

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

#define WUFFS_BASE__QUIRK_QUALITY 2

// --------

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