17 #ifndef AOM_AV1_ENCODER_INTRA_MODE_SEARCH_UTILS_H_
18 #define AOM_AV1_ENCODER_INTRA_MODE_SEARCH_UTILS_H_
21 #include "av1/common/pred_common.h"
22 #include "av1/common/reconintra.h"
25 #include "av1/encoder/encodeframe.h"
26 #include "av1/encoder/model_rd.h"
28 #include "av1/encoder/hybrid_fwd_txfm.h"
36 static const float av1_intra_hog_model_bias[DIRECTIONAL_MODES] = {
37 0.450578f, 0.695518f, -0.717944f, -0.639894f,
38 -0.602019f, -0.453454f, 0.055857f, -0.465480f,
41 static const float av1_intra_hog_model_weights[BINS * DIRECTIONAL_MODES] = {
42 -3.076402f, -3.757063f, -3.275266f, -3.180665f, -3.452105f, -3.216593f,
43 -2.871212f, -3.134296f, -1.822324f, -2.401411f, -1.541016f, -1.195322f,
44 -0.434156f, 0.322868f, 2.260546f, 3.368715f, 3.989290f, 3.308487f,
45 2.277893f, 0.923793f, 0.026412f, -0.385174f, -0.718622f, -1.408867f,
46 -1.050558f, -2.323941f, -2.225827f, -2.585453f, -3.054283f, -2.875087f,
47 -2.985709f, -3.447155f, 3.758139f, 3.204353f, 2.170998f, 0.826587f,
48 -0.269665f, -0.702068f, -1.085776f, -2.175249f, -1.623180f, -2.975142f,
49 -2.779629f, -3.190799f, -3.521900f, -3.375480f, -3.319355f, -3.897389f,
50 -3.172334f, -3.594528f, -2.879132f, -2.547777f, -2.921023f, -2.281844f,
51 -1.818988f, -2.041771f, -0.618268f, -1.396458f, -0.567153f, -0.285868f,
52 -0.088058f, 0.753494f, 2.092413f, 3.215266f, -3.300277f, -2.748658f,
53 -2.315784f, -2.423671f, -2.257283f, -2.269583f, -2.196660f, -2.301076f,
54 -2.646516f, -2.271319f, -2.254366f, -2.300102f, -2.217960f, -2.473300f,
55 -2.116866f, -2.528246f, -3.314712f, -1.701010f, -0.589040f, -0.088077f,
56 0.813112f, 1.702213f, 2.653045f, 3.351749f, 3.243554f, 3.199409f,
57 2.437856f, 1.468854f, 0.533039f, -0.099065f, -0.622643f, -2.200732f,
58 -4.228861f, -2.875263f, -1.273956f, -0.433280f, 0.803771f, 1.975043f,
59 3.179528f, 3.939064f, 3.454379f, 3.689386f, 3.116411f, 1.970991f,
60 0.798406f, -0.628514f, -1.252546f, -2.825176f, -4.090178f, -3.777448f,
61 -3.227314f, -3.479403f, -3.320569f, -3.159372f, -2.729202f, -2.722341f,
62 -3.054913f, -2.742923f, -2.612703f, -2.662632f, -2.907314f, -3.117794f,
63 -3.102660f, -3.970972f, -4.891357f, -3.935582f, -3.347758f, -2.721924f,
64 -2.219011f, -1.702391f, -0.866529f, -0.153743f, 0.107733f, 1.416882f,
65 2.572884f, 3.607755f, 3.974820f, 3.997783f, 2.970459f, 0.791687f,
66 -1.478921f, -1.228154f, -1.216955f, -1.765932f, -1.951003f, -1.985301f,
67 -1.975881f, -1.985593f, -2.422371f, -2.419978f, -2.531288f, -2.951853f,
68 -3.071380f, -3.277027f, -3.373539f, -4.462010f, -0.967888f, 0.805524f,
69 2.794130f, 3.685984f, 3.745195f, 3.252444f, 2.316108f, 1.399146f,
70 -0.136519f, -0.162811f, -1.004357f, -1.667911f, -1.964662f, -2.937579f,
71 -3.019533f, -3.942766f, -5.102767f, -3.882073f, -3.532027f, -3.451956f,
72 -2.944015f, -2.643064f, -2.529872f, -2.077290f, -2.809965f, -1.803734f,
73 -1.783593f, -1.662585f, -1.415484f, -1.392673f, -0.788794f, -1.204819f,
74 -1.998864f, -1.182102f, -0.892110f, -1.317415f, -1.359112f, -1.522867f,
75 -1.468552f, -1.779072f, -2.332959f, -2.160346f, -2.329387f, -2.631259f,
76 -2.744936f, -3.052494f, -2.787363f, -3.442548f, -4.245075f, -3.032172f,
77 -2.061609f, -1.768116f, -1.286072f, -0.706587f, -0.192413f, 0.386938f,
78 0.716997f, 1.481393f, 2.216702f, 2.737986f, 3.109809f, 3.226084f,
79 2.490098f, -0.095827f, -3.864816f, -3.507248f, -3.128925f, -2.908251f,
80 -2.883836f, -2.881411f, -2.524377f, -2.624478f, -2.399573f, -2.367718f,
81 -1.918255f, -1.926277f, -1.694584f, -1.723790f, -0.966491f, -1.183115f,
82 -1.430687f, 0.872896f, 2.766550f, 3.610080f, 3.578041f, 3.334928f,
83 2.586680f, 1.895721f, 1.122195f, 0.488519f, -0.140689f, -0.799076f,
84 -1.222860f, -1.502437f, -1.900969f, -3.206816f,
87 static const NN_CONFIG av1_intra_hog_model_nnconfig = {
93 av1_intra_hog_model_weights,
96 av1_intra_hog_model_bias,
100 #define FIX_PREC_BITS (16)
101 static AOM_INLINE
int get_hist_bin_idx(
int dx,
int dy) {
102 const int32_t ratio = (dy * (1 << FIX_PREC_BITS)) / dx;
105 static const int thresholds[BINS] = {
106 -1334015, -441798, -261605, -183158, -138560, -109331, -88359, -72303,
107 -59392, -48579, -39272, -30982, -23445, -16400, -9715, -3194,
108 3227, 9748, 16433, 23478, 31015, 39305, 48611, 59425,
109 72336, 88392, 109364, 138593, 183191, 261638, 441831, INT32_MAX
112 int lo_idx = 0, hi_idx = BINS - 1;
115 if (ratio <= thresholds[7]) {
118 }
else if (ratio <= thresholds[15]) {
121 }
else if (ratio <= thresholds[23]) {
129 for (
int idx = lo_idx; idx <= hi_idx; idx++) {
130 if (ratio <= thresholds[idx]) {
134 assert(0 &&
"No valid histogram bin found!");
140 static AOM_INLINE
void normalize_hog(
float total,
float *hist) {
141 for (
int i = 0; i < BINS; ++i) hist[i] /= total;
144 static AOM_INLINE
void lowbd_generate_hog(
const uint8_t *src,
int stride,
145 int rows,
int cols,
float *hist) {
148 for (
int r = 1; r < rows - 1; ++r) {
149 for (
int c = 1; c < cols - 1; ++c) {
150 const uint8_t *above = &src[c - stride];
151 const uint8_t *below = &src[c + stride];
152 const uint8_t *left = &src[c - 1];
153 const uint8_t *right = &src[c + 1];
155 const int dx = (right[-stride] + 2 * right[0] + right[stride]) -
156 (left[-stride] + 2 * left[0] + left[stride]);
157 const int dy = (below[-1] + 2 * below[0] + below[1]) -
158 (above[-1] + 2 * above[0] + above[1]);
159 if (dx == 0 && dy == 0)
continue;
160 const int temp = abs(dx) + abs(dy);
165 hist[BINS - 1] += temp / 2;
167 const int idx = get_hist_bin_idx(dx, dy);
168 assert(idx >= 0 && idx < BINS);
175 normalize_hog(total, hist);
180 static AOM_INLINE
void lowbd_compute_gradient_info_sb(
MACROBLOCK *
const x,
183 PixelLevelGradientInfo *
const grad_info_sb =
185 const uint8_t *src = x->
plane[plane].
src.buf;
186 const int stride = x->
plane[plane].
src.stride;
187 const int ss_x = x->
e_mbd.
plane[plane].subsampling_x;
188 const int ss_y = x->
e_mbd.
plane[plane].subsampling_y;
189 const int sb_height = block_size_high[sb_size] >> ss_y;
190 const int sb_width = block_size_wide[sb_size] >> ss_x;
192 for (
int r = 1; r < sb_height - 1; ++r) {
193 for (
int c = 1; c < sb_width - 1; ++c) {
194 const uint8_t *above = &src[c - stride];
195 const uint8_t *below = &src[c + stride];
196 const uint8_t *left = &src[c - 1];
197 const uint8_t *right = &src[c + 1];
199 const int dx = (right[-stride] + 2 * right[0] + right[stride]) -
200 (left[-stride] + 2 * left[0] + left[stride]);
201 const int dy = (below[-1] + 2 * below[0] + below[1]) -
202 (above[-1] + 2 * above[0] + above[1]);
203 grad_info_sb[r * sb_width + c].is_dx_zero = (dx == 0);
204 grad_info_sb[r * sb_width + c].abs_dx_abs_dy_sum =
205 (uint16_t)(abs(dx) + abs(dy));
206 grad_info_sb[r * sb_width + c].hist_bin_idx =
207 (dx != 0) ? get_hist_bin_idx(dx, dy) : -1;
213 #if CONFIG_AV1_HIGHBITDEPTH
214 static AOM_INLINE
void highbd_generate_hog(
const uint8_t *src8,
int stride,
215 int rows,
int cols,
float *hist) {
217 const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
219 for (
int r = 1; r < rows - 1; ++r) {
220 for (
int c = 1; c < cols - 1; ++c) {
221 const uint16_t *above = &src[c - stride];
222 const uint16_t *below = &src[c + stride];
223 const uint16_t *left = &src[c - 1];
224 const uint16_t *right = &src[c + 1];
226 const int dx = (right[-stride] + 2 * right[0] + right[stride]) -
227 (left[-stride] + 2 * left[0] + left[stride]);
228 const int dy = (below[-1] + 2 * below[0] + below[1]) -
229 (above[-1] + 2 * above[0] + above[1]);
230 if (dx == 0 && dy == 0)
continue;
231 const int temp = abs(dx) + abs(dy);
236 hist[BINS - 1] += temp / 2;
238 const int idx = get_hist_bin_idx(dx, dy);
239 assert(idx >= 0 && idx < BINS);
246 normalize_hog(total, hist);
251 static AOM_INLINE
void highbd_compute_gradient_info_sb(
MACROBLOCK *
const x,
254 PixelLevelGradientInfo *
const grad_info_sb =
256 const uint16_t *src = CONVERT_TO_SHORTPTR(x->
plane[plane].
src.buf);
257 const int stride = x->
plane[plane].
src.stride;
258 const int ss_x = x->
e_mbd.
plane[plane].subsampling_x;
259 const int ss_y = x->
e_mbd.
plane[plane].subsampling_y;
260 const int sb_height = block_size_high[sb_size] >> ss_y;
261 const int sb_width = block_size_wide[sb_size] >> ss_x;
263 for (
int r = 1; r < sb_height - 1; ++r) {
264 for (
int c = 1; c < sb_width - 1; ++c) {
265 const uint16_t *above = &src[c - stride];
266 const uint16_t *below = &src[c + stride];
267 const uint16_t *left = &src[c - 1];
268 const uint16_t *right = &src[c + 1];
270 const int dx = (right[-stride] + 2 * right[0] + right[stride]) -
271 (left[-stride] + 2 * left[0] + left[stride]);
272 const int dy = (below[-1] + 2 * below[0] + below[1]) -
273 (above[-1] + 2 * above[0] + above[1]);
274 grad_info_sb[r * sb_width + c].is_dx_zero = (dx == 0);
275 grad_info_sb[r * sb_width + c].abs_dx_abs_dy_sum =
276 (uint16_t)(abs(dx) + abs(dy));
277 grad_info_sb[r * sb_width + c].hist_bin_idx =
278 (dx != 0) ? get_hist_bin_idx(dx, dy) : -1;
283 #endif // CONFIG_AV1_HIGHBITDEPTH
285 static AOM_INLINE
void generate_hog(
const uint8_t *src8,
int stride,
int rows,
286 int cols,
float *hist,
int highbd) {
287 #if CONFIG_AV1_HIGHBITDEPTH
289 highbd_generate_hog(src8, stride, rows, cols, hist);
294 #endif // CONFIG_AV1_HIGHBITDEPTH
295 lowbd_generate_hog(src8, stride, rows, cols, hist);
298 static AOM_INLINE
void compute_gradient_info_sb(
MACROBLOCK *
const x,
301 #if CONFIG_AV1_HIGHBITDEPTH
302 if (is_cur_buf_hbd(&x->
e_mbd)) {
303 highbd_compute_gradient_info_sb(x, sb_size, plane);
306 #endif // CONFIG_AV1_HIGHBITDEPTH
307 lowbd_compute_gradient_info_sb(x, sb_size, plane);
314 BLOCK_SIZE sb_size,
int mi_row,
327 if (!frame_is_intra_only(&cpi->
common) ||
328 sf->
part_sf.partition_search_type != SEARCH_PARTITION)
331 const int num_planes = av1_num_planes(&cpi->
common);
333 av1_setup_src_planes(x, cpi->
source, mi_row, mi_col, num_planes, sb_size);
335 if (sf->
intra_sf.intra_pruning_with_hog) {
336 compute_gradient_info_sb(x, sb_size, PLANE_TYPE_Y);
339 if (sf->
intra_sf.chroma_intra_pruning_with_hog && num_planes > 1) {
340 compute_gradient_info_sb(x, sb_size, PLANE_TYPE_UV);
347 static AOM_INLINE
void generate_hog_using_gradient_cache(
const MACROBLOCK *x,
353 const int ss_x = x->
e_mbd.
plane[plane].subsampling_x;
354 const int ss_y = x->
e_mbd.
plane[plane].subsampling_y;
355 const int sb_width = block_size_wide[sb_size] >> ss_x;
359 const int mi_row_in_sb = x->
e_mbd.
mi_row & (mi_size_high[sb_size] - 1);
360 const int mi_col_in_sb = x->
e_mbd.
mi_col & (mi_size_wide[sb_size] - 1);
361 const int block_offset_in_grad_cache =
362 sb_width * (mi_row_in_sb << (MI_SIZE_LOG2 - ss_y)) +
363 (mi_col_in_sb << (MI_SIZE_LOG2 - ss_x));
365 plane * MAX_SB_SQUARE +
366 block_offset_in_grad_cache;
369 for (
int r = 1; r < rows - 1; ++r) {
370 for (
int c = 1; c < cols - 1; ++c) {
371 const uint16_t abs_dx_abs_dy_sum =
372 grad_info_blk[r * sb_width + c].abs_dx_abs_dy_sum;
373 if (!abs_dx_abs_dy_sum)
continue;
374 total += abs_dx_abs_dy_sum;
375 const bool is_dx_zero = grad_info_blk[r * sb_width + c].is_dx_zero;
377 hist[0] += abs_dx_abs_dy_sum >> 1;
378 hist[BINS - 1] += abs_dx_abs_dy_sum >> 1;
380 const int8_t idx = grad_info_blk[r * sb_width + c].hist_bin_idx;
381 assert(idx >= 0 && idx < BINS);
382 hist[idx] += abs_dx_abs_dy_sum;
386 normalize_hog(total, hist);
389 static INLINE
void collect_hog_data(
const MACROBLOCK *x, BLOCK_SIZE bsize,
390 BLOCK_SIZE sb_size,
int plane,
float *hog) {
392 const struct macroblockd_plane *
const pd = &xd->
plane[plane];
393 const int ss_x = pd->subsampling_x;
394 const int ss_y = pd->subsampling_y;
395 const int bh = block_size_high[bsize];
396 const int bw = block_size_wide[bsize];
407 generate_hog_using_gradient_cache(x, rows, cols, sb_size, plane, hog);
409 const uint8_t *src = x->
plane[plane].
src.buf;
410 const int src_stride = x->
plane[plane].
src.stride;
411 generate_hog(src, src_stride, rows, cols, hog, is_cur_buf_hbd(xd));
415 for (
int b = 0; b < BINS; ++b) {
416 hog[b] *= (1 + ss_x) * (1 + ss_y);
420 static AOM_INLINE
void prune_intra_mode_with_hog(
421 const MACROBLOCK *x, BLOCK_SIZE bsize, BLOCK_SIZE sb_size,
float th,
422 uint8_t *directional_mode_skip_mask,
int is_chroma) {
424 float hist[BINS] = { 0.0f };
425 collect_hog_data(x, bsize, sb_size, plane, hist);
428 float scores[DIRECTIONAL_MODES] = { 0.0f };
429 av1_nn_predict(hist, &av1_intra_hog_model_nnconfig, 1, scores);
430 for (UV_PREDICTION_MODE uv_mode = UV_V_PRED; uv_mode <= UV_D67_PRED;
432 if (scores[uv_mode - UV_V_PRED] <= th) {
433 directional_mode_skip_mask[uv_mode] = 1;
440 static AOM_INLINE
int write_uniform_cost(
int n,
int v) {
441 const int l = get_unsigned_bits(n);
442 const int m = (1 << l) - n;
443 if (l == 0)
return 0;
445 return av1_cost_literal(l - 1);
447 return av1_cost_literal(l);
458 BLOCK_SIZE bsize,
int mode_cost) {
459 int total_rate = mode_cost;
465 assert(((mbmi->
mode != DC_PRED) + use_palette + use_intrabc +
466 use_filter_intra) <= 1);
467 const int try_palette = av1_allow_palette(
469 if (try_palette && mbmi->
mode == DC_PRED) {
471 const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
472 const int mode_ctx = av1_get_palette_mode_ctx(xd);
476 const uint8_t *
const color_map = xd->
plane[0].color_index_map;
477 int block_width, block_height, rows, cols;
478 av1_get_block_dimensions(bsize, 0, xd, &block_width, &block_height, &rows,
481 int palette_mode_cost =
484 write_uniform_cost(plt_size, color_map[0]);
485 uint16_t color_cache[2 * PALETTE_MAX_SIZE];
486 const int n_cache = av1_get_palette_cache(xd, 0, color_cache);
491 av1_cost_color_map(x, 0, bsize, mbmi->
tx_size, PALETTE_MAP);
492 total_rate += palette_mode_cost;
495 if (av1_filter_intra_allowed(&cpi->
common, mbmi)) {
497 if (use_filter_intra) {
503 if (av1_is_directional_mode(mbmi->
mode)) {
504 if (av1_use_angle_delta(bsize)) {
511 if (av1_allow_intrabc(&cpi->
common))
523 BLOCK_SIZE bsize,
int mode_cost) {
524 int total_rate = mode_cost;
527 const UV_PREDICTION_MODE mode = mbmi->
uv_mode;
529 assert(((mode != UV_DC_PRED) + use_palette + mbmi->
use_intrabc) <= 1);
531 const int try_palette = av1_allow_palette(
533 if (try_palette && mode == UV_DC_PRED) {
538 const int bsize_ctx = av1_get_palette_bsize_ctx(bsize);
539 const int plt_size = pmi->palette_size[1];
541 const uint8_t *
const color_map = xd->
plane[1].color_index_map;
542 int palette_mode_cost =
545 write_uniform_cost(plt_size, color_map[0]);
546 uint16_t color_cache[2 * PALETTE_MAX_SIZE];
547 const int n_cache = av1_get_palette_cache(xd, 1, color_cache);
551 av1_cost_color_map(x, 1, bsize, mbmi->
tx_size, PALETTE_MAP);
552 total_rate += palette_mode_cost;
555 if (av1_is_directional_mode(get_uv_mode(mode))) {
556 if (av1_use_angle_delta(bsize)) {
570 int plane, BLOCK_SIZE plane_bsize,
571 TX_SIZE tx_size,
int use_hadamard) {
573 const BitDepthInfo bd_info = get_bit_depth_info(xd);
575 assert(!is_inter_block(xd->
mi[0]));
576 const int stepr = tx_size_high_unit[tx_size];
577 const int stepc = tx_size_wide_unit[tx_size];
578 const int txbw = tx_size_wide[tx_size];
579 const int txbh = tx_size_high[tx_size];
580 const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
581 const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
582 int64_t satd_cost = 0;
584 struct macroblockd_plane *pd = &xd->
plane[plane];
586 for (row = 0; row < max_blocks_high; row += stepr) {
587 for (col = 0; col < max_blocks_wide; col += stepc) {
588 av1_predict_intra_block_facade(cm, xd, plane, col, row, tx_size);
594 bd_info, txbh, txbw, p->
src_diff, block_size_wide[plane_bsize],
595 p->
src.buf + (((row * p->
src.stride) + col) << 2), p->
src.stride,
596 pd->dst.buf + (((row * pd->dst.stride) + col) << 2), pd->dst.stride);
597 av1_quick_txfm(use_hadamard, tx_size, bd_info, p->
src_diff,
598 block_size_wide[plane_bsize], p->
coeff);
599 satd_cost += aom_satd(p->
coeff, tx_size_2d[tx_size]);
618 int64_t *best_model_rd) {
619 const TX_SIZE tx_size = AOMMIN(TX_32X32, max_txsize_lookup[bsize]);
622 const int64_t this_model_rd =
623 intra_model_rd(cm, x, plane, bsize, tx_size, 1);
624 if (*best_model_rd != INT64_MAX &&
625 this_model_rd > *best_model_rd + (*best_model_rd >> 2)) {
627 }
else if (this_model_rd < *best_model_rd) {
628 *best_model_rd = this_model_rd;
637 #endif // AOM_AV1_ENCODER_INTRA_MODE_SEARCH_UTILS_H_
int8_t angle_delta[PLANE_TYPES]
Directional mode delta: the angle is base angle + (angle_delta * step).
Definition: blockd.h:272
#define AOM_PLANE_U
Definition: aom_image.h:200
int palette_uv_size_cost[7][PALETTE_SIZES]
palette_uv_size_cost
Definition: block.h:623
struct buf_2d src
A buffer containing the source frame.
Definition: block.h:119
AV1_COMMON common
Definition: encoder.h:2600
int mi_row
Definition: blockd.h:582
FILTER_INTRA_MODE_INFO filter_intra_mode_info
The type of filter intra mode used (if applicable).
Definition: blockd.h:274
FeatureFlags features
Definition: av1_common_int.h:906
static int intra_mode_info_cost_y(const AV1_COMP *cpi, const MACROBLOCK *x, const MB_MODE_INFO *mbmi, BLOCK_SIZE bsize, int mode_cost)
Returns the rate cost for luma prediction mode info of intra blocks.
Definition: intra_mode_search_utils.h:455
int angle_delta_cost[DIRECTIONAL_MODES][2 *MAX_ANGLE_DELTA+1]
angle_delta_cost
Definition: block.h:607
struct macroblockd_plane plane[3]
Definition: blockd.h:613
PREDICTION_MODE mode
The prediction mode used.
Definition: blockd.h:232
int av1_palette_color_cost_y(const PALETTE_MODE_INFO *const pmi, const uint16_t *color_cache, int n_cache, int bit_depth)
Gets the rate cost for transmitting luma palette color values.
Definition: palette.c:125
uint8_t use_intrabc
Whether intrabc is used.
Definition: blockd.h:318
Holds the entropy costs for various modes sent to the bitstream.
Definition: block.h:583
PARTITION_SPEED_FEATURES part_sf
Definition: speed_features.h:1354
YV12_BUFFER_CONFIG * source
Definition: encoder.h:2618
int mb_to_right_edge
Definition: blockd.h:685
int mi_col
Definition: blockd.h:583
int palette_y_size_cost[7][PALETTE_SIZES]
palette_y_size_cost
Definition: block.h:621
bool allow_screen_content_tools
Definition: av1_common_int.h:379
int filter_intra_cost[BLOCK_SIZES_ALL][2]
filter_intra_cost
Definition: block.h:603
PALETTE_MODE_INFO palette_mode_info
Stores the size and colors of palette mode.
Definition: blockd.h:280
SPEED_FEATURES sf
Definition: encoder.h:2758
int16_t * src_diff
Stores source - pred so the txfm can be computed later.
Definition: block.h:107
Top level speed vs quality trade off data struture.
Definition: speed_features.h:1330
int filter_intra_mode_cost[FILTER_INTRA_MODES]
filter_intra_mode_cost
Definition: block.h:605
SequenceHeader * seq_params
Definition: av1_common_int.h:977
int mb_to_bottom_edge
Definition: blockd.h:687
INTRA_MODE_SPEED_FEATURES intra_sf
Definition: speed_features.h:1374
tran_low_t * coeff
Transformed coefficients.
Definition: block.h:113
static int intra_mode_info_cost_uv(const AV1_COMP *cpi, const MACROBLOCK *x, const MB_MODE_INFO *mbmi, BLOCK_SIZE bsize, int mode_cost)
Return the rate cost for chroma prediction mode info of intra blocks.
Definition: intra_mode_search_utils.h:520
UV_PREDICTION_MODE uv_mode
The UV mode when intra is used.
Definition: blockd.h:234
MB_MODE_INFO ** mi
Definition: blockd.h:624
Variables related to current coding block.
Definition: blockd.h:577
int av1_palette_color_cost_uv(const PALETTE_MODE_INFO *const pmi, const uint16_t *color_cache, int n_cache, int bit_depth)
Gets the rate cost for transmitting luma palette chroma values.
Definition: palette.c:139
Top level encoder structure.
Definition: encoder.h:2557
ModeCosts mode_costs
The rate needed to signal a mode to the bitstream.
Definition: block.h:967
Declares top-level encoder structures and functions.
Top level common structure used by both encoder and decoder.
Definition: av1_common_int.h:751
BLOCK_SIZE bsize
The block size of the current coding block.
Definition: blockd.h:228
bool is_sb_gradient_cached[PLANE_TYPES]
Flags indicating the availability of cached gradient info.
Definition: block.h:1196
Stores the prediction/txfm mode of the current coding block.
Definition: blockd.h:222
int palette_y_mode_cost[7][3][2]
palette_y_mode_cost
Definition: block.h:631
static int model_intra_yrd_and_prune(const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int64_t *best_model_rd)
Estimate the luma rdcost of a given intra mode and try to prune it.
Definition: intra_mode_search_utils.h:616
int intrabc_cost[2]
intrabc_cost
Definition: block.h:618
TX_SIZE tx_size
Transform size when fixed size txfm is used (e.g. intra modes).
Definition: blockd.h:290
PixelLevelGradientInfo * pixel_gradient_info
Pointer to the buffer which caches gradient information.
Definition: block.h:1194
Declares functions used in palette search.
Encoder's parameters related to the current coding block.
Definition: block.h:854
struct macroblock_plane plane[3]
Each of the encoding plane.
Definition: block.h:864
Each source plane of the current macroblock.
Definition: block.h:105
int palette_uv_mode_cost[2][2]
palette_uv_mode_cost
Definition: block.h:633
#define AOM_PLANE_Y
Definition: aom_image.h:199
MACROBLOCKD e_mbd
Decoder's view of current coding block.
Definition: block.h:872