rdopt.h 10.6 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
Yaowu Xu's avatar
Yaowu Xu committed
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
Yaowu Xu's avatar
Yaowu Xu committed
4 5 6 7 8 9
 * 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.
Jingning Han's avatar
Jingning Han committed
10 11
 */

Yaowu Xu's avatar
Yaowu Xu committed
12 13
#ifndef AV1_ENCODER_RDOPT_H_
#define AV1_ENCODER_RDOPT_H_
Jingning Han's avatar
Jingning Han committed
14

15
#include "av1/common/blockd.h"
Linfeng Zhang's avatar
Linfeng Zhang committed
16 17 18
#if CONFIG_LV_MAP
#include "av1/common/txb_common.h"
#endif
Jingning Han's avatar
Jingning Han committed
19

20 21
#include "av1/encoder/block.h"
#include "av1/encoder/context_tree.h"
Linfeng Zhang's avatar
Linfeng Zhang committed
22 23 24 25
#include "av1/encoder/encoder.h"
#if CONFIG_LV_MAP
#include "av1/encoder/encodetxb.h"
#endif
Jingning Han's avatar
Jingning Han committed
26 27 28 29 30 31 32

#ifdef __cplusplus
extern "C" {
#endif

struct TileInfo;
struct macroblock;
Angie Chiang's avatar
Angie Chiang committed
33
struct RD_STATS;
Jingning Han's avatar
Jingning Han committed
34

35 36 37 38
#if CONFIG_RD_DEBUG
static INLINE void av1_update_txb_coeff_cost(RD_STATS *rd_stats, int plane,
                                             TX_SIZE tx_size, int blk_row,
                                             int blk_col, int txb_coeff_cost) {
39 40 41
  (void)blk_row;
  (void)blk_col;
  (void)tx_size;
42 43
  rd_stats->txb_coeff_cost[plane] += txb_coeff_cost;

44 45 46 47 48 49 50
  {
    const int txb_h = tx_size_high_unit[tx_size];
    const int txb_w = tx_size_wide_unit[tx_size];
    int idx, idy;
    for (idy = 0; idy < txb_h; ++idy)
      for (idx = 0; idx < txb_w; ++idx)
        rd_stats->txb_coeff_cost_map[plane][blk_row + idy][blk_col + idx] = 0;
51

52 53
    rd_stats->txb_coeff_cost_map[plane][blk_row][blk_col] = txb_coeff_cost;
  }
54 55
  assert(blk_row < TXB_COEFF_COST_MAP_SIZE);
  assert(blk_col < TXB_COEFF_COST_MAP_SIZE);
56 57 58
}
#endif

Angie Chiang's avatar
Angie Chiang committed
59 60 61 62 63
typedef enum OUTPUT_STATUS {
  OUTPUT_HAS_PREDICTED_PIXELS,
  OUTPUT_HAS_DECODED_PIXELS
} OUTPUT_STATUS;

64
// Returns the number of colors in 'src'.
65 66
int av1_count_colors(const uint8_t *src, int stride, int rows, int cols,
                     int *val_count);
67 68
// Same as av1_count_colors(), but for high-bitdepth mode.
int av1_count_colors_highbd(const uint8_t *src8, int stride, int rows, int cols,
69
                            int bit_depth, int *val_count);
70

71
void av1_dist_block(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane,
Angie Chiang's avatar
Angie Chiang committed
72 73 74 75
                    BLOCK_SIZE plane_bsize, int block, int blk_row, int blk_col,
                    TX_SIZE tx_size, int64_t *out_dist, int64_t *out_sse,
                    OUTPUT_STATUS output_status);

Yushin Cho's avatar
Yushin Cho committed
76
#if CONFIG_DIST_8X8
77
int64_t av1_dist_8x8(const struct AV1_COMP *const cpi, const MACROBLOCK *x,
Yushin Cho's avatar
Yushin Cho committed
78 79 80
                     const uint8_t *src, int src_stride, const uint8_t *dst,
                     int dst_stride, const BLOCK_SIZE tx_bsize, int bsw,
                     int bsh, int visible_w, int visible_h, int qindex);
Yushin Cho's avatar
Yushin Cho committed
81 82
#endif

Linfeng Zhang's avatar
Linfeng Zhang committed
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
#if !CONFIG_LV_MAP
static INLINE int cost_coeffs(const AV1_COMMON *const cm, MACROBLOCK *x,
                              int plane, int block, TX_SIZE tx_size,
                              const SCAN_ORDER *scan_order,
                              const ENTROPY_CONTEXT *a,
                              const ENTROPY_CONTEXT *l,
                              int use_fast_coef_costing) {
  MACROBLOCKD *const xd = &x->e_mbd;
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
  const struct macroblock_plane *p = &x->plane[plane];
  const struct macroblockd_plane *pd = &xd->plane[plane];
  const PLANE_TYPE type = pd->plane_type;
  const uint16_t *band_count = &band_count_table[tx_size][1];
  const int eob = p->eobs[block];
  const tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  const TX_SIZE tx_size_ctx = get_txsize_entropy_ctx(tx_size);
  uint8_t token_cache[MAX_TX_SQUARE];
  int pt = combine_entropy_contexts(*a, *l);
  int c, cost;
  const int16_t *scan = scan_order->scan;
  const int16_t *nb = scan_order->neighbors;
  const int ref = is_inter_block(mbmi);
  int(*head_token_costs)[COEFF_CONTEXTS][TAIL_TOKENS] =
      x->token_head_costs[tx_size_ctx][type][ref];
  int(*tail_token_costs)[COEFF_CONTEXTS][TAIL_TOKENS] =
      x->token_tail_costs[tx_size_ctx][type][ref];
  const int seg_eob = av1_get_tx_eob(&cm->seg, mbmi->segment_id, tx_size);
  int8_t eob_val;
  const int cat6_bits = av1_get_cat6_extrabits_size(tx_size, xd->bd);
  (void)cm;

  if (eob == 0) {
    // block zero
    cost = (*head_token_costs)[pt][0];
  } else {
    if (use_fast_coef_costing) {
      int band_left = *band_count++;

      // dc token
      int v = qcoeff[0];
      int16_t prev_t;
      cost = av1_get_token_cost(v, &prev_t, cat6_bits);
      eob_val = (eob == 1) ? EARLY_EOB : NO_EOB;
      cost += av1_get_coeff_token_cost(
          prev_t, eob_val, 1, (*head_token_costs)[pt], (*tail_token_costs)[pt]);

      token_cache[0] = av1_pt_energy_class[prev_t];
      ++head_token_costs;
      ++tail_token_costs;

      // ac tokens
      for (c = 1; c < eob; c++) {
        const int rc = scan[c];
        int16_t t;

        v = qcoeff[rc];
        cost += av1_get_token_cost(v, &t, cat6_bits);
        eob_val =
            (c + 1 == eob) ? (c + 1 == seg_eob ? LAST_EOB : EARLY_EOB) : NO_EOB;
        cost += av1_get_coeff_token_cost(t, eob_val, 0,
                                         (*head_token_costs)[!prev_t],
                                         (*tail_token_costs)[!prev_t]);
        prev_t = t;
        if (!--band_left) {
          band_left = *band_count++;
          ++head_token_costs;
          ++tail_token_costs;
        }
      }
    } else {  // !use_fast_coef_costing
      int band_left = *band_count++;

      // dc token
      int v = qcoeff[0];
      int16_t tok;
      cost = av1_get_token_cost(v, &tok, cat6_bits);
      eob_val = (eob == 1) ? EARLY_EOB : NO_EOB;
      cost += av1_get_coeff_token_cost(tok, eob_val, 1, (*head_token_costs)[pt],
                                       (*tail_token_costs)[pt]);

      token_cache[0] = av1_pt_energy_class[tok];
      ++head_token_costs;
      ++tail_token_costs;

      // ac tokens
      for (c = 1; c < eob; c++) {
        const int rc = scan[c];

        v = qcoeff[rc];
        cost += av1_get_token_cost(v, &tok, cat6_bits);
        pt = get_coef_context(nb, token_cache, c);
        eob_val =
            (c + 1 == eob) ? (c + 1 == seg_eob ? LAST_EOB : EARLY_EOB) : NO_EOB;
        cost += av1_get_coeff_token_cost(
            tok, eob_val, 0, (*head_token_costs)[pt], (*tail_token_costs)[pt]);
        token_cache[rc] = av1_pt_energy_class[tok];
        if (!--band_left) {
          band_left = *band_count++;
          ++head_token_costs;
          ++tail_token_costs;
        }
      }
    }
  }

  return cost;
}
#endif  // !CONFIG_LV_MAP

static INLINE int av1_cost_coeffs(const struct AV1_COMP *const cpi,
                                  MACROBLOCK *x, int plane, int blk_row,
                                  int blk_col, int block, TX_SIZE tx_size,
                                  const SCAN_ORDER *scan_order,
                                  const ENTROPY_CONTEXT *a,
                                  const ENTROPY_CONTEXT *l,
                                  int use_fast_coef_costing) {
#if TXCOEFF_COST_TIMER
  struct aom_usec_timer timer;
  aom_usec_timer_start(&timer);
#endif
  const AV1_COMMON *const cm = &cpi->common;
#if !CONFIG_LV_MAP
  (void)blk_row;
  (void)blk_col;
  int cost = cost_coeffs(cm, x, plane, block, tx_size, scan_order, a, l,
                         use_fast_coef_costing);
#else   // !CONFIG_LV_MAP
  (void)scan_order;
  (void)use_fast_coef_costing;
  const MACROBLOCKD *xd = &x->e_mbd;
  const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
  const struct macroblockd_plane *pd = &xd->plane[plane];
  const BLOCK_SIZE bsize = mbmi->sb_type;
  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
  TXB_CTX txb_ctx;
  get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx);
  const int eob = x->plane[plane].eobs[block];
  int cost;
  if (eob) {
    cost = av1_cost_coeffs_txb(cm, x, plane, blk_row, blk_col, block, tx_size,
                               &txb_ctx);
  } else {
    const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size);
    const PLANE_TYPE plane_type = get_plane_type(plane);
    const LV_MAP_COEFF_COST *const coeff_costs =
        &x->coeff_costs[txs_ctx][plane_type];
    cost = coeff_costs->txb_skip_cost[txb_ctx.txb_skip_ctx][1];
  }
#endif  // !CONFIG_LV_MAP
#if TXCOEFF_COST_TIMER
  AV1_COMMON *tmp_cm = (AV1_COMMON *)&cpi->common;
  aom_usec_timer_mark(&timer);
  const int64_t elapsed_time = aom_usec_timer_elapsed(&timer);
  tmp_cm->txcoeff_cost_timer += elapsed_time;
  ++tmp_cm->txcoeff_cost_count;
#endif
  return cost;
}
Yushin Cho's avatar
Yushin Cho committed
241

242
void av1_rd_pick_intra_mode_sb(const struct AV1_COMP *cpi, struct macroblock *x,
Angie Chiang's avatar
Angie Chiang committed
243
                               struct RD_STATS *rd_cost, BLOCK_SIZE bsize,
Yaowu Xu's avatar
Yaowu Xu committed
244
                               PICK_MODE_CONTEXT *ctx, int64_t best_rd);
Jingning Han's avatar
Jingning Han committed
245

246
unsigned int av1_get_sby_perpixel_variance(const struct AV1_COMP *cpi,
Yaowu Xu's avatar
Yaowu Xu committed
247 248
                                           const struct buf_2d *ref,
                                           BLOCK_SIZE bs);
249
unsigned int av1_high_get_sby_perpixel_variance(const struct AV1_COMP *cpi,
Yaowu Xu's avatar
Yaowu Xu committed
250 251
                                                const struct buf_2d *ref,
                                                BLOCK_SIZE bs, int bd);
Jingning Han's avatar
Jingning Han committed
252

253
void av1_rd_pick_inter_mode_sb(const struct AV1_COMP *cpi,
Yaowu Xu's avatar
Yaowu Xu committed
254 255
                               struct TileDataEnc *tile_data,
                               struct macroblock *x, int mi_row, int mi_col,
256 257
                               struct RD_STATS *rd_cost, BLOCK_SIZE bsize,
                               PICK_MODE_CONTEXT *ctx, int64_t best_rd_so_far);
Jingning Han's avatar
Jingning Han committed
258

Yaowu Xu's avatar
Yaowu Xu committed
259
void av1_rd_pick_inter_mode_sb_seg_skip(
260
    const struct AV1_COMP *cpi, struct TileDataEnc *tile_data,
Angie Chiang's avatar
Angie Chiang committed
261
    struct macroblock *x, int mi_row, int mi_col, struct RD_STATS *rd_cost,
David Barker's avatar
David Barker committed
262
    BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx, int64_t best_rd_so_far);
Jingning Han's avatar
Jingning Han committed
263

264 265 266 267
int av1_internal_image_edge(const struct AV1_COMP *cpi);
int av1_active_h_edge(const struct AV1_COMP *cpi, int mi_row, int mi_step);
int av1_active_v_edge(const struct AV1_COMP *cpi, int mi_col, int mi_step);
int av1_active_edge_sb(const struct AV1_COMP *cpi, int mi_row, int mi_col);
Jingning Han's avatar
Jingning Han committed
268

Yunqing Wang's avatar
Yunqing Wang committed
269 270 271 272
#ifdef __cplusplus
}  // extern "C"
#endif

273 274 275
int av1_tx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
                     const MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane,
                     TX_SIZE tx_size, TX_TYPE tx_type);
276

277 278 279 280
int64_t get_prediction_rd_cost(const struct AV1_COMP *cpi, struct macroblock *x,
                               int mi_row, int mi_col, int *skip_blk,
                               MB_MODE_INFO *backup_mbmi);

281
void av1_inverse_transform_block_facade(MACROBLOCKD *xd, int plane, int block,
282 283
                                        int blk_row, int blk_col, int eob,
                                        int reduced_tx_set);
Yaowu Xu's avatar
Yaowu Xu committed
284
#endif  // AV1_ENCODER_RDOPT_H_