generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Palette experiment: adaptly update probs

Browse Source 
Also make changes to transmit palette-enabled flag using
neighbor blocks as context.

on screen_content
--enable-palette                            +7.35%

on derflr
with all other experiments                  +6.05%

Change-Id: Id6c2f726d21913d54a3f86ecfea474a4044c27f6
This commit is contained in:
hui su 2015-03-06 18:08:50 -08:00
parent 070d635657
commit e18b104462
11 changed files with 371 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
vp9/common/vp9_blockd.h
View File

@ -109,16 +109,6 @@ typedef enum {
} COPY_MODE; } COPY_MODE;
#endif // CONFIG_COPY_MODE #endif // CONFIG_COPY_MODE
#if CONFIG_PALETTE
typedef enum {
H_SCAN,
V_SCAN,
SPIRAL_SCAN,
ZZ_SCAN,
PALETTE_SCAN_ORDERS
} PALETTE_SCAN_ORDER;
#endif
static INLINE int is_inter_mode(PREDICTION_MODE mode) { static INLINE int is_inter_mode(PREDICTION_MODE mode) {
return mode >= NEARESTMV && mode <= NEWMV; return mode >= NEARESTMV && mode <= NEWMV;
} }

144
vp9/common/vp9_entropymode.c
View File

@ -373,6 +373,32 @@ const vp9_tree_index vp9_palette_size_tree[TREE_SIZE(PALETTE_SIZES)] = {
-SEVEN_COLORS, -EIGHT_COLORS -SEVEN_COLORS, -EIGHT_COLORS
}; };
static const vp9_prob default_palette_size_prob[10][PALETTE_SIZES - 1] = {
{ 96, 89, 100, 64, 77, 130},
{ 22, 15, 44, 16, 34, 82},
{ 30, 19, 57, 18, 38, 86},
{ 94, 36, 104, 23, 43, 92},
{ 116, 76, 107, 46, 65, 105},
{ 112, 82, 94, 40, 70, 112},
{ 147, 124, 123, 58, 69, 103},
{ 180, 113, 136, 49, 45, 114},
{ 107, 70, 87, 49, 154, 156},
{ 98, 105, 142, 63, 64, 152},
};
static const vp9_prob default_palette_uv_size_prob[10][PALETTE_SIZES - 1] = {
{ 160, 196, 228, 213, 175, 230},
{ 87, 148, 208, 141, 166, 163},
{ 72, 151, 204, 139, 155, 161},
{ 78, 135, 171, 104, 120, 173},
{ 59, 92, 131, 78, 92, 142},
{ 75, 118, 149, 84, 90, 128},
{ 89, 87, 92, 66, 66, 128},
{ 67, 53, 54, 55, 66, 93},
{ 120, 130, 83, 171, 75, 214},
{ 72, 55, 66, 68, 79, 107},
};
const vp9_tree_index vp9_palette_run_length_tree[TREE_SIZE(PALETTE_RUN_LENGTHS)] const vp9_tree_index vp9_palette_run_length_tree[TREE_SIZE(PALETTE_RUN_LENGTHS)]
= { = {
-ONE_BITS, 2, -ONE_BITS, 2,
@ -383,19 +409,6 @@ const vp9_tree_index vp9_palette_run_length_tree[TREE_SIZE(PALETTE_RUN_LENGTHS)]
-SIX_BITS, -MAX_BITS -SIX_BITS, -MAX_BITS
}; };
static const vp9_prob default_palette_size_prob[10][PALETTE_SIZES - 1] = {
{ 54, 82, 96, 100, 117, 139},
{ 11, 10, 30, 20, 45, 82},
{ 11, 10, 30, 20, 45, 82},
{ 16, 13, 29, 9, 34, 93},
{ 128, 40, 50, 46, 62, 77},
{ 128, 40, 50, 46, 62, 77},
{ 92, 177, 193, 78, 28, 40},
{ 160, 30, 228, 64, 105, 180},
{ 160, 30, 228, 64, 105, 180},
{ 32, 84, 227, 45, 12, 232},
};
static const vp9_prob static const vp9_prob
default_palette_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = { default_palette_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = {
{ 10, 91, 148, 95, 121, 254}, { 10, 91, 148, 95, 121, 254},
@ -410,19 +423,6 @@ default_palette_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = {
{ 72, 34, 32, 42, 42, 108}, { 72, 34, 32, 42, 42, 108},
}; };
static const vp9_prob default_palette_uv_size_prob[10][PALETTE_SIZES - 1] = {
{ 180, 192, 207, 221, 55, 254},
{ 128, 185, 235, 148, 180, 128},
{ 128, 185, 235, 148, 180, 128},
{ 150, 180, 211, 77, 147, 179},
{ 128, 60, 195, 68, 120, 228},
{ 128, 60, 195, 68, 120, 228},
{ 228, 15, 17, 178, 47, 197},
{ 103, 210, 145, 250, 190, 128},
{ 103, 210, 145, 250, 190, 128},
{ 5, 76, 230, 148, 239, 254},
};
static const vp9_prob static const vp9_prob
default_palette_uv_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = { default_palette_uv_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = {
{ 81, 107, 112, 254, 128, 128}, { 81, 107, 112, 254, 128, 128},
@ -436,6 +436,59 @@ default_palette_uv_run_length_prob[10][PALETTE_RUN_LENGTHS - 1] = {
{ 5, 5, 5, 70, 75, 18}, { 5, 5, 5, 70, 75, 18},
{ 5, 5, 5, 5, 157, 5}, { 5, 5, 5, 5, 157, 5},
}; };
const vp9_tree_index vp9_palette_scan_order_tree
[TREE_SIZE(PALETTE_SCAN_ORDERS)] = {
-H_SCAN, 2,
-V_SCAN, 4,
-SPIRAL_SCAN, -ZZ_SCAN,
};
static const vp9_prob
default_palette_scan_order_prob[10][PALETTE_SCAN_ORDERS - 1] = {
{ 95, 152, 184},
{ 79, 102, 219},
{ 114, 143, 201},
{ 121, 133, 178},
{ 80, 163, 180},
{ 147, 124, 192},
{ 140, 202, 142},
{ 91, 238, 206},
{ 214, 203, 180},
{ 85, 223, 29},
};
static const vp9_prob
default_palette_uv_scan_order_prob[10][PALETTE_SCAN_ORDERS - 1] = {
{ 131, 171, 112},
{ 29, 133, 213},
{ 159, 147, 196},
{ 86, 113, 173},
{ 36, 210, 119},
{ 148, 156, 160},
{ 104, 209, 72},
{ 37, 253, 232},
{ 198, 240, 153},
{ 61, 253, 109},
};
static const vp9_prob default_palette_enabled_prob[10][3] = {
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
{ 240, 180, 100, },
};
static const vp9_prob default_uv_palette_enabled_prob[2] = {
253, 229
};
#endif // CONFIG_PALETTE #endif // CONFIG_PALETTE
#if CONFIG_SUPERTX #if CONFIG_SUPERTX
@ -570,6 +623,10 @@ void vp9_init_mode_probs(FRAME_CONTEXT *fc) {
#endif // CONFIG_EXT_TX #endif // CONFIG_EXT_TX
#if CONFIG_PALETTE #if CONFIG_PALETTE
vp9_copy(fc->palette_size_prob, default_palette_size_prob); vp9_copy(fc->palette_size_prob, default_palette_size_prob);
vp9_copy(fc->palette_enabled_prob, default_palette_enabled_prob);
vp9_copy(fc->palette_uv_enabled_prob, default_uv_palette_enabled_prob);
vp9_copy(fc->palette_scan_order_prob, default_palette_scan_order_prob);
vp9_copy(fc->palette_uv_scan_order_prob, default_palette_uv_scan_order_prob);
vp9_copy(fc->palette_run_length_prob, default_palette_run_length_prob); vp9_copy(fc->palette_run_length_prob, default_palette_run_length_prob);
vp9_copy(fc->palette_uv_size_prob, default_palette_uv_size_prob); vp9_copy(fc->palette_uv_size_prob, default_palette_uv_size_prob);
vp9_copy(fc->palette_uv_run_length_prob, default_palette_uv_run_length_prob); vp9_copy(fc->palette_uv_run_length_prob, default_palette_uv_run_length_prob);
@ -768,6 +825,41 @@ void vp9_adapt_mode_probs(VP9_COMMON *cm) {
counts->wedge_interinter[i]); counts->wedge_interinter[i]);
} }
#endif // CONFIG_WEDGE_PARTITION #endif // CONFIG_WEDGE_PARTITION
#if CONFIG_PALETTE
for (i = 0; i < 10; i++) {
adapt_probs(vp9_palette_scan_order_tree,
pre_fc->palette_scan_order_prob[i],
counts->y_palette_scan_order[i],
fc->palette_scan_order_prob[i]);
}
for (i = 0; i < 10; i++) {
adapt_probs(vp9_palette_scan_order_tree,
pre_fc->palette_uv_scan_order_prob[i],
counts->uv_palette_scan_order[i],
fc->palette_uv_scan_order_prob[i]);
}
for (i = 0; i < 10; i++) {
adapt_probs(vp9_palette_size_tree, pre_fc->palette_size_prob[i],
counts->y_palette_size[i],
fc->palette_size_prob[i]);
}
for (i = 0; i < 10; i++) {
adapt_probs(vp9_palette_size_tree, pre_fc->palette_uv_size_prob[i],
counts->uv_palette_size[i],
fc->palette_uv_size_prob[i]);
}
for (i = 0; i < 10; i++) {
for (j = 0; j < 3; j++)
fc->palette_enabled_prob[i][j] =
adapt_prob(pre_fc->palette_enabled_prob[i][j],
counts->y_palette_enabled[i][j]);
}
for (i = 0; i < 2; i++)
fc->palette_uv_enabled_prob[i] =
adapt_prob(pre_fc->palette_uv_enabled_prob[i],
counts->uv_palette_enabled[i]);
#endif // CONFIG_PALETTE
} }
static void set_default_lf_deltas(struct loopfilter *lf) { static void set_default_lf_deltas(struct loopfilter *lf) {

22
vp9/common/vp9_entropymode.h
View File

@ -67,6 +67,10 @@ typedef struct frame_contexts {
vp9_prob ext_tx_prob[3][EXT_TX_TYPES - 1]; vp9_prob ext_tx_prob[3][EXT_TX_TYPES - 1];
#endif // CONFIG_EXT_TX #endif // CONFIG_EXT_TX
#if CONFIG_PALETTE #if CONFIG_PALETTE
vp9_prob palette_enabled_prob[10][3];
vp9_prob palette_uv_enabled_prob[2];
vp9_prob palette_scan_order_prob[10][PALETTE_SCAN_ORDERS - 1];
vp9_prob palette_uv_scan_order_prob[10][PALETTE_SCAN_ORDERS - 1];
vp9_prob palette_size_prob[10][PALETTE_SIZES - 1]; vp9_prob palette_size_prob[10][PALETTE_SIZES - 1];
vp9_prob palette_run_length_prob[10][PALETTE_RUN_LENGTHS - 1]; vp9_prob palette_run_length_prob[10][PALETTE_RUN_LENGTHS - 1];
vp9_prob palette_uv_size_prob[10][PALETTE_SIZES - 1]; vp9_prob palette_uv_size_prob[10][PALETTE_SIZES - 1];
@ -117,18 +121,18 @@ typedef struct {
nmv_context_counts mv; nmv_context_counts mv;
#if CONFIG_FILTERINTRA #if CONFIG_FILTERINTRA
unsigned int filterintra[TX_SIZES][INTRA_MODES][2]; unsigned int filterintra[TX_SIZES][INTRA_MODES][2];
#endif #endif // CONFIG_FILTERINTRA
#if CONFIG_EXT_TX #if CONFIG_EXT_TX
unsigned int ext_tx[3][EXT_TX_TYPES]; unsigned int ext_tx[3][EXT_TX_TYPES];
#endif #endif // CONFIG_EXT_TX
#if CONFIG_SUPERTX #if CONFIG_SUPERTX
unsigned int supertx[PARTITION_SUPERTX_CONTEXTS][TX_SIZES][2]; unsigned int supertx[PARTITION_SUPERTX_CONTEXTS][TX_SIZES][2];
unsigned int supertx_size[BLOCK_SIZES]; unsigned int supertx_size[BLOCK_SIZES];
#endif #endif // CONFIG_SUPERTX
#if CONFIG_TX_SKIP #if CONFIG_TX_SKIP
unsigned int y_tx_skip[2][2]; unsigned int y_tx_skip[2][2];
unsigned int uv_tx_skip[2][2]; unsigned int uv_tx_skip[2][2];
#endif #endif // CONFIG_TX_SKIP
#if CONFIG_COPY_MODE #if CONFIG_COPY_MODE
unsigned int copy_noref[COPY_MODE_CONTEXTS][BLOCK_SIZES][2]; unsigned int copy_noref[COPY_MODE_CONTEXTS][BLOCK_SIZES][2];
unsigned int copy_mode_l2[COPY_MODE_CONTEXTS][2]; unsigned int copy_mode_l2[COPY_MODE_CONTEXTS][2];
@ -143,6 +147,14 @@ typedef struct {
#if CONFIG_WEDGE_PARTITION #if CONFIG_WEDGE_PARTITION
unsigned int wedge_interinter[BLOCK_SIZES][2]; unsigned int wedge_interinter[BLOCK_SIZES][2];
#endif // CONFIG_WEDGE_PARTITION #endif // CONFIG_WEDGE_PARTITION
#if CONFIG_PALETTE
unsigned int y_palette_enabled[10][3][2];
unsigned int uv_palette_enabled[2][2];
unsigned int y_palette_scan_order[10][PALETTE_SCAN_ORDERS];
unsigned int uv_palette_scan_order[10][PALETTE_SCAN_ORDERS];
unsigned int y_palette_size[10][PALETTE_SIZES];
unsigned int uv_palette_size[10][PALETTE_SIZES];
#endif // CONFIG_PALETTE
} FRAME_COUNTS; } FRAME_COUNTS;
extern const vp9_prob vp9_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1]; extern const vp9_prob vp9_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1];
@ -161,6 +173,8 @@ extern const vp9_tree_index vp9_ext_tx_tree[TREE_SIZE(EXT_TX_TYPES)];
#if CONFIG_PALETTE #if CONFIG_PALETTE
extern const vp9_tree_index vp9_palette_size_tree[TREE_SIZE(PALETTE_SIZES)]; extern const vp9_tree_index vp9_palette_size_tree[TREE_SIZE(PALETTE_SIZES)];
extern const vp9_tree_index extern const vp9_tree_index
vp9_palette_scan_order_tree[TREE_SIZE(PALETTE_SCAN_ORDERS)];
extern const vp9_tree_index
vp9_palette_run_length_tree[TREE_SIZE(PALETTE_RUN_LENGTHS)]; vp9_palette_run_length_tree[TREE_SIZE(PALETTE_RUN_LENGTHS)];
#endif #endif
#if CONFIG_COPY_MODE #if CONFIG_COPY_MODE

10
vp9/common/vp9_enums.h
View File

@ -149,7 +149,15 @@ typedef enum {
MAX_BITS, MAX_BITS,
PALETTE_RUN_LENGTHS PALETTE_RUN_LENGTHS
} PALETTE_RUN_LENGTH; } PALETTE_RUN_LENGTH;
#endif
typedef enum {
H_SCAN,
V_SCAN,
SPIRAL_SCAN,
ZZ_SCAN,
PALETTE_SCAN_ORDERS
} PALETTE_SCAN_ORDER;
#endif // CONFIG_PALETTE
typedef enum { typedef enum {
VP9_LAST_FLAG = 1 << 0, VP9_LAST_FLAG = 1 << 0,

20
vp9/common/vp9_palette.c
View File

@ -424,4 +424,22 @@ void palette_iscan(uint8_t *color_index_map, uint8_t *sequence,
break; break;
} }
} }
#endif
void update_palette_counts(FRAME_COUNTS *counts, MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize, int palette_ctx) {
int idx = bsize - BLOCK_8X8;
counts->y_palette_enabled[idx][palette_ctx][mbmi->palette_enabled[0]]++;
counts->uv_palette_enabled[mbmi->palette_enabled[0]]
[mbmi->palette_enabled[1]]++;
if (mbmi->palette_enabled[0]) {
counts->y_palette_scan_order[idx][mbmi->palette_scan_order[0]]++;
counts->y_palette_size[idx][mbmi->palette_size[0] - 2]++;
}
if (mbmi->palette_enabled[1]) {
counts->uv_palette_scan_order[idx][mbmi->palette_scan_order[1]]++;
counts->uv_palette_size[idx][mbmi->palette_size[1] - 2]++;
}
}
#endif // CONFIG_PALETTE

3
vp9/common/vp9_palette.h
View File

@ -12,6 +12,7 @@
#define VP9_COMMON_VP9_PALETTE_H_ #define VP9_COMMON_VP9_PALETTE_H_
#include "vp9/common/vp9_blockd.h" #include "vp9/common/vp9_blockd.h"
#include "vp9/common/vp9_entropymode.h"
#if CONFIG_PALETTE #if CONFIG_PALETTE
int count_colors(const uint8_t *src, int stride, int rows, int cols); int count_colors(const uint8_t *src, int stride, int rows, int cols);
@ -34,6 +35,8 @@ void palette_scan(uint8_t *color_index_map, uint8_t *sequence,
int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order); int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order);
void palette_iscan(uint8_t *color_index_map, uint8_t *sequence, void palette_iscan(uint8_t *color_index_map, uint8_t *sequence,
int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order); int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order);
void update_palette_counts(FRAME_COUNTS *counts, MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize, int palette_ctx);
#endif #endif
#endif // VP9_COMMON_VP9_PALETTE_H_ #endif // VP9_COMMON_VP9_PALETTE_H_

82
vp9/decoder/vp9_decodemv.c
View File

@ -224,8 +224,16 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r); mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (bsize >= BLOCK_8X8 && cm->allow_palette_mode) { if (bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
mbmi->palette_enabled[0] = vp9_read_bit(r); int palette_ctx = 0;
mbmi->palette_enabled[1] = vp9_read_bit(r); if (above_mi)
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
mbmi->palette_enabled[0] =
vp9_read(r,
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][palette_ctx]);
mbmi->palette_enabled[1] =
vp9_read(r, cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
} else { } else {
mbmi->palette_enabled[0] = 0; mbmi->palette_enabled[0] = 0;
mbmi->palette_enabled[1] = 0; mbmi->palette_enabled[1] = 0;
@ -260,7 +268,9 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
mbmi->palette_run_length[0] = mbmi->palette_run_length[0] =
vp9_read_literal(r, get_bit_depth(palette_max_run(bsize))); vp9_read_literal(r, get_bit_depth(palette_max_run(bsize)));
mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1; mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1;
mbmi->palette_scan_order[0] = vp9_read_literal(r, 2); mbmi->palette_scan_order[0] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_scan_order_prob[bsize - BLOCK_8X8]);
m1 = mbmi->palette_indexed_size; m1 = mbmi->palette_indexed_size;
m2 = mbmi->palette_literal_size; m2 = mbmi->palette_literal_size;
@ -311,7 +321,6 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
palette_color_insertion(cm->current_palette_colors, palette_color_insertion(cm->current_palette_colors,
&cm ->current_palette_size, &cm ->current_palette_size,
cm->current_palette_count, mbmi); cm->current_palette_count, mbmi);
run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0], run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer); xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer, palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
@ -335,12 +344,14 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) { if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
mbmi->palette_size[1] = mbmi->palette_size[1] =
vp9_read_tree(r, vp9_palette_size_tree, vp9_read_tree(r, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[uv_bsize - BLOCK_4X4]); cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8]);
mbmi->palette_size[1] += 2; mbmi->palette_size[1] += 2;
mbmi->palette_run_length[1] = mbmi->palette_run_length[1] =
vp9_read_literal(r, get_bit_depth(palette_max_run(uv_bsize))); vp9_read_literal(r, get_bit_depth(palette_max_run(uv_bsize)));
mbmi->palette_run_length[1] = (mbmi->palette_run_length[1]) << 1; mbmi->palette_run_length[1] = (mbmi->palette_run_length[1]) << 1;
mbmi->palette_scan_order[1] = vp9_read_literal(r, 2); mbmi->palette_scan_order[1] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8]);
} else { } else {
mbmi->palette_size[1] = mbmi->palette_size[0]; mbmi->palette_size[1] = mbmi->palette_size[0];
} }
@ -357,7 +368,7 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1])); vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1]));
bits = vp9_read_tree(r, vp9_palette_run_length_tree, bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc. cm->fc.
palette_uv_run_length_prob[uv_bsize - BLOCK_4X4]); palette_uv_run_length_prob[bsize - BLOCK_8X8]);
if (bits == MAX_BITS) if (bits == MAX_BITS)
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] = vp9_read_literal(r, d); mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] = vp9_read_literal(r, d);
else else
@ -1247,13 +1258,27 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
if (mbmi->copy_mode == NOREF) if (mbmi->copy_mode == NOREF)
#endif #endif
inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r); inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
#if CONFIG_PALETTE #if CONFIG_PALETTE
mbmi->palette_enabled[0] = 0; mbmi->palette_enabled[0] = 0;
mbmi->palette_enabled[1] = 0; mbmi->palette_enabled[1] = 0;
if (!inter_block && mbmi->sb_type >= BLOCK_8X8 && cm->allow_palette_mode) { if (!inter_block && mbmi->sb_type >= BLOCK_8X8 && cm->allow_palette_mode) {
mbmi->palette_enabled[0] = vp9_read_bit(r); const MODE_INFO *above_mi = xd->up_available ?
mbmi->palette_enabled[1] = vp9_read_bit(r); xd->mi[-xd->mi_stride].src_mi : NULL;
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
int ctx = 0;
if (above_mi)
ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
ctx += (left_mi->mbmi.palette_enabled[0] == 1);
mbmi->palette_enabled[0] =
vp9_read(r,
cm->fc.palette_enabled_prob[mbmi->sb_type - BLOCK_8X8][ctx]);
mbmi->palette_enabled[1] =
vp9_read(r, cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
} }
if (mbmi->palette_enabled[0]) { if (mbmi->palette_enabled[0]) {
@ -1271,7 +1296,9 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
mbmi->palette_run_length[0] = mbmi->palette_run_length[0] =
vp9_read_literal(r, get_bit_depth(palette_max_run(bsize))); vp9_read_literal(r, get_bit_depth(palette_max_run(bsize)));
mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1; mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1;
mbmi->palette_scan_order[0] = vp9_read_literal(r, 2); mbmi->palette_scan_order[0] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_scan_order_prob[bsize - BLOCK_8X8]);
for (i = 0; i < mbmi->palette_size[0]; i++) { for (i = 0; i < mbmi->palette_size[0]; i++) {
mbmi->palette_colors[i] = vp9_read_literal(r, 8); mbmi->palette_colors[i] = vp9_read_literal(r, 8);
@ -1308,7 +1335,7 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >> int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y; xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >> int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_y; xd->plane[1].subsampling_x;
PALETTE_RUN_LENGTH bits; PALETTE_RUN_LENGTH bits;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]); BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
@ -1316,12 +1343,14 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) { if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
mbmi->palette_size[1] = mbmi->palette_size[1] =
vp9_read_tree(r, vp9_palette_size_tree, vp9_read_tree(r, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[uv_bsize - BLOCK_4X4]); cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8]);
mbmi->palette_size[1] += 2; mbmi->palette_size[1] += 2;
mbmi->palette_run_length[1] = mbmi->palette_run_length[1] =
vp9_read_literal(r, get_bit_depth(palette_max_run(uv_bsize))); vp9_read_literal(r, get_bit_depth(palette_max_run(uv_bsize)));
mbmi->palette_run_length[1] = (mbmi->palette_run_length[1]) << 1; mbmi->palette_run_length[1] = (mbmi->palette_run_length[1]) << 1;
mbmi->palette_scan_order[1] = vp9_read_literal(r, 2); mbmi->palette_scan_order[1] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8]);
} else { } else {
mbmi->palette_size[1] = mbmi->palette_size[0]; mbmi->palette_size[1] = mbmi->palette_size[0];
} }
@ -1337,8 +1366,8 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
mbmi->palette_runs[PALETTE_MAX_RUNS + i] = mbmi->palette_runs[PALETTE_MAX_RUNS + i] =
vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1])); vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1]));
bits = vp9_read_tree(r, vp9_palette_run_length_tree, bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[uv_bsize - cm->fc.palette_uv_run_length_prob[bsize -
BLOCK_4X4]); BLOCK_8X8]);
if (bits == MAX_BITS) if (bits == MAX_BITS)
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] = mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] =
vp9_read_literal(r, d); vp9_read_literal(r, d);
@ -1356,6 +1385,21 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
} }
} }
if (!inter_block && mbmi->sb_type >= BLOCK_8X8 && cm->allow_palette_mode) {
BLOCK_SIZE bsize = mbmi->sb_type;
int palette_ctx = 0;
const MODE_INFO *above_mi = xd->up_available ?
xd->mi[-xd->mi_stride].src_mi : NULL;
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
if (above_mi)
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
update_palette_counts(&cm->counts, mbmi, bsize, palette_ctx);
}
if (!mbmi->palette_enabled[0]) { if (!mbmi->palette_enabled[0]) {
mbmi->tx_size = read_tx_size(cm, xd, cm->tx_mode, mbmi->sb_type, mbmi->tx_size = read_tx_size(cm, xd, cm->tx_mode, mbmi->sb_type,
!mbmi->skip || !inter_block, r); !mbmi->skip || !inter_block, r);
@ -1363,7 +1407,7 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
#else #else
mbmi->tx_size = read_tx_size(cm, xd, cm->tx_mode, mbmi->sb_type, mbmi->tx_size = read_tx_size(cm, xd, cm->tx_mode, mbmi->sb_type,
!mbmi->skip || !inter_block, r); !mbmi->skip || !inter_block, r);
#endif #endif // CONFIG_PALETTE
#if CONFIG_EXT_TX #if CONFIG_EXT_TX
if (inter_block && if (inter_block &&
@ -1390,8 +1434,12 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
if (!cm->frame_parallel_decoding_mode) if (!cm->frame_parallel_decoding_mode)
#if CONFIG_COPY_MODE #if CONFIG_COPY_MODE
if (mbmi->copy_mode == NOREF) if (mbmi->copy_mode == NOREF)
#endif #endif // CONFIG_COPY_MODE
++cm->counts.intra_inter[ctx][1]; ++cm->counts.intra_inter[ctx][1];
#if CONFIG_PALETTE
mbmi->palette_enabled[0] = 0;
mbmi->palette_enabled[1] = 0;
#endif // CONFIG_PALETTE
} }
#endif // CONFIG_SUPERTX #endif // CONFIG_SUPERTX

67
vp9/encoder/vp9_bitstream.c
View File

@ -46,6 +46,7 @@ static struct vp9_token ext_tx_encodings[EXT_TX_TYPES];
#endif #endif
#if CONFIG_PALETTE #if CONFIG_PALETTE
static struct vp9_token palette_size_encodings[PALETTE_SIZES]; static struct vp9_token palette_size_encodings[PALETTE_SIZES];
static struct vp9_token palette_scan_order_encodings[PALETTE_SCAN_ORDERS];
static struct vp9_token palette_run_length_encodings[PALETTE_RUN_LENGTHS]; static struct vp9_token palette_run_length_encodings[PALETTE_RUN_LENGTHS];
#endif #endif
#if CONFIG_COPY_MODE #if CONFIG_COPY_MODE
@ -78,6 +79,8 @@ void vp9_entropy_mode_init() {
#endif #endif
#if CONFIG_PALETTE #if CONFIG_PALETTE
vp9_tokens_from_tree(palette_size_encodings, vp9_palette_size_tree); vp9_tokens_from_tree(palette_size_encodings, vp9_palette_size_tree);
vp9_tokens_from_tree(palette_scan_order_encodings,
vp9_palette_scan_order_tree);
vp9_tokens_from_tree(palette_run_length_encodings, vp9_tokens_from_tree(palette_run_length_encodings,
vp9_palette_run_length_tree); vp9_palette_run_length_tree);
#endif #endif
@ -464,10 +467,22 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (!is_inter && bsize >= BLOCK_8X8 && cm->allow_palette_mode) { if (!is_inter && bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
int l, n, i, d, bits; int l, n, i, d, bits, ctx;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
const MODE_INFO *above_mi = xd->up_available ?
xd->mi[-xd->mi_stride].src_mi : NULL;
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
vp9_write_bit(w, mbmi->palette_enabled[0]); ctx = 0;
vp9_write_bit(w, mbmi->palette_enabled[1]); if (above_mi)
ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
ctx += (left_mi->mbmi.palette_enabled[0] == 1);
vp9_write(w, mbmi->palette_enabled[0],
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][ctx]);
vp9_write(w, mbmi->palette_enabled[1],
cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
if (mbmi->palette_enabled[0]) { if (mbmi->palette_enabled[0]) {
int rows = 4 * num_4x4_blocks_high_lookup[bsize]; int rows = 4 * num_4x4_blocks_high_lookup[bsize];
@ -480,7 +495,10 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
&palette_size_encodings[n - 2]); &palette_size_encodings[n - 2]);
vp9_write_literal(w, (l >> 1), vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(bsize))); get_bit_depth(palette_max_run(bsize)));
vp9_write_literal(w, mbmi->palette_scan_order[0], 2); vp9_write_token(w, vp9_palette_scan_order_tree,
cm->fc.palette_scan_order_prob[bsize - BLOCK_8X8],
&palette_scan_order_encodings
[mbmi->palette_scan_order[0]]);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
vp9_write_literal(w, mbmi->palette_colors[i], 8); vp9_write_literal(w, mbmi->palette_colors[i], 8);
@ -505,17 +523,19 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
xd->plane[1].subsampling_y; xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >> int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x; xd->plane[1].subsampling_x;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
n = mbmi->palette_size[1]; n = mbmi->palette_size[1];
l = mbmi->palette_run_length[1]; l = mbmi->palette_run_length[1];
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) { if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
vp9_write_token(w, vp9_palette_size_tree, vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[uv_bsize - BLOCK_4X4], cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8],
&palette_size_encodings[n - 2]); &palette_size_encodings[n - 2]);
vp9_write_literal(w, (l >> 1), vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(uv_bsize))); get_bit_depth(palette_max_run(uv_bsize)));
vp9_write_literal(w, mbmi->palette_scan_order[1], 2); vp9_write_token(w, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8],
&palette_scan_order_encodings
[mbmi->palette_scan_order[1]]);
} }
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
@ -530,8 +550,7 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
get_bit_depth(mbmi->palette_size[1])); get_bit_depth(mbmi->palette_size[1]));
bits = get_bit_depth(runs[i + 1]); bits = get_bit_depth(runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree, vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[uv_bsize - cm->fc.palette_uv_run_length_prob[bsize - BLOCK_8X8],
BLOCK_4X4],
&palette_run_length_encodings[bits > 6 ? &palette_run_length_encodings[bits > 6 ?
6 : bits - 1]); 6 : bits - 1]);
vp9_write_literal(w, runs[i + 1] - 1, vp9_write_literal(w, runs[i + 1] - 1,
@ -834,10 +853,18 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (bsize >= BLOCK_8X8 && cm->allow_palette_mode) { if (bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
int l, m1, m2, i, d, bits; int l, m1, m2, i, d, bits, ctx;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
vp9_write_bit(w, mbmi->palette_enabled[0]); ctx = 0;
vp9_write_bit(w, mbmi->palette_enabled[1]); if (above_mi)
ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
ctx += (left_mi->mbmi.palette_enabled[0] == 1);
vp9_write(w, mbmi->palette_enabled[0],
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][ctx]);
vp9_write(w, mbmi->palette_enabled[1],
cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
if (mbmi->palette_enabled[0]) { if (mbmi->palette_enabled[0]) {
int rows = 4 * num_4x4_blocks_high_lookup[bsize]; int rows = 4 * num_4x4_blocks_high_lookup[bsize];
@ -858,7 +885,10 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
vp9_write_literal(w, mbmi->palette_delta_bitdepth, PALETTE_DELTA_BIT); vp9_write_literal(w, mbmi->palette_delta_bitdepth, PALETTE_DELTA_BIT);
vp9_write_literal(w, (l >> 1), vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(bsize))); get_bit_depth(palette_max_run(bsize)));
vp9_write_literal(w, mbmi->palette_scan_order[0], 2); vp9_write_token(w, vp9_palette_scan_order_tree,
cm->fc.palette_scan_order_prob[bsize - BLOCK_8X8],
&palette_scan_order_encodings
[mbmi->palette_scan_order[0]]);
if (m1 > 0) { if (m1 > 0) {
for (i = 0; i < m1; i++) for (i = 0; i < m1; i++)
@ -897,16 +927,18 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
xd->plane[1].subsampling_y; xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >> int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x; xd->plane[1].subsampling_x;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
l = mbmi->palette_run_length[1]; l = mbmi->palette_run_length[1];
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) { if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
vp9_write_token(w, vp9_palette_size_tree, vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[uv_bsize - BLOCK_4X4], cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8],
&palette_size_encodings[mbmi->palette_size[1] - 2]); &palette_size_encodings[mbmi->palette_size[1] - 2]);
vp9_write_literal(w, (l >> 1), vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(uv_bsize))); get_bit_depth(palette_max_run(uv_bsize)));
vp9_write_literal(w, mbmi->palette_scan_order[1], 2); vp9_write_token(w, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8],
&palette_scan_order_encodings
[mbmi->palette_scan_order[1]]);
} }
for (i = 0; i < mbmi->palette_size[1]; i++) for (i = 0; i < mbmi->palette_size[1]; i++)
@ -921,8 +953,7 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
get_bit_depth(mbmi->palette_size[1])); get_bit_depth(mbmi->palette_size[1]));
bits = get_bit_depth(runs[i + 1]); bits = get_bit_depth(runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree, vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[uv_bsize - cm->fc.palette_uv_run_length_prob[bsize - BLOCK_8X8],
BLOCK_4X4],
&palette_run_length_encodings[bits > 6 ? &palette_run_length_encodings[bits > 6 ?
6 : bits - 1]); 6 : bits - 1]);
vp9_write_literal(w, runs[i + 1] - 1, vp9_write_literal(w, runs[i + 1] - 1,

21
vp9/encoder/vp9_encodeframe.c
View File

@ -5047,7 +5047,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
!vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { !vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
++cm->counts.ext_tx[mbmi->tx_size][mbmi->ext_txfrm]; ++cm->counts.ext_tx[mbmi->tx_size][mbmi->ext_txfrm];
} }
#endif #endif // CONFIG_EXT_TX
#if CONFIG_TX_SKIP #if CONFIG_TX_SKIP
if (bsize >= BLOCK_8X8) { if (bsize >= BLOCK_8X8) {
int q_idx = vp9_get_qindex(&cm->seg, mbmi->segment_id, cm->base_qindex); int q_idx = vp9_get_qindex(&cm->seg, mbmi->segment_id, cm->base_qindex);
@ -5062,12 +5062,27 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
if (try_tx_skip) { if (try_tx_skip) {
#else #else
if (try_tx_skip && (!(mbmi->skip || seg_skip) || !is_inter_block(mbmi))) { if (try_tx_skip && (!(mbmi->skip || seg_skip) || !is_inter_block(mbmi))) {
#endif #endif // CONFIG_SUPERTX
++cm->counts.y_tx_skip[is_inter_block(mbmi)][mbmi->tx_skip[0]]; ++cm->counts.y_tx_skip[is_inter_block(mbmi)][mbmi->tx_skip[0]];
++cm->counts.uv_tx_skip[mbmi->tx_skip[0]][mbmi->tx_skip[1]]; ++cm->counts.uv_tx_skip[mbmi->tx_skip[0]][mbmi->tx_skip[1]];
} }
} }
#endif #endif // CONFIG_TX_SKIP
#if CONFIG_PALETTE
if (!frame_is_intra_only(cm) && !is_inter_block(mbmi) &&
bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
int palette_ctx = 0;
const MODE_INFO *above_mi = xd->up_available ?
xd->mi[-xd->mi_stride].src_mi : NULL;
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
if (above_mi)
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
update_palette_counts(&cm->counts, mbmi, bsize, palette_ctx);
}
#endif // CONFIG_PALETTE
} }
} }

2
vp9/encoder/vp9_encoder.c
View File

@ -2606,7 +2606,7 @@ static void encode_with_recode_loop(VP9_COMP *cpi,
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (loop_count == 0 && frame_is_intra_only(cm)) if (loop_count == 0 && frame_is_intra_only(cm))
cm->allow_palette_mode = 1; cm->allow_palette_mode = 1;
#endif #endif // CONFIG_PALETTE
// Variance adaptive and in frame q adjustment experiments are mutually // Variance adaptive and in frame q adjustment experiments are mutually
// exclusive. // exclusive.

74
vp9/encoder/vp9_rdopt.c
View File

@ -1355,7 +1355,7 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
int try_tx_skip = q_idx <= TX_SKIP_Q_THRESH_INTRA; int try_tx_skip = q_idx <= TX_SKIP_Q_THRESH_INTRA;
#endif // CONFIG_TX_SKIP #endif // CONFIG_TX_SKIP
#if CONFIG_PALETTE #if CONFIG_PALETTE
int palette_selected = 0, best_n = 0, best_l = 0, colors; int palette_selected = 0, best_n = 0, best_l = 0, colors, palette_ctx;
int best_m1 = 0, best_m2 = 0, palette_delta_bitdepth = 0; int best_m1 = 0, best_m2 = 0, palette_delta_bitdepth = 0;
int rows = 4 * num_4x4_blocks_high_lookup[bsize]; int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize]; int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
@ -1374,6 +1374,13 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
tx_cache[i] = INT64_MAX; tx_cache[i] = INT64_MAX;
vpx_memset(x->skip_txfm, 0, sizeof(x->skip_txfm)); vpx_memset(x->skip_txfm, 0, sizeof(x->skip_txfm));
#if CONFIG_PALETTE
palette_ctx = 0;
if (above_mi)
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
#endif // CONFIG_PALETTE
/* Y Search for intra prediction mode */ /* Y Search for intra prediction mode */
#if CONFIG_FILTERINTRA #if CONFIG_FILTERINTRA
for (mode_ext = 2 * DC_PRED; mode_ext <= 2 * TM_PRED + 1; mode_ext++) { for (mode_ext = 2 * DC_PRED; mode_ext <= 2 * TM_PRED + 1; mode_ext++) {
@ -1415,7 +1422,9 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
#endif #endif
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (this_rate != INT_MAX && cpi->common.allow_palette_mode) if (this_rate != INT_MAX && cpi->common.allow_palette_mode)
this_rate += vp9_cost_bit(128, 0); this_rate +=
vp9_cost_bit(cpi->common.fc.
palette_enabled_prob[bsize - BLOCK_8X8][palette_ctx], 0);
#endif #endif
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
@ -1503,6 +1512,7 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
int l, m1, m2, d = get_bit_depth(rows * cols); int l, m1, m2, d = get_bit_depth(rows * cols);
int bits, best_bits = 0, total_bits, best_total_bits; int bits, best_bits = 0, total_bits, best_total_bits;
int palette_size_cost[PALETTE_SIZES]; int palette_size_cost[PALETTE_SIZES];
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
int palette_run_length_cost[PALETTE_RUN_LENGTHS]; int palette_run_length_cost[PALETTE_RUN_LENGTHS];
double centroids[PALETTE_MAX_SIZE]; double centroids[PALETTE_MAX_SIZE];
double lb = src[0], ub = src[0], val; double lb = src[0], ub = src[0], val;
@ -1521,6 +1531,9 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
vp9_cost_tokens(palette_size_cost, vp9_cost_tokens(palette_size_cost,
cpi->common.fc.palette_size_prob[bsize - BLOCK_8X8], cpi->common.fc.palette_size_prob[bsize - BLOCK_8X8],
vp9_palette_size_tree); vp9_palette_size_tree);
vp9_cost_tokens(palette_scan_order_cost,
cpi->common.fc.palette_scan_order_prob[bsize - BLOCK_8X8],
vp9_palette_scan_order_tree);
vp9_cost_tokens(palette_run_length_cost, vp9_cost_tokens(palette_run_length_cost,
cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8], cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8],
vp9_palette_run_length_tree); vp9_palette_run_length_tree);
@ -1680,12 +1693,15 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
continue; continue;
this_rate = this_rate_tokenonly + this_rate = this_rate_tokenonly +
(1 + vp9_encode_uniform_cost(MIN(k + 1, 8), m1) + PALETTE_DELTA_BIT (vp9_encode_uniform_cost(MIN(k + 1, 8), m1) + PALETTE_DELTA_BIT
+ get_bit_depth(palette_max_run(bsize)) + 2 + + get_bit_depth(palette_max_run(bsize)) +
get_bit_depth(mic->mbmi.current_palette_size) * m1 + get_bit_depth(mic->mbmi.current_palette_size) * m1 +
best_bits * m1 + best_bits * m1 +
8 * m2 + get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) + 8 * m2 + get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) +
palette_size_cost[k - 2]; vp9_cost_bit(cpi->common.fc.palette_enabled_prob
[bsize - BLOCK_8X8][palette_ctx], 1) +
palette_size_cost[k - 2] +
palette_scan_order_cost[ps];
for (i = 0; i < l; i += 2) { for (i = 0; i < l; i += 2) {
int bits = get_bit_depth(mic->mbmi.palette_runs[i + 1]); int bits = get_bit_depth(mic->mbmi.palette_runs[i + 1]);
this_rate += palette_run_length_cost[bits > 6 ? 6 : bits - 1]; this_rate += palette_run_length_cost[bits > 6 ? 6 : bits - 1];
@ -1909,7 +1925,8 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
if (xd->mi[0].src_mi->mbmi.sb_type >= BLOCK_8X8 && if (xd->mi[0].src_mi->mbmi.sb_type >= BLOCK_8X8 &&
xd->plane[1].subsampling_x && xd->plane[1].subsampling_y && xd->plane[1].subsampling_x && xd->plane[1].subsampling_y &&
cpi->common.allow_palette_mode) cpi->common.allow_palette_mode)
this_rate += vp9_cost_bit(128, 0); this_rate += vp9_cost_bit(cpi->common.fc.palette_uv_enabled_prob
[mbmi->palette_enabled[0]], 0);
#endif // CONFIG_PALETTE #endif // CONFIG_PALETTE
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion); this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
@ -2001,6 +2018,7 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
if (colors > 1 && colors <= 64) { if (colors > 1 && colors <= 64) {
int n, r, c, i, j, max_itr = 200; int n, r, c, i, j, max_itr = 200;
int l, d = get_bit_depth(rows * cols); int l, d = get_bit_depth(rows * cols);
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
int palette_run_length_cost[PALETTE_RUN_LENGTHS]; int palette_run_length_cost[PALETTE_RUN_LENGTHS];
int palette_size_cost[PALETTE_SIZES]; int palette_size_cost[PALETTE_SIZES];
double centroids[2 * PALETTE_MAX_SIZE]; double centroids[2 * PALETTE_MAX_SIZE];
@ -2014,6 +2032,9 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
#endif // CONFIG_TX_SKIP #endif // CONFIG_TX_SKIP
i = uv_bsize - BLOCK_4X4; i = uv_bsize - BLOCK_4X4;
vp9_cost_tokens(palette_scan_order_cost,
cpi->common.fc.palette_uv_scan_order_prob[i],
vp9_palette_scan_order_tree);
vp9_cost_tokens(palette_size_cost, vp9_cost_tokens(palette_size_cost,
cpi->common.fc.palette_uv_size_prob[i], cpi->common.fc.palette_uv_size_prob[i],
vp9_palette_size_tree); vp9_palette_size_tree);
@ -2114,9 +2135,12 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
continue; continue;
this_rate = this_rate_tokenonly + this_rate = this_rate_tokenonly +
(1 + get_bit_depth(palette_max_run(uv_bsize)) + 2 + 2 * 8 * n + (get_bit_depth(palette_max_run(uv_bsize)) + 2 * 8 * n +
get_bit_depth(n) * (l >> 1)) * vp9_cost_bit(128, 0) + get_bit_depth(n) * (l >> 1)) * vp9_cost_bit(128, 0) +
palette_size_cost[n - 2]; vp9_cost_bit(cpi->common.fc.palette_uv_enabled_prob
[mbmi->palette_enabled[0]], 1) +
palette_size_cost[n - 2] +
palette_scan_order_cost[ps];
for (i = 0; i < l; i += 2) { for (i = 0; i < l; i += 2) {
int bits = get_bit_depth( int bits = get_bit_depth(
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1]); mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1]);
@ -5205,7 +5229,7 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
int copy_mode_context = vp9_get_copy_mode_context(xd); int copy_mode_context = vp9_get_copy_mode_context(xd);
#endif // CONFIG_COPY_MODE #endif // CONFIG_COPY_MODE
#if CONFIG_PALETTE #if CONFIG_PALETTE
int best_n = 0, best_l = 0, colors; int best_n = 0, best_l = 0, colors, palette_ctx;
int rows = 4 * num_4x4_blocks_high_lookup[bsize]; int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize]; int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
int src_stride = x->plane[0].src.stride; int src_stride = x->plane[0].src.stride;
@ -5217,6 +5241,10 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
uint16_t best_runs[PALETTE_MAX_RUNS]; uint16_t best_runs[PALETTE_MAX_RUNS];
uint16_t palette_runs_uv[TX_SIZES][PALETTE_MAX_RUNS]; uint16_t palette_runs_uv[TX_SIZES][PALETTE_MAX_RUNS];
PALETTE_SCAN_ORDER best_ps = H_SCAN, ps_uv[TX_SIZES]; PALETTE_SCAN_ORDER best_ps = H_SCAN, ps_uv[TX_SIZES];
const MODE_INFO *above_mi = xd->up_available ?
xd->mi[-xd->mi_stride].src_mi : NULL;
const MODE_INFO *left_mi = xd->left_available ?
xd->mi[-1].src_mi : NULL;
#endif // CONFIG_PALETTE #endif // CONFIG_PALETTE
vp9_zero(best_mbmode); vp9_zero(best_mbmode);
@ -5363,6 +5391,14 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
midx = end_pos; midx = end_pos;
} }
#if CONFIG_PALETTE
palette_ctx = 0;
if (above_mi)
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
#endif // CONFIG_PALETTE
for (midx = 0; midx < MAX_MODES; ++midx) { for (midx = 0; midx < MAX_MODES; ++midx) {
int mode_index = mode_map[midx]; int mode_index = mode_map[midx];
int mode_excluded = 0; int mode_excluded = 0;
@ -5773,8 +5809,11 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
cm->fc.filterintra_prob[mbmi->tx_size][mbmi->mode], mbmi->filterbit); cm->fc.filterintra_prob[mbmi->tx_size][mbmi->mode], mbmi->filterbit);
#endif // CONFIG_FILTERINTRA #endif // CONFIG_FILTERINTRA
#if CONFIG_PALETTE #if CONFIG_PALETTE
if (cpi->common.allow_palette_mode && bsize >= BLOCK_8X8) if (cpi->common.allow_palette_mode && bsize >= BLOCK_8X8 &&
rate2 += vp9_cost_bit(128, 0); rate2 != INT_MAX)
rate2 +=
vp9_cost_bit(cm->fc.palette_enabled_prob[bsize - BLOCK_8X8]
[palette_ctx], 0);
#endif // CONFIG_PALETTE #endif // CONFIG_PALETTE
if (this_mode != DC_PRED && this_mode != TM_PRED) if (this_mode != DC_PRED && this_mode != TM_PRED)
rate2 += intra_cost_penalty; rate2 += intra_cost_penalty;
@ -6349,6 +6388,7 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
int l, d = get_bit_depth(rows * cols); int l, d = get_bit_depth(rows * cols);
int palette_size_cost[PALETTE_SIZES]; int palette_size_cost[PALETTE_SIZES];
int palette_run_length_cost[PALETTE_RUN_LENGTHS]; int palette_run_length_cost[PALETTE_RUN_LENGTHS];
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
double centroids[PALETTE_MAX_SIZE]; double centroids[PALETTE_MAX_SIZE];
double lb = src[0], ub = src[0], val; double lb = src[0], ub = src[0], val;
PALETTE_SCAN_ORDER ps; PALETTE_SCAN_ORDER ps;
@ -6379,6 +6419,9 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
vp9_cost_tokens(palette_run_length_cost, vp9_cost_tokens(palette_run_length_cost,
cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8], cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8],
vp9_palette_run_length_tree); vp9_palette_run_length_tree);
vp9_cost_tokens(palette_scan_order_cost,
cpi->common.fc.palette_scan_order_prob[bsize - BLOCK_8X8],
vp9_palette_scan_order_tree);
mbmi->ref_frame[0] = INTRA_FRAME; mbmi->ref_frame[0] = INTRA_FRAME;
mbmi->mode = DC_PRED; mbmi->mode = DC_PRED;
for (r = 0; r < rows; r++) { for (r = 0; r < rows; r++) {
@ -6477,9 +6520,12 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
continue; continue;
total_rate_y = rate_y + total_rate_y = rate_y +
(1 + get_bit_depth(palette_max_run(bsize)) + 2 + (get_bit_depth(palette_max_run(bsize)) + 8 * k +
8 * k + get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) + get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) +
palette_size_cost[k - 2]; vp9_cost_bit(cm->fc.palette_enabled_prob
[bsize - BLOCK_8X8][palette_ctx], 1) +
palette_size_cost[k - 2] +
palette_scan_order_cost[ps];
for (i = 0; i < l; i += 2) { for (i = 0; i < l; i += 2) {
int bits = get_bit_depth(mbmi->palette_runs[i + 1]); int bits = get_bit_depth(mbmi->palette_runs[i + 1]);
total_rate_y += palette_run_length_cost[bits > 6 ? 6 : bits - 1]; total_rate_y += palette_run_length_cost[bits > 6 ? 6 : bits - 1];