// Copyright 2021 The libgav1 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
//
//      http://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 "src/utils/entropy_decoder.h"

#include <cstdint>
#include <cstdio>

#include "absl/time/clock.h"
#include "absl/time/time.h"
#include "gtest/gtest.h"

namespace libgav1 {
namespace {

#include "src/utils/entropy_decoder_test_data.inc"

class EntropyDecoderTest : public testing::Test {
 protected:
  // If compile_time is true, tests
  //     bool EntropyDecoder::ReadSymbol(uint16_t* cdf).
  // Otherwise, tests
  //     int EntropyDecoder::ReadSymbol(uint16_t* cdf, int symbol_count)
  // with symbol_count=2.
  template <bool compile_time>
  void TestReadSymbolBoolean(int num_runs);

  // For N = 3..16 (except 15):
  //     template <bool compile_time>
  //     void TestReadSymbolN(int num_runs);
  //
  // If compile_time is true, tests
  //     int EntropyDecoder::ReadSymbol<N>(uint16_t* const cdf).
  // Otherwise, tests
  //     int EntropyDecoder::ReadSymbol(uint16_t* cdf, int symbol_count)
  // with symbol_count=N.
  //
  // NOTE: symbol_count=15 is not tested because AV1 does not use it.
  template <bool compile_time>
  void TestReadSymbol3(int num_runs);

  template <bool compile_time>
  void TestReadSymbol4(int num_runs);

  template <bool compile_time>
  void TestReadSymbol5(int num_runs);

  template <bool compile_time>
  void TestReadSymbol6(int num_runs);

  template <bool compile_time>
  void TestReadSymbol7(int num_runs);

  template <bool compile_time>
  void TestReadSymbol8(int num_runs);

  template <bool compile_time>
  void TestReadSymbol9(int num_runs);

  template <bool compile_time>
  void TestReadSymbol10(int num_runs);

  template <bool compile_time>
  void TestReadSymbol11(int num_runs);

  template <bool compile_time>
  void TestReadSymbol12(int num_runs);

  template <bool compile_time>
  void TestReadSymbol13(int num_runs);

  template <bool compile_time>
  void TestReadSymbol14(int num_runs);

  template <bool compile_time>
  void TestReadSymbol16(int num_runs);
};

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbolBoolean(int num_runs) {
  static constexpr int kSymbols[4][4] = {{0, 0, 1, 1},  //
                                         {0, 1, 1, 0},  //
                                         {1, 0, 1, 0},  //
                                         {1, 0, 0, 1}};
  absl::Duration elapsed_time;
  bool symbols[1024 * 4 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbolBoolean,
                          kNumBytesTestReadSymbolBoolean,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][3] = {
        {16384, 0, 0},
        {32768 - 8386, 0, 0},
        {32768 - 24312, 0, 0},
        {16384, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 1024; ++i) {
      for (int j = 0; j < 4; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 2) != 0;
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbolBooleanCompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbolBoolean(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 1024; ++i) {
    for (int j = 0; j < 4; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol3(int num_runs) {
  static constexpr int kSymbols[6][4] = {{0, 2, 1, 2},  //
                                         {1, 1, 2, 1},  //
                                         {2, 0, 0, 0},  //
                                         {0, 2, 0, 2},  //
                                         {1, 2, 1, 0},  //
                                         {2, 1, 1, 0}};
  absl::Duration elapsed_time;
  int symbols[1024 * 6 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol3, kNumBytesTestReadSymbol3,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][4] = {
        // pdf: 1/3, 1/3, 1/3
        {32768 - 10923, 32768 - 21845, 0, 0},
        // pdf: 1/6, 2/6, 3/6
        {32768 - 5461, 32768 - 16384, 0, 0},
        // pdf: 2/6, 3/6, 1/6
        {32768 - 10923, 32768 - 27307, 0, 0},
        // pdf: 3/6, 1/6, 2/6
        {32768 - 16384, 32768 - 21845, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 1024; ++i) {
      for (int j = 0; j < 6; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<3>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 3);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol3CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol3(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 1024; ++i) {
    for (int j = 0; j < 6; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol4(int num_runs) {
  static constexpr int kSymbols[8][4] = {{0, 0, 3, 3},  //
                                         {0, 0, 2, 2},  //
                                         {1, 1, 0, 0},  //
                                         {1, 2, 1, 1},  //
                                         {2, 2, 3, 2},  //
                                         {2, 3, 2, 1},  //
                                         {3, 3, 0, 0},  //
                                         {3, 3, 1, 1}};
  absl::Duration elapsed_time;
  int symbols[1024 * 8 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol4, kNumBytesTestReadSymbol4,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][5] = {
        // pdf: 1/4, 1/4, 1/4, 1/4
        {32768 - 8192, 32768 - 16384, 32768 - 24576, 0, 0},
        // pdf: 2/8, 1/8, 2/8, 3/8
        {32768 - 8192, 32768 - 12288, 32768 - 20480, 0, 0},
        // pdf: 1/4, 1/4, 1/4, 1/4
        {32768 - 8192, 32768 - 16384, 32768 - 24576, 0, 0},
        // pdf: 2/8, 3/8, 2/8, 1/8
        {32768 - 8192, 32768 - 20480, 32768 - 28672, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 1024; ++i) {
      for (int j = 0; j < 8; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<4>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 4);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol4CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol4(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 1024; ++i) {
    for (int j = 0; j < 8; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol5(int num_runs) {
  static constexpr int kSymbols[10][4] = {{0, 0, 4, 4},  //
                                          {0, 1, 3, 3},  //
                                          {1, 2, 2, 2},  //
                                          {1, 3, 1, 1},  //
                                          {2, 4, 0, 0},  //
                                          {2, 0, 4, 3},  //
                                          {3, 1, 3, 2},  //
                                          {3, 2, 2, 1},  //
                                          {4, 3, 1, 2},  //
                                          {4, 0, 4, 2}};
  absl::Duration elapsed_time;
  int symbols[320 * 10 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol5, kNumBytesTestReadSymbol5,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][6] = {
        // pdf: 1/5, 1/5, 1/5, 1/5, 1/5
        {32768 - 6554, 32768 - 13107, 32768 - 19661, 32768 - 26214, 0, 0},
        // pdf: 3/10, 2/10, 2/10, 2/10, 1/10
        {32768 - 9830, 32768 - 16384, 32768 - 22938, 32768 - 29491, 0, 0},
        // pdf: 1/10, 2/10, 2/10, 2/10, 3/10
        {32768 - 3277, 32768 - 9830, 32768 - 16384, 32768 - 22938, 0, 0},
        // pdf: 1/10, 2/10, 4/10, 2/10, 1/10
        {32768 - 3277, 32768 - 9830, 32768 - 22938, 32768 - 29491, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 320; ++i) {
      for (int j = 0; j < 10; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<5>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 5);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol5CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol5(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 320; ++i) {
    for (int j = 0; j < 10; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol6(int num_runs) {
  static constexpr int kSymbols[12][4] = {{0, 0, 5, 5},  //
                                          {0, 1, 4, 4},  //
                                          {1, 2, 3, 3},  //
                                          {1, 3, 2, 2},  //
                                          {2, 4, 1, 1},  //
                                          {2, 5, 0, 0},  //
                                          {3, 0, 5, 4},  //
                                          {3, 1, 4, 3},  //
                                          {4, 2, 3, 2},  //
                                          {4, 3, 2, 1},  //
                                          {5, 4, 1, 3},  //
                                          {5, 0, 5, 2}};
  absl::Duration elapsed_time;
  int symbols[256 * 12 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol6, kNumBytesTestReadSymbol6,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][7] = {
        // pmf: 1/6, 1/6, 1/6, 1/6, 1/6, 1/6
        {32768 - 5461, 32768 - 10923, 32768 - 16384, 32768 - 21845,
         32768 - 27307, 0, 0},
        // pmf: 3/12, 2/12, 2/12, 2/12, 2/12, 1/12
        {32768 - 8192, 32768 - 13653, 32768 - 19115, 32768 - 24576,
         32768 - 30037, 0, 0},
        // pmf: 1/12, 2/12, 2/12, 2/12, 2/12, 3/12
        {32768 - 2731, 32768 - 8192, 32768 - 13653, 32768 - 19115,
         32768 - 24576, 0, 0},
        // pmf: 1/12, 2/12, 3/12, 3/12, 2/12, 1/12
        {32768 - 2731, 32768 - 8192, 32768 - 16384, 32768 - 24576,
         32768 - 30037, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 256; ++i) {
      for (int j = 0; j < 12; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<6>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 6);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol6CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol6(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 256; ++i) {
    for (int j = 0; j < 12; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol7(int num_runs) {
  static constexpr int kSymbols[14][4] = {{0, 4, 6, 3},  //
                                          {1, 5, 5, 2},  //
                                          {2, 6, 4, 1},  //
                                          {3, 0, 3, 0},  //
                                          {4, 1, 2, 6},  //
                                          {5, 2, 1, 5},  //
                                          {6, 3, 0, 4},  //
                                          {0, 0, 6, 5},  //
                                          {2, 1, 4, 3},  //
                                          {4, 3, 6, 1},  //
                                          {6, 5, 2, 4},  //
                                          {1, 0, 5, 2},  //
                                          {3, 2, 3, 2},  //
                                          {5, 4, 5, 3}};
  absl::Duration elapsed_time;
  int symbols[1024 * 14 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol7, kNumBytesTestReadSymbol7,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][8] = {
        // pdf: 1/7, 1/7, 1/7, 1/7, 1/7, 1/7, 1/7
        {32768 - 4681, 32768 - 9362, 32768 - 14043, 32768 - 18725,
         32768 - 23406, 32768 - 28087, 0, 0},
        // pdf: 3/14, 2/14, 2/14, 2/14, 2/14, 2/14, 1/14
        {32768 - 7022, 32768 - 11703, 32768 - 16384, 32768 - 21065,
         32768 - 25746, 32768 - 30427, 0, 0},
        // pdf: 1/14, 1/14, 2/14, 2/14, 2/14, 3/14, 3/14
        {32768 - 2341, 32768 - 4681, 32768 - 9362, 32768 - 14043, 32768 - 18725,
         32768 - 25746, 0, 0},
        // pdf: 1/14, 2/14, 3/14, 3/14, 2/14, 2/14, 1/14
        {32768 - 2341, 32768 - 7022, 32768 - 14043, 32768 - 21065,
         32768 - 25746, 32768 - 30427, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 1024; ++i) {
      for (int j = 0; j < 14; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<7>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 7);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol7CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol7(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 1024; ++i) {
    for (int j = 0; j < 14; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol8(int num_runs) {
  static constexpr int kSymbols[16][4] = {{0, 4, 7, 3},  //
                                          {1, 5, 6, 2},  //
                                          {2, 6, 5, 1},  //
                                          {3, 7, 4, 0},  //
                                          {4, 0, 3, 7},  //
                                          {5, 1, 2, 6},  //
                                          {6, 2, 1, 5},  //
                                          {7, 3, 0, 4},  //
                                          {0, 0, 6, 5},  //
                                          {2, 1, 4, 3},  //
                                          {4, 3, 6, 4},  //
                                          {6, 5, 2, 2},  //
                                          {1, 0, 7, 3},  //
                                          {3, 2, 5, 5},  //
                                          {5, 4, 7, 2},  //
                                          {7, 6, 3, 4}};
  absl::Duration elapsed_time;
  int symbols[1024 * 16 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol8, kNumBytesTestReadSymbol8,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][9] = {
        // pdf: 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8
        {32768 - 4096, 32768 - 8192, 32768 - 12288, 32768 - 16384,
         32768 - 20480, 32768 - 24576, 32768 - 28672, 0, 0},
        // pdf: 3/16, 2/16, 2/16, 2/16, 2/16, 2/16, 2/16, 1/16
        {32768 - 6144, 32768 - 10240, 32768 - 14336, 32768 - 18432,
         32768 - 22528, 32768 - 26624, 32768 - 30720, 0, 0},
        // pdf: 1/16, 1/16, 2/16, 2/16, 2/16, 2/16, 3/16, 3/16
        {32768 - 2048, 32768 - 4096, 32768 - 8192, 32768 - 12288, 32768 - 16384,
         32768 - 20480, 32768 - 26624, 0, 0},
        // pdf: 1/16, 1/16, 3/16, 3/16, 3/16, 3/16, 1/16, 1/16
        {32768 - 2048, 32768 - 4096, 32768 - 10240, 32768 - 16384,
         32768 - 22528, 32768 - 28672, 32768 - 30720, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 1024; ++i) {
      for (int j = 0; j < 16; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<8>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 8);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol8CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol8(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 1024; ++i) {
    for (int j = 0; j < 16; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol9(int num_runs) {
  static constexpr int kSymbols[18][4] = {{0, 4, 8, 3},  //
                                          {1, 5, 7, 2},  //
                                          {2, 6, 6, 1},  //
                                          {3, 7, 5, 0},  //
                                          {4, 8, 4, 8},  //
                                          {5, 0, 3, 7},  //
                                          {6, 1, 2, 6},  //
                                          {7, 2, 1, 5},  //
                                          {8, 3, 0, 4},  //
                                          {0, 0, 8, 7},  //
                                          {2, 1, 6, 5},  //
                                          {4, 3, 4, 3},  //
                                          {6, 5, 2, 1},  //
                                          {8, 7, 7, 6},  //
                                          {1, 0, 5, 4},  //
                                          {3, 2, 3, 2},  //
                                          {5, 4, 1, 4},  //
                                          {7, 6, 8, 4}};
  absl::Duration elapsed_time;
  int symbols[128 * 18 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol9, kNumBytesTestReadSymbol9,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][10] = {
        // pmf: 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9, 1/9
        {32768 - 3641, 32768 - 7282, 32768 - 10923, 32768 - 14564,
         32768 - 18204, 32768 - 21845, 32768 - 25486, 32768 - 29127, 0, 0},
        // pmf: 3/18, 2/18, 2/18, 2/18, 2/18, 2/18, 2/18, 2/18, 1/18
        {32768 - 5461, 32768 - 9102, 32768 - 12743, 32768 - 16384,
         32768 - 20025, 32768 - 23666, 32768 - 27307, 32768 - 30948, 0, 0},
        // pmf: 1/18, 2/18, 2/18, 2/18, 2/18, 2/18, 2/18, 2/18, 3/18
        {32768 - 1820, 32768 - 5461, 32768 - 9102, 32768 - 12743, 32768 - 16384,
         32768 - 20025, 32768 - 23666, 32768 - 27307, 0, 0},
        // pmf: 1/18, 2/18, 2/18, 2/18, 4/18, 2/18, 2/18, 2/18, 1/18
        {32768 - 1820, 32768 - 5461, 32768 - 9102, 32768 - 12743, 32768 - 20025,
         32768 - 23666, 32768 - 27307, 32768 - 30948, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 128; ++i) {
      for (int j = 0; j < 18; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<9>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 9);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol9CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol9(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 128; ++i) {
    for (int j = 0; j < 18; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol10(int num_runs) {
  static constexpr int kSymbols[20][4] = {{0, 5, 9, 4},  //
                                          {1, 6, 8, 3},  //
                                          {2, 7, 7, 2},  //
                                          {3, 8, 6, 1},  //
                                          {4, 9, 5, 0},  //
                                          {5, 0, 4, 9},  //
                                          {6, 1, 3, 8},  //
                                          {7, 2, 2, 7},  //
                                          {8, 3, 1, 6},  //
                                          {9, 4, 0, 5},  //
                                          {0, 0, 9, 7},  //
                                          {2, 1, 8, 5},  //
                                          {4, 3, 6, 3},  //
                                          {6, 5, 4, 1},  //
                                          {8, 7, 2, 8},  //
                                          {1, 0, 9, 6},  //
                                          {3, 2, 7, 4},  //
                                          {5, 4, 5, 2},  //
                                          {7, 6, 3, 5},  //
                                          {9, 8, 1, 4}};
  absl::Duration elapsed_time;
  int symbols[96 * 20 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol10, kNumBytesTestReadSymbol10,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][11] = {
        // pmf: 1/10, 1/10, 1/10, 1/10, 1/10, 1/10, 1/10, 1/10, 1/10, 1/10
        {32768 - 3277, 32768 - 6554, 32768 - 9830, 32768 - 13107, 32768 - 16384,
         32768 - 19661, 32768 - 22938, 32768 - 26214, 32768 - 29491, 0, 0},
        // pmf: 3/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 1/20
        {32768 - 4915, 32768 - 8192, 32768 - 11469, 32768 - 14746,
         32768 - 18022, 32768 - 21299, 32768 - 24576, 32768 - 27853,
         32768 - 31130, 0, 0},
        // pmf: 1/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 2/20, 3/20
        {32768 - 1638, 32768 - 4915, 32768 - 8192, 32768 - 11469, 32768 - 14746,
         32768 - 18022, 32768 - 21299, 32768 - 24576, 32768 - 27853, 0, 0},
        // pmf: 1/20, 2/20, 2/20, 2/20, 3/20, 3/20, 2/20, 2/20, 2/20, 1/20
        {32768 - 1638, 32768 - 4915, 32768 - 8192, 32768 - 11469, 32768 - 16384,
         32768 - 21299, 32768 - 24576, 32768 - 27853, 32768 - 31130, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 96; ++i) {
      for (int j = 0; j < 20; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<10>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 10);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol10CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol10(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 96; ++i) {
    for (int j = 0; j < 20; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol11(int num_runs) {
  static constexpr int kSymbols[22][4] = {{0, 6, 10, 5},   //
                                          {1, 7, 9, 4},    //
                                          {2, 8, 8, 3},    //
                                          {3, 9, 7, 2},    //
                                          {4, 10, 6, 1},   //
                                          {5, 0, 5, 0},    //
                                          {6, 1, 4, 10},   //
                                          {7, 2, 3, 9},    //
                                          {8, 3, 2, 8},    //
                                          {9, 4, 1, 7},    //
                                          {10, 5, 0, 6},   //
                                          {0, 0, 10, 9},   //
                                          {2, 1, 8, 7},    //
                                          {4, 3, 6, 5},    //
                                          {6, 5, 4, 3},    //
                                          {8, 7, 2, 1},    //
                                          {10, 9, 10, 8},  //
                                          {1, 0, 9, 6},    //
                                          {3, 2, 7, 4},    //
                                          {5, 4, 5, 2},    //
                                          {7, 6, 3, 5},    //
                                          {9, 8, 1, 5}};
  absl::Duration elapsed_time;
  int symbols[96 * 22 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol11, kNumBytesTestReadSymbol11,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][12] = {
        // pmf: 1/11, 1/11, 1/11, 1/11, 1/11, 1/11, 1/11, 1/11, 1/11, 1/11, 1/11
        {32768 - 2979, 32768 - 5958, 32768 - 8937, 32768 - 11916, 32768 - 14895,
         32768 - 17873, 32768 - 20852, 32768 - 23831, 32768 - 26810,
         32768 - 29789, 0, 0},
        // pmf: 3/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 1/22
        {32768 - 4468, 32768 - 7447, 32768 - 10426, 32768 - 13405,
         32768 - 16384, 32768 - 19363, 32768 - 22342, 32768 - 25321,
         32768 - 28300, 32768 - 31279, 0, 0},
        // pmf: 1/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 2/22, 3/22
        {32768 - 1489, 32768 - 4468, 32768 - 7447, 32768 - 10426, 32768 - 13405,
         32768 - 16384, 32768 - 19363, 32768 - 22342, 32768 - 25321,
         32768 - 28300, 0, 0},
        // pmf: 1/22, 2/22, 2/22, 2/22, 2/22, 4/22, 2/22, 2/22, 2/22, 2/22, 1/22
        {32768 - 1489, 32768 - 4468, 32768 - 7447, 32768 - 10426, 32768 - 13405,
         32768 - 19363, 32768 - 22342, 32768 - 25321, 32768 - 28300,
         32768 - 31279, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 96; ++i) {
      for (int j = 0; j < 22; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<11>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 11);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol11CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol11(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 96; ++i) {
    for (int j = 0; j < 22; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol12(int num_runs) {
  static constexpr int kSymbols[24][4] = {{0, 6, 11, 5},   //
                                          {1, 7, 10, 4},   //
                                          {2, 8, 9, 3},    //
                                          {3, 9, 8, 2},    //
                                          {4, 10, 7, 1},   //
                                          {5, 11, 6, 0},   //
                                          {6, 0, 5, 11},   //
                                          {7, 1, 4, 10},   //
                                          {8, 2, 3, 9},    //
                                          {9, 3, 2, 8},    //
                                          {10, 4, 1, 7},   //
                                          {11, 5, 0, 6},   //
                                          {0, 0, 11, 9},   //
                                          {2, 1, 10, 7},   //
                                          {4, 3, 8, 5},    //
                                          {6, 5, 6, 3},    //
                                          {8, 7, 4, 1},    //
                                          {10, 9, 2, 10},  //
                                          {1, 0, 11, 8},   //
                                          {3, 2, 9, 6},    //
                                          {5, 4, 7, 4},    //
                                          {7, 6, 5, 2},    //
                                          {9, 8, 3, 6},    //
                                          {11, 10, 1, 5}};
  absl::Duration elapsed_time;
  int symbols[80 * 24 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol12, kNumBytesTestReadSymbol12,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][13] = {
        // pmf: 1/12, 1/12, 1/12, 1/12, 1/12, 1/12, 1/12, 1/12, 1/12, 1/12,
        // 1/12,
        // 1/12
        {32768 - 2731, 32768 - 5461, 32768 - 8192, 32768 - 10923, 32768 - 13653,
         32768 - 16384, 32768 - 19115, 32768 - 21845, 32768 - 24576,
         32768 - 27307, 32768 - 30037, 0, 0},
        // pmf: 3/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24,
        // 2/24,
        // 1/24
        {32768 - 4096, 32768 - 6827, 32768 - 9557, 32768 - 12288, 32768 - 15019,
         32768 - 17749, 32768 - 20480, 32768 - 23211, 32768 - 25941,
         32768 - 28672, 32768 - 31403, 0, 0},
        // pmf: 1/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24, 2/24,
        // 2/24,
        // 3/24
        {32768 - 1365, 32768 - 4096, 32768 - 6827, 32768 - 9557, 32768 - 12288,
         32768 - 15019, 32768 - 17749, 32768 - 20480, 32768 - 23211,
         32768 - 25941, 32768 - 28672, 0, 0},
        // pmf: 1/24, 2/24, 2/24, 2/24, 2/24, 3/24, 3/24, 2/24, 2/24, 2/24,
        // 2/24,
        // 1/24
        {32768 - 1365, 32768 - 4096, 32768 - 6827, 32768 - 9557, 32768 - 12288,
         32768 - 16384, 32768 - 20480, 32768 - 23211, 32768 - 25941,
         32768 - 28672, 32768 - 31403, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 80; ++i) {
      for (int j = 0; j < 24; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<12>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 12);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol12CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol12(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 80; ++i) {
    for (int j = 0; j < 24; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol13(int num_runs) {
  static constexpr int kSymbols[26][4] = {{0, 6, 12, 5},     //
                                          {1, 7, 11, 4},     //
                                          {2, 8, 10, 3},     //
                                          {3, 9, 9, 2},      //
                                          {4, 10, 8, 1},     //
                                          {5, 11, 7, 0},     //
                                          {6, 12, 6, 12},    //
                                          {7, 0, 5, 11},     //
                                          {8, 1, 4, 10},     //
                                          {9, 2, 3, 9},      //
                                          {10, 3, 2, 8},     //
                                          {11, 4, 1, 7},     //
                                          {12, 5, 0, 6},     //
                                          {0, 0, 12, 11},    //
                                          {2, 1, 10, 9},     //
                                          {4, 3, 8, 7},      //
                                          {6, 5, 6, 5},      //
                                          {8, 7, 4, 3},      //
                                          {10, 9, 2, 1},     //
                                          {12, 11, 12, 10},  //
                                          {1, 0, 11, 8},     //
                                          {3, 2, 9, 6},      //
                                          {5, 4, 7, 4},      //
                                          {7, 6, 5, 2},      //
                                          {9, 8, 3, 6},      //
                                          {11, 10, 1, 6}};
  absl::Duration elapsed_time;
  int symbols[64 * 26 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol13, kNumBytesTestReadSymbol13,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][14] = {
        // pmf: 1/13, 1/13, 1/13, 1/13, 1/13, 1/13, 1/13, 1/13, 1/13, 1/13,
        // 1/13, 1/13, 1/13
        {32768 - 2521, 32768 - 5041, 32768 - 7562, 32768 - 10082, 32768 - 12603,
         32768 - 15124, 32768 - 17644, 32768 - 20165, 32768 - 22686,
         32768 - 25206, 32768 - 27727, 32768 - 30247, 0, 0},
        // pmf: 3/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26,
        // 2/26, 2/26, 1/26
        {32768 - 3781, 32768 - 6302, 32768 - 8822, 32768 - 11343, 32768 - 13863,
         32768 - 16384, 32768 - 18905, 32768 - 21425, 32768 - 23946,
         32768 - 26466, 32768 - 28987, 32768 - 31508, 0, 0},
        // pmf: 1/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26, 2/26,
        // 2/26, 2/26, 3/26
        {32768 - 1260, 32768 - 3781, 32768 - 6302, 32768 - 8822, 32768 - 11343,
         32768 - 13863, 32768 - 16384, 32768 - 18905, 32768 - 21425,
         32768 - 23946, 32768 - 26466, 32768 - 28987, 0, 0},
        // pmf: 1/26, 2/26, 2/26, 2/26, 2/26, 2/26, 4/26, 2/26, 2/26, 2/26,
        // 2/26, 2/26, 1/26
        {32768 - 1260, 32768 - 3781, 32768 - 6302, 32768 - 8822, 32768 - 11343,
         32768 - 13863, 32768 - 18905, 32768 - 21425, 32768 - 23946,
         32768 - 26466, 32768 - 28987, 32768 - 31508, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 64; ++i) {
      for (int j = 0; j < 26; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<13>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 13);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol13CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol13(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 64; ++i) {
    for (int j = 0; j < 26; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol14(int num_runs) {
  static constexpr int kSymbols[28][4] = {{0, 7, 13, 6},    //
                                          {1, 8, 12, 5},    //
                                          {2, 9, 11, 4},    //
                                          {3, 10, 10, 3},   //
                                          {4, 11, 9, 2},    //
                                          {5, 12, 8, 1},    //
                                          {6, 13, 7, 0},    //
                                          {7, 0, 6, 13},    //
                                          {8, 1, 5, 12},    //
                                          {9, 2, 4, 11},    //
                                          {10, 3, 3, 10},   //
                                          {11, 4, 2, 9},    //
                                          {12, 5, 1, 8},    //
                                          {13, 6, 0, 7},    //
                                          {0, 0, 13, 11},   //
                                          {2, 1, 12, 9},    //
                                          {4, 3, 10, 7},    //
                                          {6, 5, 8, 5},     //
                                          {8, 7, 6, 3},     //
                                          {10, 9, 4, 1},    //
                                          {12, 11, 2, 12},  //
                                          {1, 0, 13, 10},   //
                                          {3, 2, 11, 8},    //
                                          {5, 4, 9, 6},     //
                                          {7, 6, 7, 4},     //
                                          {9, 8, 5, 2},     //
                                          {11, 10, 3, 7},   //
                                          {13, 12, 1, 6}};
  absl::Duration elapsed_time;
  int symbols[64 * 28 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol14, kNumBytesTestReadSymbol14,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][15] = {
        // pmf: 1/14, 1/14, 1/14, 1/14, 1/14, 1/14, 1/14, 1/14, 1/14, 1/14,
        // 1/14, 1/14, 1/14, 1/14
        {32768 - 2341, 32768 - 4681, 32768 - 7022, 32768 - 9362, 32768 - 11703,
         32768 - 14043, 32768 - 16384, 32768 - 18725, 32768 - 21065,
         32768 - 23406, 32768 - 25746, 32768 - 28087, 32768 - 30427, 0, 0},
        // pmf: 3/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28,
        // 2/28, 2/28, 2/28, 1/28
        {32768 - 3511, 32768 - 5851, 32768 - 8192, 32768 - 10533, 32768 - 12873,
         32768 - 15214, 32768 - 17554, 32768 - 19895, 32768 - 22235,
         32768 - 24576, 32768 - 26917, 32768 - 29257, 32768 - 31598, 0, 0},
        // pmf: 1/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28, 2/28,
        // 2/28, 2/28, 2/28, 3/28
        {32768 - 1170, 32768 - 3511, 32768 - 5851, 32768 - 8192, 32768 - 10533,
         32768 - 12873, 32768 - 15214, 32768 - 17554, 32768 - 19895,
         32768 - 22235, 32768 - 24576, 32768 - 26917, 32768 - 29257, 0, 0},
        // pmf: 1/28, 2/28, 2/28, 2/28, 2/28, 2/28, 3/28, 3/28, 2/28, 2/28,
        // 2/28, 2/28, 2/28, 1/28
        {32768 - 1170, 32768 - 3511, 32768 - 5851, 32768 - 8192, 32768 - 10533,
         32768 - 12873, 32768 - 16384, 32768 - 19895, 32768 - 22235,
         32768 - 24576, 32768 - 26917, 32768 - 29257, 32768 - 31598, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 64; ++i) {
      for (int j = 0; j < 28; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<14>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 14);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol14CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol14(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 64; ++i) {
    for (int j = 0; j < 28; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

template <bool compile_time>
void EntropyDecoderTest::TestReadSymbol16(int num_runs) {
  static constexpr int kSymbols[32][4] = {{0, 8, 15, 7},    //
                                          {1, 9, 14, 6},    //
                                          {2, 10, 13, 5},   //
                                          {3, 11, 12, 4},   //
                                          {4, 12, 11, 3},   //
                                          {5, 13, 10, 2},   //
                                          {6, 14, 9, 1},    //
                                          {7, 15, 8, 0},    //
                                          {8, 0, 7, 15},    //
                                          {9, 1, 6, 14},    //
                                          {10, 2, 5, 13},   //
                                          {11, 3, 4, 12},   //
                                          {12, 4, 3, 11},   //
                                          {13, 5, 2, 10},   //
                                          {14, 6, 1, 9},    //
                                          {15, 7, 0, 8},    //
                                          {0, 0, 15, 13},   //
                                          {2, 1, 14, 11},   //
                                          {4, 3, 12, 9},    //
                                          {6, 5, 10, 7},    //
                                          {8, 7, 8, 5},     //
                                          {10, 9, 6, 3},    //
                                          {12, 11, 4, 1},   //
                                          {14, 13, 2, 14},  //
                                          {1, 0, 15, 12},   //
                                          {3, 2, 13, 10},   //
                                          {5, 4, 11, 8},    //
                                          {7, 6, 9, 6},     //
                                          {9, 8, 7, 4},     //
                                          {11, 10, 5, 2},   //
                                          {13, 12, 3, 8},   //
                                          {15, 14, 1, 7}};
  absl::Duration elapsed_time;
  int symbols[48 * 32 * 4];
  for (int run = 0; run < num_runs; ++run) {
    EntropyDecoder reader(kBytesTestReadSymbol16, kNumBytesTestReadSymbol16,
                          /*allow_update_cdf=*/true);
    uint16_t cdf[4][17] = {
        // pmf: 1/16, 1/16, 1/16, 1/16, 1/16, 1/16, 1/16, 1/16, 1/16, 1/16,
        // 1/16, 1/16, 1/16, 1/16, 1/16, 1/16
        {32768 - 2048, 32768 - 4096, 32768 - 6144, 32768 - 8192, 32768 - 10240,
         32768 - 12288, 32768 - 14336, 32768 - 16384, 32768 - 18432,
         32768 - 20480, 32768 - 22528, 32768 - 24576, 32768 - 26624,
         32768 - 28672, 32768 - 30720, 0, 0},
        // pmf: 3/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32,
        // 2/32, 2/32, 2/32, 2/32, 2/32, 1/32
        {32768 - 3072, 32768 - 5120, 32768 - 7168, 32768 - 9216, 32768 - 11264,
         32768 - 13312, 32768 - 15360, 32768 - 17408, 32768 - 19456,
         32768 - 21504, 32768 - 23552, 32768 - 25600, 32768 - 27648,
         32768 - 29696, 32768 - 31744, 0, 0},
        // pmf: 1/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32,
        // 2/32, 2/32, 2/32, 2/32, 2/32, 3/32
        {32768 - 1024, 32768 - 3072, 32768 - 5120, 32768 - 7168, 32768 - 9216,
         32768 - 11264, 32768 - 13312, 32768 - 15360, 32768 - 17408,
         32768 - 19456, 32768 - 21504, 32768 - 23552, 32768 - 25600,
         32768 - 27648, 32768 - 29696, 0, 0},
        // pmf: 1/32, 2/32, 2/32, 2/32, 2/32, 2/32, 2/32, 3/32, 3/32, 2/32,
        // 2/32, 2/32, 2/32, 2/32, 2/32, 1/32
        {32768 - 1024, 32768 - 3072, 32768 - 5120, 32768 - 7168, 32768 - 9216,
         32768 - 11264, 32768 - 13312, 32768 - 16384, 32768 - 19456,
         32768 - 21504, 32768 - 23552, 32768 - 25600, 32768 - 27648,
         32768 - 29696, 32768 - 31744, 0, 0},
    };
    const absl::Time start = absl::Now();
    int index = 0;
    for (int i = 0; i < 48; ++i) {
      for (int j = 0; j < 32; ++j) {
        for (int k = 0; k < 4; ++k) {  // NOLINT(modernize-loop-convert)
          if (compile_time) {
            symbols[index++] = reader.ReadSymbol<16>(cdf[k]);
          } else {
            symbols[index++] = reader.ReadSymbol(cdf[k], 16);
          }
        }
      }
    }
    elapsed_time += absl::Now() - start;
  }
  if (compile_time) {
    printf("TestReadSymbol16CompileTime(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  } else {
    printf("TestReadSymbol16(%d): %5d us\n", num_runs,
           static_cast<int>(absl::ToInt64Microseconds(elapsed_time)));
  }

  int index = 0;
  for (int i = 0; i < 48; ++i) {
    for (int j = 0; j < 32; ++j) {  // NOLINT(modernize-loop-convert)
      for (int k = 0; k < 4; ++k) {
        ASSERT_EQ(symbols[index++], kSymbols[j][k]);
      }
    }
  }
}

TEST_F(EntropyDecoderTest, ReadSymbolBoolean) {
  TestReadSymbolBoolean</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbolBooleanCompileTime) {
  TestReadSymbolBoolean</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol3) {
  TestReadSymbol3</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol3CompileTime) {
  TestReadSymbol3</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol4) {
  TestReadSymbol4</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol4CompileTime) {
  TestReadSymbol4</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol5) {
  TestReadSymbol5</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol5CompileTime) {
  TestReadSymbol5</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol6) {
  TestReadSymbol6</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol6CompileTime) {
  TestReadSymbol6</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol7) {
  TestReadSymbol7</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol7CompileTime) {
  TestReadSymbol7</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol8) {
  TestReadSymbol8</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol8CompileTime) {
  TestReadSymbol8</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol9) {
  TestReadSymbol9</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol9CompileTime) {
  TestReadSymbol9</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol10) {
  TestReadSymbol10</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol10CompileTime) {
  TestReadSymbol10</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol11) {
  TestReadSymbol11</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol11CompileTime) {
  TestReadSymbol11</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol12) {
  TestReadSymbol12</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol12CompileTime) {
  TestReadSymbol12</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol13) {
  TestReadSymbol13</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol13CompileTime) {
  TestReadSymbol13</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol14) {
  TestReadSymbol14</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol14CompileTime) {
  TestReadSymbol14</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol16) {
  TestReadSymbol16</*compile_time=*/false>(1);
}

TEST_F(EntropyDecoderTest, ReadSymbol16CompileTime) {
  TestReadSymbol16</*compile_time=*/true>(1);
}

TEST_F(EntropyDecoderTest, DISABLED_Speed) {
  // compile_time=true is only tested for those symbol_count values that have
  // an instantiation of the EntropyDecoder::ReadSymbol<symbol_count> template
  // method.
  TestReadSymbolBoolean</*compile_time=*/false>(10000);
  TestReadSymbolBoolean</*compile_time=*/true>(10000);
  TestReadSymbol3</*compile_time=*/false>(5000);
  TestReadSymbol3</*compile_time=*/true>(5000);
  TestReadSymbol4</*compile_time=*/false>(2000);
  TestReadSymbol4</*compile_time=*/true>(2000);
  TestReadSymbol5</*compile_time=*/false>(5000);
  TestReadSymbol5</*compile_time=*/true>(5000);
  TestReadSymbol6</*compile_time=*/false>(5000);
  TestReadSymbol6</*compile_time=*/true>(5000);
  TestReadSymbol7</*compile_time=*/false>(1000);
  TestReadSymbol7</*compile_time=*/true>(1000);
  TestReadSymbol8</*compile_time=*/false>(1000);
  TestReadSymbol8</*compile_time=*/true>(1000);
  TestReadSymbol9</*compile_time=*/false>(5000);
  TestReadSymbol9</*compile_time=*/true>(5000);
  TestReadSymbol10</*compile_time=*/false>(5000);
  TestReadSymbol10</*compile_time=*/true>(5000);
  TestReadSymbol11</*compile_time=*/false>(5000);
  TestReadSymbol11</*compile_time=*/true>(5000);
  TestReadSymbol12</*compile_time=*/false>(5000);
  TestReadSymbol12</*compile_time=*/true>(5000);
  TestReadSymbol13</*compile_time=*/false>(5000);
  TestReadSymbol13</*compile_time=*/true>(5000);
  TestReadSymbol14</*compile_time=*/false>(5000);
  TestReadSymbol14</*compile_time=*/true>(5000);
  TestReadSymbol16</*compile_time=*/false>(5000);
  TestReadSymbol16</*compile_time=*/true>(5000);
}

}  // namespace
}  // namespace libgav1