// Copyright 2023 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.

// ----------------

/*
This test program is typically run indirectly, by the "wuffs test" or "wuffs
bench" commands. These commands take an optional "-mimic" flag to check that
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
giflib for GIF, libpng for PNG, etc.

To manually run this test:

for CC in clang gcc; do
  $CC -std=c99 -Wall -Werror jpeg.c && ./a.out
  rm -f a.out
done

Each edition should print "PASS", amongst other information, and exit(0).

Add the "wuffs mimic cflags" (everything after the colon below) to the C
compiler flags (after the .c file) to run the mimic tests.

To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
the first "./a.out" with "./a.out -bench". Combine these changes with the
"wuffs mimic cflags" to run the mimic benchmarks.
*/

// ¿ wuffs mimic cflags: -DWUFFS_MIMIC

// 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.
#define WUFFS_IMPLEMENTATION

// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
// entire Wuffs standard library, implementing a variety of codecs and file
// formats. Without this macro definition, an optimizing compiler or linker may
// very well discard Wuffs code for unused codecs, but listing the Wuffs
// modules we use makes that process explicit. Preprocessing means that such
// code simply isn't compiled.
#define WUFFS_CONFIG__MODULES
#define WUFFS_CONFIG__MODULE__BASE
#define WUFFS_CONFIG__MODULE__JPEG

// If building this program in an environment that doesn't easily accommodate
// relative includes, you can use the script/inline-c-relative-includes.go
// program to generate a stand-alone C file.
#include "../../../release/c/wuffs-unsupported-snapshot.c"
#include "../testlib/testlib.c"
#ifdef WUFFS_MIMIC
// No mimic library.
#endif

// ---------------- JPEG Tests

const char*  //
wuffs_jpeg_decode(uint64_t* n_bytes_out,
                  wuffs_base__io_buffer* dst,
                  uint32_t wuffs_initialize_flags,
                  wuffs_base__pixel_format pixfmt,
                  uint32_t* quirks_ptr,
                  size_t quirks_len,
                  wuffs_base__io_buffer* src) {
  wuffs_jpeg__decoder dec;
  CHECK_STATUS("initialize",
               wuffs_jpeg__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
                                               wuffs_initialize_flags));
  return do_run__wuffs_base__image_decoder(
      wuffs_jpeg__decoder__upcast_as__wuffs_base__image_decoder(&dec),
      n_bytes_out, dst, pixfmt, quirks_ptr, quirks_len, src);
}

const char*  //
test_wuffs_jpeg_decode_interface() {
  CHECK_FOCUS(__func__);
  wuffs_jpeg__decoder dec;
  CHECK_STATUS("initialize",
               wuffs_jpeg__decoder__initialize(
                   &dec, sizeof dec, WUFFS_VERSION,
                   WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
  return do_test__wuffs_base__image_decoder(
      wuffs_jpeg__decoder__upcast_as__wuffs_base__image_decoder(&dec),
      "test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466);
}

const char*  //
test_wuffs_jpeg_decode_truncated_input() {
  CHECK_FOCUS(__func__);

  wuffs_base__io_buffer src =
      wuffs_base__ptr_u8__reader(g_src_array_u8, 0, false);
  wuffs_jpeg__decoder dec;
  CHECK_STATUS("initialize",
               wuffs_jpeg__decoder__initialize(
                   &dec, sizeof dec, WUFFS_VERSION,
                   WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));

  wuffs_base__status status =
      wuffs_jpeg__decoder__decode_image_config(&dec, NULL, &src);
  if (status.repr != wuffs_base__suspension__short_read) {
    RETURN_FAIL("closed=false: have \"%s\", want \"%s\"", status.repr,
                wuffs_base__suspension__short_read);
  }

  src.meta.closed = true;
  status = wuffs_jpeg__decoder__decode_image_config(&dec, NULL, &src);
  if (status.repr != wuffs_jpeg__error__truncated_input) {
    RETURN_FAIL("closed=true: have \"%s\", want \"%s\"", status.repr,
                wuffs_jpeg__error__truncated_input);
  }
  return NULL;
}

const char*  //
do_test_wuffs_jpeg_decode_dht(wuffs_base__io_buffer* src,
                              const uint32_t arg_bits,
                              const uint32_t arg_n_bits,
                              const int32_t* want_dst_ptr,
                              const size_t want_dst_len,
                              const uint8_t (*want_symbols)[256],
                              const uint32_t (*want_slow)[16],
                              const uint16_t (*want_fast)[256]) {
  wuffs_jpeg__decoder dec;
  memset(&dec, 0xAB, sizeof dec);  // 0xAB is arbitrary, non-zero junk.
  CHECK_STATUS("initialize",
               wuffs_jpeg__decoder__initialize(
                   &dec, sizeof dec, WUFFS_VERSION,
                   WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));

  // Decode that DHT payload.
  if (wuffs_base__io_buffer__reader_length(src) <= 0) {
    return "empty src";
  }
  uint32_t tc4_th = ((src->data.ptr[src->meta.ri] >> 2) & 0x04) |
                    ((src->data.ptr[src->meta.ri] >> 0) & 0x03);
  dec.private_impl.f_sof_marker = 0xC0;
  dec.private_impl.f_payload_length =
      ((uint32_t)(wuffs_base__io_buffer__reader_length(src)));
  CHECK_STATUS("decode_dht", wuffs_jpeg__decoder__decode_dht(&dec, src));

  if (memcmp(dec.private_impl.f_huff_tables_symbols[tc4_th], want_symbols,
             sizeof(*want_symbols))) {
    RETURN_FAIL("unexpected huff_tables_symbols");
  } else if (memcmp(dec.private_impl.f_huff_tables_slow[tc4_th], want_slow,
                    sizeof(*want_slow))) {
    RETURN_FAIL("unexpected huff_tables_slow");
  } else if (memcmp(dec.private_impl.f_huff_tables_fast[tc4_th], want_fast,
                    sizeof(*want_fast))) {
    RETURN_FAIL("unexpected huff_tables_fast");
  }

  const int32_t err_not_enough_bits = -1;
  const int32_t err_fast_not_applicable = -2;
  const int32_t err_invalid_code = -3;

  // Check decoding of (arg_bits, arg_n_bits).
  for (int use_fast = 0; use_fast < 2; use_fast++) {
    uint32_t bits = arg_bits;
    uint32_t n_bits = arg_n_bits;
    for (size_t i = 0; i < want_dst_len; i++) {
      int have = err_fast_not_applicable;

      if (use_fast) {
        uint16_t x = (*want_fast)[bits >> 24];
        uint32_t n = x >> 8;
        if (x == 0xFFFF) {
          have = err_fast_not_applicable;
        } else if (n > n_bits) {
          have = err_not_enough_bits;
        } else {
          bits <<= n;
          n_bits -= n;
          have = x & 0xFF;
        }
      }

      if (have == err_fast_not_applicable) {
        uint32_t code = 0;
        for (uint32_t j = 0; true; j++) {
          if (n_bits <= 0) {
            have = err_not_enough_bits;
            break;
          } else if (j >= 16) {
            have = err_invalid_code;
            break;
          }
          code = (code << 1) | (bits >> 31);
          bits <<= 1;
          n_bits -= 1;
          uint32_t x = (*want_slow)[j];
          if (code < (x >> 8)) {
            have = (*want_symbols)[(code + x) & 0xFF];
            break;
          }
        }
      }

      if (have != want_dst_ptr[i]) {
        RETURN_FAIL("output symbols: use_fast=%d, i=%zu: have %d, want %d",
                    use_fast, i, have, want_dst_ptr[i]);
      }
    }
  }

  return NULL;
}

const char*  //
test_wuffs_jpeg_decode_dht_easy() {
  CHECK_FOCUS(__func__);

  const uint8_t want_symbols[256] = {
      6, 7, 4, 5, 0, 3, 8, 9, 2, 1, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  //
  };

  // Set src to this fragment of "hd test/data/bricks-color.jpeg".
  //   000000b0  .. ff c4 00 1d 00 00 02  02 03 01 01 01 00 00 00
  //   000000c0  00 00 00 00 00 00 06 07  04 05 00 03 08 09 02 01
  // The "ff c4" is the DHT marker. The "00 1d" is the payload length. The
  // remaining payload has 0x001D - 2 = 0x1B = 17 + 10 bytes.
  g_src_array_u8[0x00] = 0x00;  // (tc, th) selectors are (0, 0).
  g_src_array_u8[0x01] = 0x00;  // 0 codes of bit_length 1.
  g_src_array_u8[0x02] = 0x02;  // 2 codes of bit_length 2.
  g_src_array_u8[0x03] = 0x02;  // 2 codes of bit_length 3.
  g_src_array_u8[0x04] = 0x03;  // 3 codes of bit_length 4.
  g_src_array_u8[0x05] = 0x01;  // 1 codes of bit_length 5.
  g_src_array_u8[0x06] = 0x01;  // 1 codes of bit_length 6.
  g_src_array_u8[0x07] = 0x01;  // 1 codes of bit_length 7.
  g_src_array_u8[0x08] = 0x00;  // 0 codes of bit_length 8.
  g_src_array_u8[0x09] = 0x00;  // 0 codes of bit_length 9.
  g_src_array_u8[0x0A] = 0x00;  // etc.
  g_src_array_u8[0x0B] = 0x00;
  g_src_array_u8[0x0C] = 0x00;
  g_src_array_u8[0x0D] = 0x00;
  g_src_array_u8[0x0E] = 0x00;
  g_src_array_u8[0x0F] = 0x00;
  g_src_array_u8[0x10] = 0x00;  // 0 codes of bit-length 16. 10 codes total.
  g_src_array_u8[0x11] = want_symbols[0];  // The 1st symbol is 0x06.
  g_src_array_u8[0x12] = want_symbols[1];  // The 2nd symbol is 0x07.
  g_src_array_u8[0x13] = want_symbols[2];  // The 3rd symbol is 0x04.
  g_src_array_u8[0x14] = want_symbols[3];  // etc.
  g_src_array_u8[0x15] = want_symbols[4];
  g_src_array_u8[0x16] = want_symbols[5];
  g_src_array_u8[0x17] = want_symbols[6];
  g_src_array_u8[0x18] = want_symbols[7];
  g_src_array_u8[0x19] = want_symbols[8];
  g_src_array_u8[0x1A] = want_symbols[9];
  wuffs_base__io_buffer src =
      wuffs_base__ptr_u8__reader(g_src_array_u8, 0x1B, false);

  // The Huffman codes are:
  //   0b00......   bit_length=2   symbol=6
  //   0b01......   bit_length=2   symbol=7
  //   0b100.....   bit_length=3   symbol=4
  //   0b101.....   bit_length=3   symbol=5
  //   0b1100....   bit_length=4   symbol=0
  //   0b1101....   bit_length=4   symbol=3
  //   0b1110....   bit_length=4   symbol=8
  //   0b11110...   bit_length=5   symbol=9
  //   0b111110..   bit_length=6   symbol=2
  //   0b1111110.   bit_length=7   symbol=1
  //   0b1111111.   invalid

  // Running this on "wxyz" input should give these symbols:
  //   0x77 'w'      0x78 'x'      0x79 'y'      0x7A 'z'
  //   0b0111_0111   0b0111_1000   0b0111_1001   0b0111_1010
  //     01 1101 1101    1110 00     01 1110 01    01 1110 10
  //     s7 s3   s3      s8   s6     s7 s8   s7    s7 s8   err_not_enough_bits
  const uint32_t bits = 0x7778797A;
  const uint32_t n_bits = 32;
  const int32_t want_dst_ptr[11] = {7, 3, 3, 8, 6, 7, 8, 7, 7, 8, -1};
  const size_t want_dst_len = 11;

  const uint32_t want_slow[16] = {
      0x00000000, 0x00000200, 0x000006FE, 0x00000FF8,  //
      0x00001FE9, 0x00003FCA, 0x00007F8B, 0x00000000,  //
      0x00000000, 0x00000000, 0x00000000, 0x00000000,  //
      0x00000000, 0x00000000, 0x00000000, 0x00000000,  //
  };

  const uint16_t want_fast[256] = {
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //
      0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206,  //

      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //
      0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207, 0x0207,  //

      0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304,  //
      0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304,  //
      0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304,  //
      0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304, 0x0304,  //
      0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305,  //
      0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305,  //
      0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305,  //
      0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305, 0x0305,  //

      0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,  //
      0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,  //
      0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403,  //
      0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403, 0x0403,  //
      0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408,  //
      0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408,  //
      0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509,  //
      0x0602, 0x0602, 0x0602, 0x0602, 0x0701, 0x0701, 0xFFFF, 0xFFFF,  //
  };

  return do_test_wuffs_jpeg_decode_dht(&src, bits, n_bits, want_dst_ptr,
                                       want_dst_len, &want_symbols, &want_slow,
                                       &want_fast);
}

const char*  //
test_wuffs_jpeg_decode_dht_hard() {
  CHECK_FOCUS(__func__);

  const uint8_t want_symbols[256] = {
      0x01, 0x02, 0x03, 0x04, 0x05, 0x11, 0x00, 0x06,  //
      0x07, 0x12, 0x21, 0x31, 0x13, 0x41, 0x51, 0x08,  //
      0x14, 0x22, 0x61, 0x71, 0x32, 0x42, 0x81, 0x91,  //
      0xA1, 0xB1, 0x15, 0x23, 0x52, 0x33, 0x82, 0xC1,  //
      0xD1, 0xF0, 0x16, 0x62, 0x72, 0x92, 0xC2, 0xE1,  //
      0x17, 0x53, 0x63, 0xA2, 0xA4, 0xB2, 0xF1, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  //
  };

  // Set src to this fragment of "hd test/data/bricks-color.jpeg".
  //   000000d0  ff c4 00 42 10 00 02 01  03 02 04 03 05 06 03 05
  //   000000e0  06 07 00 00 00 01 02 03  04 05 11 00 06 07 12 21
  //   000000f0  31 13 41 51 08 14 22 61  71 32 42 81 91 a1 b1 15
  //   00000100  23 52 33 82 c1 d1 f0 16  62 72 92 c2 e1 17 53 63
  //   00000110  a2 a4 b2 f1 .. .. .. ..  .. .. .. .. .. .. .. ..
  // The "ff c4" is the DHT marker. The "00 42" is the payload length. The
  // remaining payload has 0x0042 - 2 = 0x40 = 17 + 47 bytes.
  g_src_array_u8[0x00] = 0x10;  // (tc, th) selectors are (1, 0).
  g_src_array_u8[0x01] = 0x00;  // 0 codes of bit_length 1.
  g_src_array_u8[0x02] = 0x02;  // 2 codes of bit_length 2.
  g_src_array_u8[0x03] = 0x01;  // 1 codes of bit_length 3.
  g_src_array_u8[0x04] = 0x03;  // 3 codes of bit_length 4.
  g_src_array_u8[0x05] = 0x02;  // 2 codes of bit_length 5.
  g_src_array_u8[0x06] = 0x04;  // 4 codes of bit_length 6.
  g_src_array_u8[0x07] = 0x03;  // 3 codes of bit_length 7.
  g_src_array_u8[0x08] = 0x05;  // 5 codes of bit_length 8.
  g_src_array_u8[0x09] = 0x06;  // 6 codes of bit_length 9.
  g_src_array_u8[0x0A] = 0x03;  // etc.
  g_src_array_u8[0x0B] = 0x05;
  g_src_array_u8[0x0C] = 0x06;
  g_src_array_u8[0x0D] = 0x07;
  g_src_array_u8[0x0E] = 0x00;
  g_src_array_u8[0x0F] = 0x00;
  g_src_array_u8[0x10] = 0x00;  // 0 codes of bit-length 16. 47 codes total.
  memcpy(&g_src_array_u8[0x11], want_symbols, 47);
  wuffs_base__io_buffer src =
      wuffs_base__ptr_u8__reader(g_src_array_u8, 0x40, false);

  // The Huffman codes are:
  //   0b00......_........   bit_length=0x02   symbol=0x01
  //   0b01......_........   bit_length=0x02   symbol=0x02
  //   0b100....._........   bit_length=0x03   symbol=0x03
  //   0b1010...._........   bit_length=0x04   symbol=0x04
  //   0b1011...._........   bit_length=0x04   symbol=0x05
  //   0b1100...._........   bit_length=0x04   symbol=0x11
  //   0b11010..._........   bit_length=0x05   symbol=0x00
  //   0b11011..._........   bit_length=0x05   symbol=0x06
  //   0b111000.._........   bit_length=0x06   symbol=0x07
  //   0b111001.._........   bit_length=0x06   symbol=0x12
  //   0b111010.._........   bit_length=0x06   symbol=0x21
  //   0b111011.._........   bit_length=0x06   symbol=0x31
  //   0b1111000._........   bit_length=0x07   symbol=0x13
  //   0b1111001._........   bit_length=0x07   symbol=0x41
  //   0b1111010._........   bit_length=0x07   symbol=0x51
  //   0b11110110_........   bit_length=0x08   symbol=0x08
  //   0b11110111_........   bit_length=0x08   symbol=0x14
  //   0b11111000_........   bit_length=0x08   symbol=0x22
  //   0b11111001_........   bit_length=0x08   symbol=0x61
  //   0b11111010_........   bit_length=0x08   symbol=0x71
  //   0b11111011_0.......   bit_length=0x09   symbol=0x32
  //   0b11111011_1.......   bit_length=0x09   symbol=0x42
  //   0b11111100_0.......   bit_length=0x09   symbol=0x81
  //   0b11111100_1.......   bit_length=0x09   symbol=0x91
  //   0b11111101_0.......   bit_length=0x09   symbol=0xA1
  //   0b11111101_1.......   bit_length=0x09   symbol=0xB1
  //   0b11111110_00......   bit_length=0x0A   symbol=0x15
  //   0b11111110_01......   bit_length=0x0A   symbol=0x23
  //   0b11111110_10......   bit_length=0x0A   symbol=0x52
  //   0b11111110_110.....   bit_length=0x0B   symbol=0x33
  //   0b11111110_111.....   bit_length=0x0B   symbol=0x82
  //   0b11111111_000.....   bit_length=0x0B   symbol=0xC1
  //   0b11111111_001.....   bit_length=0x0B   symbol=0xD1
  //   0b11111111_010.....   bit_length=0x0B   symbol=0xF0
  //   0b11111111_0110....   bit_length=0x0C   symbol=0x16
  //   0b11111111_0111....   bit_length=0x0C   symbol=0x62
  //   0b11111111_1000....   bit_length=0x0C   symbol=0x72
  //   0b11111111_1001....   bit_length=0x0C   symbol=0x92
  //   0b11111111_1010....   bit_length=0x0C   symbol=0xC2
  //   0b11111111_1011....   bit_length=0x0C   symbol=0xE1
  //   0b11111111_11000...   bit_length=0x0D   symbol=0x17
  //   0b11111111_11001...   bit_length=0x0D   symbol=0x53
  //   0b11111111_11010...   bit_length=0x0D   symbol=0x63
  //   0b11111111_11011...   bit_length=0x0D   symbol=0xA2
  //   0b11111111_11100...   bit_length=0x0D   symbol=0xA4
  //   0b11111111_11101...   bit_length=0x0D   symbol=0xB2
  //   0b11111111_11110...   bit_length=0x0D   symbol=0xF1
  //   0b11111111_11111...   invalid

  // Running this on "wx\x7Fh" input should give these symbols:
  //   0x77 'w'      0x78 'x'      0x7F '\x7F'   0x68 'h'
  //   0b0111_0111   0b0111_1000   0b0111_1111   0b0110_1000
  //     01 11011 1011    1100 00     11111110110       100 0
  //     s2 s6    s5      s11  s1     s33               s3  err_not_enough_bits
  const uint32_t bits = 0x77787F68;
  const uint32_t n_bits = 32;
  const int32_t want_dst_ptr[8] = {0x02, 0x06, 0x05, 0x11,
                                   0x01, 0x33, 0x03, -1};
  const size_t want_dst_len = 8;

  const uint32_t want_slow[16] = {
      0x00000000, 0x00000200, 0x000005FE, 0x00000DF9,  //
      0x00001CEC, 0x00003CD0, 0x00007B94, 0x0000FB19,  //
      0x0001FC1E, 0x0003FB22, 0x0007FB27, 0x000FFC2C,  //
      0x001FFF30, 0x00000000, 0x00000000, 0x00000000,  //
  };

  const uint16_t want_fast[256] = {
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //
      0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201, 0x0201,  //

      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //
      0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202,  //

      0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303,  //
      0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303,  //
      0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303,  //
      0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303, 0x0303,  //
      0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404,  //
      0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404, 0x0404,  //
      0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405,  //
      0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405, 0x0405,  //

      0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411,  //
      0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411, 0x0411,  //
      0x0500, 0x0500, 0x0500, 0x0500, 0x0500, 0x0500, 0x0500, 0x0500,  //
      0x0506, 0x0506, 0x0506, 0x0506, 0x0506, 0x0506, 0x0506, 0x0506,  //
      0x0607, 0x0607, 0x0607, 0x0607, 0x0612, 0x0612, 0x0612, 0x0612,  //
      0x0621, 0x0621, 0x0621, 0x0621, 0x0631, 0x0631, 0x0631, 0x0631,  //
      0x0713, 0x0713, 0x0741, 0x0741, 0x0751, 0x0751, 0x0808, 0x0814,  //
      0x0822, 0x0861, 0x0871, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,  //
  };

  return do_test_wuffs_jpeg_decode_dht(&src, bits, n_bits, want_dst_ptr,
                                       want_dst_len, &want_symbols, &want_slow,
                                       &want_fast);
}

const char*  //
test_wuffs_jpeg_decode_idct() {
  CHECK_FOCUS(__func__);

  // This is "test/data/bricks-color.jpeg"'s first MCU's first block, in
  // natural (not zig-zag) order.
  const uint16_t mcu_block[64] = {
      0xFFC9, 0xFFD8, 0x0014, 0xFFF7, 0x0002, 0x0000, 0x0000, 0x0000,  //
      0x006A, 0xFFE3, 0x001C, 0xFFF9, 0x0002, 0x0000, 0x0000, 0x0000,  //
      0x0015, 0x0002, 0x0002, 0xFFFE, 0x0001, 0x0000, 0x0000, 0x0001,  //
      0x000D, 0xFFEC, 0x0005, 0xFFFE, 0x0000, 0x0000, 0x0000, 0x0000,  //
      0xFFFA, 0xFFFA, 0x0002, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000,  //
      0x0001, 0xFFFD, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
  };

  // This is "test/data/bricks-color.jpeg"'s first quantization table, in
  // natural (not zig-zag) order.
  const uint8_t quant_table[64] = {
      0x03, 0x02, 0x02, 0x03, 0x04, 0x06, 0x08, 0x0A,  //
      0x02, 0x02, 0x02, 0x03, 0x04, 0x09, 0x0A, 0x09,  //
      0x02, 0x02, 0x03, 0x04, 0x06, 0x09, 0x0B, 0x09,  //
      0x02, 0x03, 0x04, 0x05, 0x08, 0x0E, 0x0D, 0x0A,  //
      0x03, 0x04, 0x06, 0x09, 0x0B, 0x11, 0x10, 0x0C,  //
      0x04, 0x06, 0x09, 0x0A, 0x0D, 0x11, 0x12, 0x0F,  //
      0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x13, 0x13, 0x10,  //
      0x0C, 0x0F, 0x0F, 0x10, 0x12, 0x10, 0x10, 0x10,  //
  };

  // This is the IDCT's expected result (including dequantization), again in
  // natural (not zig-zag) order.
  const uint8_t want_array[64] = {
      0x81, 0x7E, 0x82, 0x7E, 0x82, 0x92, 0xC5, 0xF2,  //
      0x81, 0x80, 0x84, 0x85, 0x85, 0x88, 0x9D, 0xB2,  //
      0x86, 0x81, 0x7A, 0x77, 0x72, 0x75, 0x7E, 0x8A,  //
      0x54, 0x58, 0x58, 0x5E, 0x5E, 0x6C, 0x79, 0x87,  //
      0x4D, 0x54, 0x56, 0x5B, 0x59, 0x65, 0x6E, 0x7A,  //
      0x4A, 0x4D, 0x4F, 0x53, 0x56, 0x5F, 0x67, 0x6E,  //
      0x4A, 0x4D, 0x54, 0x58, 0x5B, 0x58, 0x56, 0x54,  //
      0x4C, 0x4C, 0x52, 0x4F, 0x4D, 0x40, 0x3A, 0x35,  //
  };

  wuffs_jpeg__decoder dec;
  CHECK_STATUS("initialize", wuffs_jpeg__decoder__initialize(
                                 &dec, sizeof dec, WUFFS_VERSION,
                                 WUFFS_INITIALIZE__DEFAULT_OPTIONS));

  const uint32_t b = 0;
  memcpy(&dec.private_data.f_mcu_blocks[b], mcu_block, sizeof(mcu_block));

  const uint32_t q = 0;
  memcpy(&dec.private_impl.f_quant_tables[q], quant_table, sizeof(quant_table));

  uint8_t dst_array[64] = {0};
  wuffs_jpeg__decoder__decode_idct(
      &dec, wuffs_base__make_slice_u8(&dst_array[0], 64), 8, b, q);

  wuffs_base__io_buffer have =
      wuffs_base__ptr_u8__reader(&dst_array[0], 64, true);
  wuffs_base__io_buffer want =
      wuffs_base__ptr_u8__reader((void*)(&want_array[0]), 64, true);

  return check_io_buffers_equal("", &have, &want);
}

const char*  //
test_wuffs_jpeg_decode_mcu() {
  CHECK_FOCUS(__func__);

  wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
      .data = g_src_slice_u8,
  });
  CHECK_STRING(read_file(&src, "test/data/bricks-color.jpeg"));

  wuffs_jpeg__decoder dec;
  CHECK_STATUS("initialize", wuffs_jpeg__decoder__initialize(
                                 &dec, sizeof dec, WUFFS_VERSION,
                                 WUFFS_INITIALIZE__DEFAULT_OPTIONS));

  // Bypass the "#missing Quantization table" check.
  dec.private_impl.f_seen_dqt[0] = true;
  dec.private_impl.f_seen_dqt[1] = true;

  // Decode the 0xC0 SOF marker, four 0xC4 DHT markers and 0xDA SOS marker. The
  // SOS marker is only partially processed, since complete SOS processing
  // would call wuffs_jpeg__decoder__decode_mcu multiple times.
  const uint32_t marker_positions[6] =  //
      {0x09E, 0x0B1, 0x0D0, 0x114, 0x133, 0x16E};
  for (int i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(marker_positions); i++) {
    uint8_t want_marker = (i <= 0) ? 0xC0 : ((i <= 4) ? 0xC4 : 0xDA);
    src.meta.ri = marker_positions[i];
    if ((src.meta.ri + 4) > src.meta.wi) {
      RETURN_FAIL("seek #%d: past EOF", i);
    } else if (src.data.ptr[src.meta.ri++] != 0xFF) {
      RETURN_FAIL("seek #%d: have 0x%02X, want 0x%02X", i,
                  src.data.ptr[src.meta.ri - 1], 0xFF);
    } else if (src.data.ptr[src.meta.ri++] != want_marker) {
      RETURN_FAIL("seek #%d: have 0x%02X, want 0x%02X", i,
                  src.data.ptr[src.meta.ri - 1], want_marker);
    }

    dec.private_impl.f_payload_length = 0;
    dec.private_impl.f_payload_length |= src.data.ptr[src.meta.ri++];
    dec.private_impl.f_payload_length <<= 8;
    dec.private_impl.f_payload_length |= src.data.ptr[src.meta.ri++];
    dec.private_impl.f_payload_length -= 2;

    if (i <= 0) {
      dec.private_impl.f_sof_marker = 0xC0;
      CHECK_STATUS("decode_sof", wuffs_jpeg__decoder__decode_sof(&dec, &src));
    } else if (i <= 4) {
      CHECK_STATUS("decode_dht", wuffs_jpeg__decoder__decode_dht(&dec, &src));
    } else {
      CHECK_STATUS("prepare_scan",
                   wuffs_jpeg__decoder__prepare_scan(&dec, &src));
      wuffs_jpeg__decoder__fill_bitstream(&dec, &src);
    }
  }

  // Decode and compare-to-golden the first MCU (Minimum Coded Unit).

  if (wuffs_jpeg__decoder__decode_mcu(&dec)) {
    RETURN_FAIL("decode_mcu failed");
  }

  // 4:2:0 chroma subsampling means that the MCU has 4 Y, 1 Cb and 1 Cr blocks.
  uint16_t wants[10][64] = {
      {
          0xFFC9, 0xFFD8, 0x0014, 0xFFF7, 0x0002, 0x0000, 0x0000, 0x0000,  //
          0x006A, 0xFFE3, 0x001C, 0xFFF9, 0x0002, 0x0000, 0x0000, 0x0000,  //
          0x0015, 0x0002, 0x0002, 0xFFFE, 0x0001, 0x0000, 0x0000, 0x0001,  //
          0x000D, 0xFFEC, 0x0005, 0xFFFE, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0xFFFA, 0xFFFA, 0x0002, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0001, 0xFFFD, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      },
      {
          0xFFAA, 0x0070, 0x003A, 0xFFE0, 0xFFF9, 0x0004, 0x0000, 0x0001,  //
          0x004F, 0x005E, 0x0022, 0x0006, 0xFFF3, 0xFFFD, 0x0004, 0x0000,  //
          0xFFF4, 0xFFE8, 0x0002, 0x0012, 0x0003, 0x0000, 0xFFFF, 0x0002,  //
          0xFFEC, 0xFFF3, 0x000A, 0x000A, 0x0007, 0x0000, 0xFFFF, 0xFFFF,  //
          0xFFF3, 0xFFFB, 0xFFFD, 0x0002, 0x0002, 0x0000, 0x0001, 0x0000,  //
          0xFFFC, 0xFFFB, 0xFFFD, 0xFFFF, 0x0000, 0x0002, 0x0001, 0x0001,  //
          0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0001, 0x0001, 0x0001,  //
          0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0001, 0x0000,  //
      },
      {
          0xFF25, 0x000D, 0x0003, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x000E, 0x0006, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0005, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0004, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      },
      {
          0xFF59, 0xFFD6, 0xFFCF, 0x000C, 0x0006, 0xFFFE, 0xFFFE, 0x0002,  //
          0xFFF3, 0x0013, 0x000C, 0xFFE6, 0x000E, 0x0001, 0xFFFC, 0x0004,  //
          0x0010, 0xFFF1, 0x0005, 0x0003, 0xFFFA, 0x0002, 0x0001, 0xFFFE,  //
          0xFFF9, 0x0005, 0x0000, 0xFFFE, 0x0002, 0x0000, 0xFFFE, 0x0002,  //
          0x0003, 0xFFFF, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0001, 0xFFFF,  //
          0xFFFE, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      },
      {
          0x0077, 0x000F, 0xFFFA, 0x0001, 0x0000, 0xFFFF, 0x0002, 0xFFFF,  //
          0xFFFA, 0x0020, 0xFFF9, 0x0000, 0x0000, 0xFFFF, 0x0001, 0xFFFF,  //
          0xFFFA, 0x0008, 0x0000, 0x0000, 0xFFFF, 0x0001, 0x0000, 0x0000,  //
          0xFFFE, 0x0001, 0x0001, 0x0001, 0xFFFF, 0x0001, 0xFFFF, 0x0000,  //
          0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      },
      {
          0xFF88, 0x0003, 0xFFFD, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0001,  //
          0xFFE4, 0xFFEC, 0x0001, 0x0001, 0x0000, 0x0001, 0xFFFF, 0x0001,  //
          0xFFFC, 0xFFFC, 0xFFFE, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0000,  //
          0x0001, 0xFFFF, 0xFFFF, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0xFFFE, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
          0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,  //
      },
      {0},  //
      {0},  //
      {0},  //
      {0},  //
  };

  for (int b = 0; b < 10; b++) {
    wuffs_base__io_buffer have = wuffs_base__ptr_u8__reader(  //
        (void*)(&dec.private_data.f_mcu_blocks[b]),           //
        sizeof(dec.private_data.f_mcu_blocks[b]), true);
    wuffs_base__io_buffer want = wuffs_base__ptr_u8__reader(  //
        (void*)(&wants[b]),                                   //
        sizeof(wants[b]), true);

    char prefix[64];
    snprintf(prefix, 64, "b=%d: ", b);
    CHECK_STRING(check_io_buffers_equal(prefix, &have, &want));
  }

  return NULL;
}

// ---------------- Mimic Tests

#ifdef WUFFS_MIMIC

// No mimic tests.

#endif  // WUFFS_MIMIC

// ---------------- JPEG Benches

const char*  //
bench_wuffs_jpeg_decode_77k_24bpp() {
  CHECK_FOCUS(__func__);
  return do_bench_image_decode(
      &wuffs_jpeg_decode,
      WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
      wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
      NULL, 0, "test/data/bricks-color.jpeg", 0, SIZE_MAX, 1000);
}

// ---------------- Mimic Benches

#ifdef WUFFS_MIMIC

// No mimic benches.

#endif  // WUFFS_MIMIC

// ---------------- Manifest

proc g_tests[] = {

    test_wuffs_jpeg_decode_dht_easy,
    test_wuffs_jpeg_decode_dht_hard,
    test_wuffs_jpeg_decode_idct,
    test_wuffs_jpeg_decode_mcu,
    test_wuffs_jpeg_decode_interface,
    test_wuffs_jpeg_decode_truncated_input,

#ifdef WUFFS_MIMIC

// No mimic tests.

#endif  // WUFFS_MIMIC

    NULL,
};

proc g_benches[] = {

    bench_wuffs_jpeg_decode_77k_24bpp,

#ifdef WUFFS_MIMIC

// No mimic benches.

#endif  // WUFFS_MIMIC

    NULL,
};

int  //
main(int argc, char** argv) {
  g_proc_package_name = "std/jpeg";
  return test_main(argc, argv, g_tests, g_benches);
}