Remove frame counts in decoding coefs area

Continued to remove count accumulation in decoder for decoder speedup.

Change-Id: I9e3b874bfc5f750297070235bdfc4d71526ed665

av1/av1.cmake

@@ -81,8 +81,7 @@ set(AOM_AV1_DECODER_SOURCES
     "${AOM_ROOT}/av1/decoder/detokenize.c"
     "${AOM_ROOT}/av1/decoder/detokenize.h"
     "${AOM_ROOT}/av1/decoder/dthread.c"
-    "${AOM_ROOT}/av1/decoder/dthread.h"
-    "${AOM_ROOT}/av1/decoder/symbolrate.h")
+    "${AOM_ROOT}/av1/decoder/dthread.h")
 
 if (CONFIG_OBU)
   list(APPEND AOM_AV1_DECODER_SOURCES

av1/common/entropymode.h

@@ -250,12 +250,6 @@ typedef struct FRAME_COUNTS {
                                    [SIG_COEF_CONTEXTS_EOB][NUM_BASE_LEVELS + 1];
 #endif  // CONFIG_LV_MAP
 
-#if CONFIG_SYMBOLRATE
-  unsigned int superblock_num;
-  unsigned int coeff_num[COEFF_LEVELS];  // 0: zero coeff 1: non-zero coeff
-  unsigned int symbol_num[2];  // 0: entropy symbol 1: non-entropy symbol
-#endif
-
   unsigned int newmv_mode[NEWMV_MODE_CONTEXTS][2];
   unsigned int zeromv_mode[GLOBALMV_MODE_CONTEXTS][2];
   unsigned int refmv_mode[REFMV_MODE_CONTEXTS][2];

av1/common/enums.h

@@ -551,9 +551,6 @@ typedef enum ATTRIBUTE_PACKED {
   FILTER_INTRA_MODES,
 } FILTER_INTRA_MODE;
 #endif  // CONFIG_FILTER_INTRA
-#if CONFIG_SYMBOLRATE
-#define COEFF_LEVELS 18
-#endif
 
 #define DIRECTIONAL_MODES 8
 #define MAX_ANGLE_DELTA 3

av1/decoder/decodeframe.c

@@ -53,7 +53,7 @@
 #include "av1/common/seg_common.h"
 #include "av1/common/thread_common.h"
 #include "av1/common/tile_common.h"
-
+#include "av1/common/warped_motion.h"
 #include "av1/decoder/decodeframe.h"
 #include "av1/decoder/decodemv.h"
 #include "av1/decoder/decoder.h"
@@ -61,9 +61,6 @@
 #include "av1/decoder/decodetxb.h"
 #endif
 #include "av1/decoder/detokenize.h"
-#include "av1/decoder/symbolrate.h"
-
-#include "av1/common/warped_motion.h"
 
 #define MAX_AV1_HEADER_SIZE 80
 #define ACCT_STR __func__
@@ -2023,10 +2020,7 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
       td->cm = cm;
       td->xd = pbi->mb;
       td->xd.corrupted = 0;
-      td->xd.counts =
-          cm->refresh_frame_context == REFRESH_FRAME_CONTEXT_BACKWARD
-              ? &cm->counts
-              : NULL;
+      td->xd.counts = NULL;
       av1_zero(td->dqcoeff);
       av1_tile_init(&td->xd.tile, td->cm, tile_row, tile_col);
       setup_bool_decoder(buf->data, data_end, buf->size, &cm->error,
@@ -2096,9 +2090,6 @@ static const uint8_t *decode_tiles(AV1Decoder *pbi, const uint8_t *data,
 
         for (int mi_col = tile_info.mi_col_start; mi_col < tile_info.mi_col_end;
              mi_col += cm->mib_size) {
-#if CONFIG_SYMBOLRATE
-          av1_record_superblock(td->xd.counts);
-#endif
           decode_partition(pbi, &td->xd, mi_row, mi_col, &td->bit_reader,
                            cm->sb_size);
         }
@@ -3622,9 +3613,6 @@ void av1_decode_tg_tiles_and_wrapup(AV1Decoder *pbi, const uint8_t *data,
           num_bwd_ctxs * sizeof(&pbi->tile_data[0].tctx.partition_cdf[0][0]));
       make_update_tile_list_dec(pbi, cm->largest_tile_id, num_bwd_ctxs,
                                 tile_ctxs);
-#if CONFIG_SYMBOLRATE
-      av1_dump_symbol_rate(cm);
-#endif
       av1_average_tile_coef_cdfs(pbi->common.fc, tile_ctxs, cdf_ptrs,
                                  num_bwd_ctxs);
       av1_average_tile_intra_cdfs(pbi->common.fc, tile_ctxs, cdf_ptrs,

av1/decoder/decodetxb.c

@@ -15,20 +15,16 @@
 #include "av1/common/txb_common.h"
 #include "av1/decoder/decodemv.h"
 #include "av1/decoder/decodetxb.h"
-#include "av1/decoder/symbolrate.h"
 
 #define ACCT_STR __func__
 
-static int read_golomb(MACROBLOCKD *xd, aom_reader *r, FRAME_COUNTS *counts) {
-#if !CONFIG_SYMBOLRATE
-  (void)counts;
-#endif
+static int read_golomb(MACROBLOCKD *xd, aom_reader *r) {
   int x = 1;
   int length = 0;
   int i = 0;
 
   while (!i) {
-    i = av1_read_record_bit(counts, r, ACCT_STR);
+    i = aom_read_bit(r, ACCT_STR);
     ++length;
     if (length >= 32) {
       aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
@@ -39,7 +35,7 @@ static int read_golomb(MACROBLOCKD *xd, aom_reader *r, FRAME_COUNTS *counts) {
 
   for (i = 0; i < length - 1; ++i) {
     x <<= 1;
-    x += av1_read_record_bit(counts, r, ACCT_STR);
+    x += aom_read_bit(r, ACCT_STR);
   }
 
   return x - 1;
@@ -66,11 +62,6 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
                             const TXB_CTX *const txb_ctx, const TX_SIZE tx_size,
                             int16_t *const max_scan_line, int *const eob) {
   FRAME_CONTEXT *const ec_ctx = xd->tile_ctx;
-#if TXCOEFF_TIMER
-  FRAME_COUNTS *const counts = NULL;
-#else
-  FRAME_COUNTS *const counts = xd->counts;
-#endif
   const int32_t max_value = (1 << (7 + xd->bd)) - 1;
   const int32_t min_value = -(1 << (7 + xd->bd));
   const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
@@ -136,79 +127,49 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
   const int eob_multi_ctx = (tx_type_to_class[tx_type] == TX_CLASS_2D) ? 0 : 1;
   switch (eob_multi_size) {
     case 0:
-      eob_pt = av1_read_record_symbol(
-                   counts, r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx],
-                   5, ACCT_STR) +
-               1;
+      eob_pt =
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx],
+                          5, ACCT_STR) +
+          1;
       break;
     case 1:
-      eob_pt = av1_read_record_symbol(
-                   counts, r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx],
-                   6, ACCT_STR) +
-               1;
+      eob_pt =
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx],
+                          6, ACCT_STR) +
+          1;
       break;
     case 2:
-      eob_pt = av1_read_record_symbol(
-                   counts, r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx],
-                   7, ACCT_STR) +
-               1;
+      eob_pt =
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx],
+                          7, ACCT_STR) +
+          1;
       break;
     case 3:
       eob_pt =
-          av1_read_record_symbol(
-              counts, r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx], 8,
-              ACCT_STR) +
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx],
+                          8, ACCT_STR) +
           1;
       break;
     case 4:
       eob_pt =
-          av1_read_record_symbol(
-              counts, r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx], 9,
-              ACCT_STR) +
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx],
+                          9, ACCT_STR) +
           1;
       break;
     case 5:
       eob_pt =
-          av1_read_record_symbol(
-              counts, r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx], 10,
-              ACCT_STR) +
+          aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx],
+                          10, ACCT_STR) +
           1;
       break;
     case 6:
     default:
-      eob_pt =
-          av1_read_record_symbol(
-              counts, r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx],
-              11, ACCT_STR) +
-          1;
+      eob_pt = aom_read_symbol(
+                   r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx], 11,
+                   ACCT_STR) +
+               1;
       break;
   }
-  if (counts) {
-    switch (eob_multi_size) {
-      case 0:
-        ++counts->eob_multi16[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 1:
-        ++counts->eob_multi32[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 2:
-        ++counts->eob_multi64[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 3:
-        ++counts->eob_multi128[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 4:
-        ++counts->eob_multi256[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 5:
-        ++counts->eob_multi512[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-      case 6:
-      default:
-        ++counts->eob_multi1024[plane_type][eob_multi_ctx][eob_pt - 1];
-        break;
-    }
-  }
 
   // printf("Dec: ");
   if (k_eob_offset_bits[eob_pt] > 0) {
@@ -220,7 +181,7 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
     }
 
     for (int i = 1; i < k_eob_offset_bits[eob_pt]; i++) {
-      bit = av1_read_record_bit(counts, r, ACCT_STR);
+      bit = aom_read_bit(r, ACCT_STR);
       // printf("eob_bit:\n");
       if (bit) {
         eob_extra += (1 << (k_eob_offset_bits[eob_pt] - 1 - i));
@@ -245,16 +206,8 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
       cdf = ec_ctx->coeff_base_cdf[txs_ctx][plane_type][coeff_ctx];
       nsymbs = 4;
     }
-    const int level = av1_read_record_symbol(counts, r, cdf, nsymbs, ACCT_STR) +
-                      (c == *eob - 1);
-    if (counts) {
-      if (c == *eob - 1) {
-        ++counts
-              ->coeff_base_eob_multi[txs_ctx][plane_type][coeff_ctx][level - 1];
-      } else {
-        ++counts->coeff_base_multi[txs_ctx][plane_type][coeff_ctx][level];
-      }
-    }
+    const int level =
+        aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + (c == *eob - 1);
 
     // printf("base_cdf: %d %d %2d\n", txs_ctx, plane_type, coeff_ctx);
     // printf("base_cdf: %d %d %2d : %3d %3d %3d\n", txs_ctx, plane_type,
@@ -297,7 +250,7 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
       *sign = aom_read_symbol(r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx],
                               2, ACCT_STR);
     } else {
-      *sign = av1_read_record_bit(counts, r, ACCT_STR);
+      *sign = aom_read_bit(r, ACCT_STR);
     }
     if (*sign) tcoeffs[pos] = -tcoeffs[pos];
   }
@@ -317,17 +270,10 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
       ctx = get_br_ctx(levels, pos, bwl, level_counts[pos]);
 #endif
       for (idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) {
-        int k = av1_read_record_symbol(
-            counts, r,
-            ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][ctx],
+        int k = aom_read_symbol(
+            r, ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][ctx],
             BR_CDF_SIZE, ACCT_STR);
         *level += k;
-        if (counts) {
-          for (int lps = 0; lps < BR_CDF_SIZE - 1; lps++)
-            if (lps == k) break;
-          ++counts->coeff_lps_multi[AOMMIN(txs_ctx, TX_32X32)][plane_type][ctx]
-                                   [k];
-        }
         if (k < BR_CDF_SIZE - 1) break;
       }
       if (*level <= NUM_BASE_LEVELS + COEFF_BASE_RANGE) {
@@ -352,7 +298,7 @@ uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *const xd,
       // decode 0-th order Golomb code
       *level = COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS;
       // Save golomb in tcoeffs because adding it to level may incur overflow
-      tran_low_t t = *level + read_golomb(xd, r, counts);
+      tran_low_t t = *level + read_golomb(xd, r);
       cul_level += (int)t;
 #if CONFIG_NEW_QUANT
 #if CONFIG_AOM_QM

av1/decoder/detokenize.c

@@ -20,48 +20,37 @@
 #include "av1/common/common.h"
 #include "av1/common/entropy.h"
 #include "av1/common/idct.h"
-#include "av1/decoder/symbolrate.h"
 
-static INLINE int read_coeff(FRAME_COUNTS *counts,
-                             const aom_cdf_prob *const *cdf, int n,
+static INLINE int read_coeff(const aom_cdf_prob *const *cdf, int n,
                              aom_reader *r) {
-#if !CONFIG_SYMBOLRATE
-  (void)counts;
-#endif
   int val = 0;
   int i = 0;
   int count = 0;
   while (count < n) {
     const int size = AOMMIN(n - count, 4);
-    val |= av1_read_record_cdf(counts, r, cdf[i++], 1 << size, ACCT_STR)
-           << count;
+    val |= aom_read_cdf(r, cdf[i++], 1 << size, ACCT_STR) << count;
     count += size;
   }
   return val;
 }
 
-static int token_to_value(FRAME_COUNTS *counts, aom_reader *const r, int token,
-                          TX_SIZE tx_size, int bit_depth) {
+static int token_to_value(aom_reader *const r, int token, TX_SIZE tx_size,
+                          int bit_depth) {
   switch (token) {
     case ZERO_TOKEN:
     case ONE_TOKEN:
     case TWO_TOKEN:
     case THREE_TOKEN:
     case FOUR_TOKEN: return token;
-    case CATEGORY1_TOKEN:
-      return CAT1_MIN_VAL + read_coeff(counts, av1_cat1_cdf, 1, r);
-    case CATEGORY2_TOKEN:
-      return CAT2_MIN_VAL + read_coeff(counts, av1_cat2_cdf, 2, r);
-    case CATEGORY3_TOKEN:
-      return CAT3_MIN_VAL + read_coeff(counts, av1_cat3_cdf, 3, r);
-    case CATEGORY4_TOKEN:
-      return CAT4_MIN_VAL + read_coeff(counts, av1_cat4_cdf, 4, r);
-    case CATEGORY5_TOKEN:
-      return CAT5_MIN_VAL + read_coeff(counts, av1_cat5_cdf, 5, r);
+    case CATEGORY1_TOKEN: return CAT1_MIN_VAL + read_coeff(av1_cat1_cdf, 1, r);
+    case CATEGORY2_TOKEN: return CAT2_MIN_VAL + read_coeff(av1_cat2_cdf, 2, r);
+    case CATEGORY3_TOKEN: return CAT3_MIN_VAL + read_coeff(av1_cat3_cdf, 3, r);
+    case CATEGORY4_TOKEN: return CAT4_MIN_VAL + read_coeff(av1_cat4_cdf, 4, r);
+    case CATEGORY5_TOKEN: return CAT5_MIN_VAL + read_coeff(av1_cat5_cdf, 5, r);
     case CATEGORY6_TOKEN: {
       const int skip_bits =
           CAT6_BIT_SIZE - av1_get_cat6_extrabits_size(tx_size, bit_depth);
-      return CAT6_MIN_VAL + read_coeff(counts, av1_cat6_cdf, 18 - skip_bits, r);
+      return CAT6_MIN_VAL + read_coeff(av1_cat6_cdf, 18 - skip_bits, r);
     }
     default:
       assert(0);  // Invalid token.
@@ -124,10 +113,9 @@ static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff,
     dqv_val = &dq_val[band != 0][0];
 #endif  // CONFIG_NEW_QUANT && !CONFIG_AOM_QM
 
-    comb_token = last_pos ? 2 * av1_read_record_bit(xd->counts, r, ACCT_STR) + 2
-                          : av1_read_record_symbol(
-                                xd->counts, r, coef_head_cdfs[band][ctx],
-                                HEAD_TOKENS + first_pos, ACCT_STR) +
+    comb_token = last_pos ? 2 * aom_read_bit(r, ACCT_STR) + 2
+                          : aom_read_symbol(r, coef_head_cdfs[band][ctx],
+                                            HEAD_TOKENS + first_pos, ACCT_STR) +
                                 !first_pos;
     if (first_pos) {
       if (comb_token == 0) return 0;
@@ -137,9 +125,6 @@ static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff,
     while (!token) {
       *max_scan_line = AOMMAX(*max_scan_line, scan[c]);
       token_cache[scan[c]] = 0;
-#if CONFIG_SYMBOLRATE
-      av1_record_coeff(xd->counts, 0);
-#endif
       ++c;
       dqv = dq[1];
       ctx = get_coef_context(nb, token_cache, c);
@@ -147,20 +132,18 @@ static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff,
 
       last_pos = (c + 1 == max_eob);
 
-      comb_token =
-          last_pos
-              ? 2 * av1_read_record_bit(xd->counts, r, ACCT_STR) + 2
-              : av1_read_record_symbol(xd->counts, r, coef_head_cdfs[band][ctx],
-                                       HEAD_TOKENS, ACCT_STR) +
-                    1;
+      comb_token = last_pos ? 2 * aom_read_bit(r, ACCT_STR) + 2
+                            : aom_read_symbol(r, coef_head_cdfs[band][ctx],
+                                              HEAD_TOKENS, ACCT_STR) +
+                                  1;
       token = comb_token >> 1;
     }
 
     more_data = comb_token & 1;
 
     if (token > ONE_TOKEN)
-      token += av1_read_record_symbol(xd->counts, r, coef_tail_cdfs[band][ctx],
-                                      TAIL_TOKENS, ACCT_STR);
+      token +=
+          aom_read_symbol(r, coef_tail_cdfs[band][ctx], TAIL_TOKENS, ACCT_STR);
 #if CONFIG_NEW_QUANT && !CONFIG_AOM_QM
     dqv_val = &dq_val[band != 0][0];
 #endif  // CONFIG_NEW_QUANT && !CONFIG_AOM_QM
@@ -168,11 +151,7 @@ static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff,
     *max_scan_line = AOMMAX(*max_scan_line, scan[c]);
     token_cache[scan[c]] = av1_pt_energy_class[token];
 
-    val = token_to_value(xd->counts, r, token, tx_size, xd->bd);
-#if CONFIG_SYMBOLRATE
-    av1_record_coeff(xd->counts, val);
-#endif
-
+    val = token_to_value(r, token, tx_size, xd->bd);
 #if CONFIG_AOM_QM
     // Apply quant matrix only for 2D transforms
     if (IS_2D_TRANSFORM(tx_type) && iqmatrix != NULL)
@@ -189,8 +168,7 @@ static int decode_coefs(MACROBLOCKD *xd, PLANE_TYPE type, tran_low_t *dqcoeff,
     v = (int)(((int64_t)val * dqv) >> dq_shift);
 #endif
 
-    v = (int)check_range(av1_read_record_bit(xd->counts, r, ACCT_STR) ? -v : v,
-                         xd->bd);
+    v = (int)check_range(aom_read_bit(r, ACCT_STR) ? -v : v, xd->bd);
 
     dqcoeff[scan[c]] = v;
 

av1/decoder/symbolrate.h

-/*
- * Copyright (c) 2017, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include "aom_dsp/bitreader.h"
-#include "av1/common/enums.h"
-
-#ifndef AV1_DECODER_SYMBOLRATE_H_
-#define AV1_DECODER_SYMBOLRATE_H_
-
-#if CONFIG_SYMBOLRATE
-static INLINE void av1_dump_symbol_rate(struct AV1Common *cm) {
-  const FRAME_COUNTS *counts = &cm->counts;
-  printf("fidx %d show %d superblock_num %d\n", cm->current_video_frame,
-         cm->show_frame, counts->superblock_num);
-  printf("%d %d\n", counts->symbol_num[0], counts->symbol_num[1]);
-  for (int i = 0; i < COEFF_LEVELS; ++i) printf("%d ", counts->coeff_num[i]);
-  printf("\n");
-}
-static INLINE int av1_read_record_symbol(FRAME_COUNTS *counts, aom_reader *r,
-                                         aom_cdf_prob *cdf, int nsymbs,
-                                         const char *str) {
-  (void)str;
-  if (counts) ++counts->symbol_num[0];
-  return aom_read_symbol(r, cdf, nsymbs, str);
-}
-
-#if CONFIG_LV_MAP
-static INLINE int av1_read_record_bin(FRAME_COUNTS *counts, aom_reader *r,
-                                      aom_cdf_prob *cdf, int nsymbs,
-                                      const char *str) {
-  (void)str;
-  if (counts) ++counts->symbol_num[0];
-  return aom_read_bin(r, cdf, nsymbs, str);
-}
-
-#endif
-
-static INLINE int av1_read_record(FRAME_COUNTS *counts, aom_reader *r, int prob,
-                                  const char *str) {
-  (void)str;
-  if (counts) ++counts->symbol_num[0];
-  return aom_read(r, prob, str);
-}
-
-static INLINE int av1_read_record_cdf(FRAME_COUNTS *counts, aom_reader *r,
-                                      const aom_cdf_prob *cdf, int nsymbs,
-                                      const char *str) {
-  (void)str;
-  if (counts) ++counts->symbol_num[0];
-  return aom_read_cdf(r, cdf, nsymbs, str);
-}
-
-static INLINE int av1_read_record_bit(FRAME_COUNTS *counts, aom_reader *r,
-                                      const char *str) {
-  (void)str;
-  if (counts) ++counts->symbol_num[1];
-  return aom_read_bit(r, str);
-}
-
-static INLINE void av1_record_coeff(FRAME_COUNTS *counts, tran_low_t qcoeff) {
-  assert(qcoeff >= 0);
-  int abs_qc = abs(qcoeff);
-  abs_qc = clamp(abs_qc, 0, COEFF_LEVELS - 1);
-  if (counts) ++counts->coeff_num[abs_qc];
-}
-
-static INLINE void av1_record_superblock(FRAME_COUNTS *counts) {
-  if (counts) ++counts->superblock_num;
-}
-#else  // CONFIG_SYMBOLRATE
-
-#define av1_read_record_symbol(counts, r, cdf, nsymbs, ACCT_STR_NAME) \
-  aom_read_symbol(r, cdf, nsymbs, ACCT_STR_NAME)
-
-#if CONFIG_LV_MAP
-#define av1_read_record_bin(counts, r, cdf, nsymbs, ACCT_STR_NAME) \
-  aom_read_bin(r, cdf, nsymbs, ACCT_STR_NAME)
-#define av1_read_record_symbol4(counts, r, cdf, nsymbs, ACCT_STR_NAME) \
-  aom_read_symbol4(r, cdf, nsymbs, ACCT_STR_NAME)
-#endif
-
-#define av1_read_record(counts, r, prob, ACCT_STR_NAME) \
-  aom_read(r, prob, ACCT_STR_NAME)
-
-#define av1_read_record_cdf(counts, r, cdf, nsymbs, ACCT_STR_NAME) \
-  aom_read_cdf(r, cdf, nsymbs, ACCT_STR_NAME)
-
-#define av1_read_record_bit(counts, r, ACCT_STR_NAME) \
-  aom_read_bit(r, ACCT_STR_NAME)
-
-#endif  // CONFIG_SYMBOLRATE
-
-#endif  // AV1_DECODER_SYMBOLRATE_H_

build/cmake/aom_config_defaults.cmake

@@ -85,7 +85,6 @@ set(CONFIG_LOWBITDEPTH 1 CACHE NUMBER "Enables low bit depth support.")
 set(CONFIG_REALTIME_ONLY 0 CACHE NUMBER "Support only realtime encodes.")
 set(CONFIG_SIZE_LIMIT 0 CACHE NUMBER "Limit max decode width/height.")
 set(CONFIG_SPATIAL_RESAMPLING 1 CACHE NUMBER "Spatial resampling.")
-set(CONFIG_SYMBOLRATE 0 CACHE NUMBER "Enables symbol rate accounting.")
 
 # AV1 experiment flags.
 set(CONFIG_AMVR 0 CACHE NUMBER "AV1 experiment flag.")