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

Merge "Palette experiment: encode color indices based on context" into nextgen

Browse Source
This commit is contained in:
hui su 2015-03-26 18:34:43 -07:00 committed by Gerrit Code Review
commit 65d39f9fae
12 changed files with 914 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
vp9/common/vp9_blockd.h
View File

@ -39,7 +39,8 @@ extern "C" {
#define PALETTE_BUF_SIZE 16
#define PALETTE_MAX_SIZE 8
#define PALETTE_DELTA_BIT 0
#define PALETTE_MAX_RUNS 128
#define PALETTE_MAX_RUNS 512
#define PALETTE_COLOR_CONTEXTS 16
#endif // CONFIG_PALETTE
/* Segment Feature Masks */
@ -357,7 +358,7 @@ typedef struct macroblockd {
DECLARE_ALIGNED(16, uint8_t, color_index_map[2][64 * 64]);
DECLARE_ALIGNED(16, int, palette_scan_buffer[64 * 64]);
DECLARE_ALIGNED(16, uint8_t, palette_map_buffer[64 * 64]);
#endif
#endif // CONFIG_PALETTE
ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];

302
vp9/common/vp9_entropymode.c
View File

@ -444,34 +444,6 @@ const vp9_tree_index vp9_palette_scan_order_tree
-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, },
@ -489,6 +461,264 @@ static const vp9_prob default_palette_enabled_prob[10][3] = {
static const vp9_prob default_uv_palette_enabled_prob[2] = {
253, 229
};
const vp9_tree_index vp9_palette_color_tree[TREE_SIZE(PALETTE_COLORS)] = {
-PALETTE_COLOR_ONE, 2,
-PALETTE_COLOR_TWO, 4,
-PALETTE_COLOR_THREE, 6,
-PALETTE_COLOR_FOUR, 8,
-PALETTE_COLOR_FIVE, 10,
-PALETTE_COLOR_SIX, 12,
-PALETTE_COLOR_SEVEN, -PALETTE_COLOR_EIGHT
};
static const vp9_prob default_palette_color_prob
[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS][PALETTE_COLORS - 1] = {
{ // 2 colors
{ 230, 255, 128, 128, 128, 128, 128 },
{ 214, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 240, 255, 128, 128, 128, 128, 128 },
{ 73, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 130, 255, 128, 128, 128, 128, 128 },
{ 227, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 188, 255, 128, 128, 128, 128, 128 },
{ 75, 255, 128, 128, 128, 128, 128 },
{ 250, 255, 128, 128, 128, 128, 128 },
{ 223, 255, 128, 128, 128, 128, 128 },
{ 252, 255, 128, 128, 128, 128, 128 },
}, { // 3 colors
{ 229, 137, 255, 128, 128, 128, 128 },
{ 197, 120, 255, 128, 128, 128, 128 },
{ 107, 195, 255, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 27, 151, 255, 128, 128, 128, 128 },
{ 230, 130, 255, 128, 128, 128, 128 },
{ 37, 230, 255, 128, 128, 128, 128 },
{ 67, 221, 255, 128, 128, 128, 128 },
{ 124, 230, 255, 128, 128, 128, 128 },
{ 195, 109, 255, 128, 128, 128, 128 },
{ 99, 122, 255, 128, 128, 128, 128 },
{ 205, 208, 255, 128, 128, 128, 128 },
{ 40, 235, 255, 128, 128, 128, 128 },
{ 251, 132, 255, 128, 128, 128, 128 },
{ 237, 186, 255, 128, 128, 128, 128 },
{ 253, 112, 255, 128, 128, 128, 128 },
}, { // 4 colors
{ 195, 87, 128, 255, 128, 128, 128 },
{ 143, 100, 123, 255, 128, 128, 128 },
{ 94, 124, 119, 255, 128, 128, 128 },
{ 77, 91, 130, 255, 128, 128, 128 },
{ 39, 114, 178, 255, 128, 128, 128 },
{ 222, 94, 125, 255, 128, 128, 128 },
{ 44, 203, 132, 255, 128, 128, 128 },
{ 68, 175, 122, 255, 128, 128, 128 },
{ 110, 187, 124, 255, 128, 128, 128 },
{ 152, 91, 128, 255, 128, 128, 128 },
{ 70, 109, 181, 255, 128, 128, 128 },
{ 133, 113, 164, 255, 128, 128, 128 },
{ 47, 205, 133, 255, 128, 128, 128 },
{ 247, 94, 136, 255, 128, 128, 128 },
{ 205, 122, 146, 255, 128, 128, 128 },
{ 251, 100, 141, 255, 128, 128, 128 },
}, { // 5 colors
{ 195, 65, 84, 125, 255, 128, 128 },
{ 150, 76, 84, 121, 255, 128, 128 },
{ 94, 110, 81, 117, 255, 128, 128 },
{ 79, 85, 91, 139, 255, 128, 128 },
{ 26, 102, 139, 127, 255, 128, 128 },
{ 220, 73, 91, 119, 255, 128, 128 },
{ 38, 203, 86, 127, 255, 128, 128 },
{ 61, 186, 72, 124, 255, 128, 128 },
{ 132, 199, 84, 128, 255, 128, 128 },
{ 172, 52, 62, 120, 255, 128, 128 },
{ 102, 89, 121, 122, 255, 128, 128 },
{ 182, 48, 69, 186, 255, 128, 128 },
{ 36, 206, 87, 126, 255, 128, 128 },
{ 249, 55, 67, 122, 255, 128, 128 },
{ 218, 88, 75, 122, 255, 128, 128 },
{ 253, 64, 80, 119, 255, 128, 128 },
}, { // 6 colors
{ 182, 54, 64, 75, 118, 255, 128 },
{ 126, 67, 70, 76, 116, 255, 128 },
{ 79, 92, 67, 85, 120, 255, 128 },
{ 63, 61, 81, 118, 132, 255, 128 },
{ 21, 80, 105, 83, 119, 255, 128 },
{ 215, 72, 74, 74, 111, 255, 128 },
{ 50, 176, 63, 79, 120, 255, 128 },
{ 72, 148, 66, 77, 120, 255, 128 },
{ 105, 177, 57, 78, 130, 255, 128 },
{ 150, 66, 66, 80, 127, 255, 128 },
{ 81, 76, 109, 85, 116, 255, 128 },
{ 113, 81, 62, 96, 148, 255, 128 },
{ 54, 179, 69, 82, 121, 255, 128 },
{ 244, 47, 48, 67, 118, 255, 128 },
{ 198, 83, 53, 65, 121, 255, 128 },
{ 250, 42, 51, 69, 110, 255, 128 },
}, { // 7 colors
{ 182, 45, 54, 62, 74, 113, 255 },
{ 124, 63, 57, 62, 77, 114, 255 },
{ 77, 80, 56, 66, 76, 117, 255 },
{ 63, 57, 69, 98, 85, 131, 255 },
{ 19, 81, 98, 63, 80, 116, 255 },
{ 215, 56, 60, 63, 68, 105, 255 },
{ 50, 174, 50, 60, 79, 118, 255 },
{ 68, 151, 50, 58, 73, 117, 255 },
{ 104, 182, 53, 57, 79, 127, 255 },
{ 156, 50, 51, 63, 77, 111, 255 },
{ 88, 67, 97, 59, 82, 120, 255 },
{ 114, 81, 46, 65, 103, 132, 255 },
{ 55, 166, 57, 66, 82, 120, 255 },
{ 245, 34, 38, 43, 63, 114, 255 },
{ 203, 68, 45, 47, 60, 118, 255 },
{ 250, 35, 37, 47, 66, 110, 255 },
}, { // 8 colors
{ 180, 43, 46, 50, 56, 69, 109 },
{ 116, 53, 51, 49, 57, 73, 115 },
{ 79, 70, 49, 50, 59, 74, 117 },
{ 60, 54, 57, 70, 62, 83, 129 },
{ 20, 73, 85, 52, 66, 81, 119 },
{ 213, 56, 52, 49, 53, 62, 104 },
{ 48, 161, 41, 45, 56, 77, 116 },
{ 68, 139, 40, 47, 54, 71, 116 },
{ 123, 166, 42, 43, 52, 76, 130 },
{ 153, 44, 44, 47, 54, 79, 129 },
{ 87, 64, 83, 49, 60, 75, 127 },
{ 131, 68, 43, 48, 73, 96, 130 },
{ 55, 152, 45, 51, 64, 77, 113 },
{ 243, 30, 28, 33, 41, 65, 114 },
{ 202, 56, 35, 36, 42, 63, 123 },
{ 249, 31, 29, 32, 45, 68, 111 },
}
};
static const vp9_prob default_palette_uv_color_prob
[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS][PALETTE_COLORS - 1] = {
{ // 2 colors
{ 228, 255, 128, 128, 128, 128, 128 },
{ 195, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 228, 255, 128, 128, 128, 128, 128 },
{ 71, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 129, 255, 128, 128, 128, 128, 128 },
{ 206, 255, 128, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 136, 255, 128, 128, 128, 128, 128 },
{ 98, 255, 128, 128, 128, 128, 128 },
{ 236, 255, 128, 128, 128, 128, 128 },
{ 222, 255, 128, 128, 128, 128, 128 },
{ 249, 255, 128, 128, 128, 128, 128 },
}, { // 3 colors
{ 198, 136, 255, 128, 128, 128, 128 },
{ 178, 105, 255, 128, 128, 128, 128 },
{ 100, 206, 255, 128, 128, 128, 128 },
{ 128, 128, 128, 128, 128, 128, 128 },
{ 12, 136, 255, 128, 128, 128, 128 },
{ 219, 134, 255, 128, 128, 128, 128 },
{ 50, 198, 255, 128, 128, 128, 128 },
{ 61, 231, 255, 128, 128, 128, 128 },
{ 110, 209, 255, 128, 128, 128, 128 },
{ 173, 106, 255, 128, 128, 128, 128 },
{ 145, 166, 255, 128, 128, 128, 128 },
{ 156, 175, 255, 128, 128, 128, 128 },
{ 69, 183, 255, 128, 128, 128, 128 },
{ 241, 163, 255, 128, 128, 128, 128 },
{ 224, 160, 255, 128, 128, 128, 128 },
{ 246, 154, 255, 128, 128, 128, 128 },
}, { // 4 colors
{ 173, 88, 143, 255, 128, 128, 128 },
{ 146, 81, 127, 255, 128, 128, 128 },
{ 84, 134, 102, 255, 128, 128, 128 },
{ 69, 138, 140, 255, 128, 128, 128 },
{ 31, 103, 200, 255, 128, 128, 128 },
{ 217, 101, 139, 255, 128, 128, 128 },
{ 51, 174, 121, 255, 128, 128, 128 },
{ 64, 177, 109, 255, 128, 128, 128 },
{ 96, 179, 145, 255, 128, 128, 128 },
{ 164, 77, 114, 255, 128, 128, 128 },
{ 87, 94, 156, 255, 128, 128, 128 },
{ 105, 57, 173, 255, 128, 128, 128 },
{ 63, 158, 137, 255, 128, 128, 128 },
{ 236, 102, 156, 255, 128, 128, 128 },
{ 197, 115, 153, 255, 128, 128, 128 },
{ 245, 106, 154, 255, 128, 128, 128 },
}, { // 5 colors
{ 179, 64, 97, 129, 255, 128, 128 },
{ 137, 56, 88, 125, 255, 128, 128 },
{ 82, 107, 61, 118, 255, 128, 128 },
{ 59, 113, 86, 115, 255, 128, 128 },
{ 23, 88, 118, 130, 255, 128, 128 },
{ 213, 66, 90, 125, 255, 128, 128 },
{ 37, 181, 103, 121, 255, 128, 128 },
{ 47, 188, 61, 131, 255, 128, 128 },
{ 104, 185, 103, 144, 255, 128, 128 },
{ 163, 39, 76, 112, 255, 128, 128 },
{ 94, 74, 131, 126, 255, 128, 128 },
{ 142, 42, 103, 163, 255, 128, 128 },
{ 53, 162, 99, 149, 255, 128, 128 },
{ 239, 54, 84, 108, 255, 128, 128 },
{ 203, 84, 110, 147, 255, 128, 128 },
{ 248, 70, 105, 151, 255, 128, 128 },
}, { // 6 colors
{ 189, 50, 67, 90, 130, 255, 128 },
{ 114, 50, 55, 90, 123, 255, 128 },
{ 66, 76, 54, 82, 128, 255, 128 },
{ 43, 69, 69, 80, 129, 255, 128 },
{ 22, 59, 87, 88, 141, 255, 128 },
{ 203, 49, 68, 87, 122, 255, 128 },
{ 43, 157, 74, 104, 146, 255, 128 },
{ 54, 138, 51, 95, 138, 255, 128 },
{ 82, 171, 58, 102, 146, 255, 128 },
{ 129, 38, 59, 64, 168, 255, 128 },
{ 56, 67, 119, 92, 112, 255, 128 },
{ 96, 62, 53, 132, 82, 255, 128 },
{ 60, 147, 77, 108, 145, 255, 128 },
{ 238, 76, 73, 93, 148, 255, 128 },
{ 189, 86, 73, 103, 157, 255, 128 },
{ 246, 62, 75, 83, 167, 255, 128 },
}, { // 7 colors
{ 179, 42, 51, 73, 99, 134, 255 },
{ 119, 52, 52, 61, 64, 114, 255 },
{ 53, 77, 35, 65, 71, 131, 255 },
{ 38, 70, 51, 68, 89, 144, 255 },
{ 23, 65, 128, 73, 97, 131, 255 },
{ 210, 47, 52, 63, 81, 143, 255 },
{ 42, 159, 57, 68, 98, 143, 255 },
{ 49, 153, 45, 82, 93, 143, 255 },
{ 81, 169, 52, 72, 113, 151, 255 },
{ 136, 46, 35, 56, 75, 96, 255 },
{ 57, 84, 109, 47, 107, 131, 255 },
{ 128, 78, 57, 36, 128, 85, 255 },
{ 54, 149, 68, 77, 94, 153, 255 },
{ 243, 58, 50, 71, 81, 167, 255 },
{ 189, 92, 64, 70, 121, 173, 255 },
{ 248, 35, 38, 51, 82, 201, 255 },
}, { // 8 colors
{ 201, 40, 36, 42, 64, 92, 123 },
{ 116, 43, 33, 43, 73, 102, 128 },
{ 46, 77, 37, 69, 62, 78, 150 },
{ 40, 65, 52, 50, 76, 89, 133 },
{ 28, 48, 91, 17, 64, 77, 133 },
{ 218, 43, 43, 37, 56, 72, 163 },
{ 41, 155, 44, 83, 82, 129, 180 },
{ 44, 141, 29, 55, 64, 89, 147 },
{ 92, 166, 48, 45, 59, 126, 179 },
{ 169, 35, 49, 41, 36, 99, 139 },
{ 55, 77, 77, 56, 60, 75, 156 },
{ 155, 81, 51, 64, 57, 182, 255 },
{ 60, 134, 49, 49, 93, 128, 174 },
{ 244, 98, 51, 46, 22, 73, 238 },
{ 189, 70, 40, 87, 93, 79, 201 },
{ 248, 54, 49, 40, 29, 42, 227 },
}
};
#endif // CONFIG_PALETTE
#if CONFIG_SUPERTX
@ -625,11 +855,11 @@ void vp9_init_mode_probs(FRAME_CONTEXT *fc) {
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_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_color_prob, default_palette_color_prob);
vp9_copy(fc->palette_uv_color_prob, default_palette_uv_color_prob);
#endif // CONFIG_PALETTE
#if CONFIG_SUPERTX
vp9_copy(fc->supertx_prob, default_supertx_prob);
@ -827,18 +1057,6 @@ void vp9_adapt_mode_probs(VP9_COMMON *cm) {
#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],

11
vp9/common/vp9_entropymode.h
View File

@ -69,12 +69,14 @@ typedef struct frame_contexts {
#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_run_length_prob[10][PALETTE_RUN_LENGTHS - 1];
vp9_prob palette_uv_size_prob[10][PALETTE_SIZES - 1];
vp9_prob palette_uv_run_length_prob[10][PALETTE_RUN_LENGTHS - 1];
vp9_prob palette_color_prob[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS]
[PALETTE_COLORS - 1];
vp9_prob palette_uv_color_prob[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS]
[PALETTE_COLORS - 1];
#endif // CONFIG_PALETTE
#if CONFIG_SUPERTX
vp9_prob supertx_prob[PARTITION_SUPERTX_CONTEXTS][TX_SIZES];
@ -169,14 +171,15 @@ extern const vp9_tree_index vp9_switchable_interp_tree
[TREE_SIZE(SWITCHABLE_FILTERS)];
#if CONFIG_EXT_TX
extern const vp9_tree_index vp9_ext_tx_tree[TREE_SIZE(EXT_TX_TYPES)];
#endif
#endif // CONFIG_EXT_TX
#if CONFIG_PALETTE
extern const vp9_tree_index vp9_palette_size_tree[TREE_SIZE(PALETTE_SIZES)];
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)];
#endif
extern const vp9_tree_index vp9_palette_color_tree[TREE_SIZE(PALETTE_COLORS)];
#endif // CONFIG_PALETTE
#if CONFIG_COPY_MODE
extern const vp9_tree_index vp9_copy_mode_tree_l2[TREE_SIZE(2)];
extern const vp9_tree_index vp9_copy_mode_tree[TREE_SIZE(COPY_MODE_COUNT - 1)];

12
vp9/common/vp9_enums.h
View File

@ -157,6 +157,18 @@ typedef enum {
ZZ_SCAN,
PALETTE_SCAN_ORDERS
} PALETTE_SCAN_ORDER;
typedef enum {
PALETTE_COLOR_ONE,
PALETTE_COLOR_TWO,
PALETTE_COLOR_THREE,
PALETTE_COLOR_FOUR,
PALETTE_COLOR_FIVE,
PALETTE_COLOR_SIX,
PALETTE_COLOR_SEVEN,
PALETTE_COLOR_EIGHT,
PALETTE_COLORS
} PALETTE_COLOR;
#endif // CONFIG_PALETTE
typedef enum {

152
vp9/common/vp9_palette.c
View File

@ -16,7 +16,7 @@
#include "vp9/common/vp9_palette.h"
#if CONFIG_PALETTE
void insertion_sort(double *data, int n) {
void vp9_insertion_sort(double *data, int n) {
int i, j, k;
double val;
@ -38,7 +38,7 @@ void insertion_sort(double *data, int n) {
}
}
int count_colors(const uint8_t *src, int stride, int rows, int cols) {
int vp9_count_colors(const uint8_t *src, int stride, int rows, int cols) {
int n = 0, r, c, i, val_count[256];
uint8_t val;
vpx_memset(val_count, 0, sizeof(val_count));
@ -59,7 +59,7 @@ int count_colors(const uint8_t *src, int stride, int rows, int cols) {
return n;
}
int run_lengh_encoding(uint8_t *seq, int n, uint16_t *runs, int max_run) {
int vp9_run_lengh_encoding(uint8_t *seq, int n, uint16_t *runs, int max_run) {
int this_run, i, l = 0;
uint8_t symbol;
@ -81,7 +81,7 @@ int run_lengh_encoding(uint8_t *seq, int n, uint16_t *runs, int max_run) {
return l;
}
int run_lengh_decoding(uint16_t *runs, int l, uint8_t *seq) {
int vp9_run_lengh_decoding(uint16_t *runs, int l, uint8_t *seq) {
int i, j = 0;
for (i = 0; i < l; i += 2) {
@ -92,7 +92,8 @@ int run_lengh_decoding(uint16_t *runs, int l, uint8_t *seq) {
return j;
}
void transpose_block(uint8_t *seq_in, uint8_t *seq_out, int rows, int cols) {
static void transpose_block(uint8_t *seq_in, uint8_t *seq_out, int rows,
int cols) {
int r, c;
for (r = 0; r < cols; r++)
@ -100,8 +101,8 @@ void transpose_block(uint8_t *seq_in, uint8_t *seq_out, int rows, int cols) {
seq_out[r * rows + c] = seq_in[c * cols + r];
}
void palette_color_insertion(uint8_t *old_colors, int *m, int *count,
MB_MODE_INFO *mbmi) {
void vp9_palette_color_insertion(uint8_t *old_colors, int *m, int *count,
MB_MODE_INFO *mbmi) {
int k = *m, n = mbmi->palette_literal_size;
int i, j, l, min_idx = -1;
uint8_t *new_colors = mbmi->palette_literal_colors;
@ -149,7 +150,7 @@ void palette_color_insertion(uint8_t *old_colors, int *m, int *count,
*m = k;
}
int palette_color_lookup(uint8_t *dic, int n, uint8_t val, int bits) {
int vp9_palette_color_lookup(uint8_t *dic, int n, uint8_t val, int bits) {
int j, min, arg_min = 0, i = 1;
if (n < 1)
@ -172,7 +173,7 @@ int palette_color_lookup(uint8_t *dic, int n, uint8_t val, int bits) {
return -1;
}
int get_bit_depth(int n) {
int vp9_get_bit_depth(int n) {
int i = 1, p = 2;
while (p < n) {
i++;
@ -182,18 +183,7 @@ int get_bit_depth(int n) {
return i;
}
int palette_max_run(BLOCK_SIZE bsize) {
int table[BLOCK_SIZES] = {
32, 32, 32, 32, // BLOCK_4X4, BLOCK_4X8, BLOCK_8X4, BLOCK_8X8
64, 64, 64, 64, // BLOCK_8X16, BLOCK_16X8, BLOCK_16X16, BLOCK_16X32
64, 64, 64, 64, // BLOCK_32X16, BLOCK_32X32, BLOCK_32X64, BLOCK_64X32
64 // BLOCK_64X64
};
return table[bsize];
}
double calc_dist(double *p1, double *p2, int dim) {
static double calc_dist(double *p1, double *p2, int dim) {
double dist = 0;
int i = 0;
@ -203,8 +193,8 @@ double calc_dist(double *p1, double *p2, int dim) {
return dist;
}
void calc_indices(double *data, double *centroids, int *indices,
int n, int k, int dim) {
void vp9_calc_indices(double *data, double *centroids, int *indices,
int n, int k, int dim) {
int i, j;
double min_dist, this_dist;
@ -260,21 +250,21 @@ double calc_total_dist(double *data, double *centroids, int *indices,
return dist;
}
int k_means(double *data, double *centroids, int *indices,
int n, int k, int dim, int max_itr) {
int vp9_k_means(double *data, double *centroids, int *indices,
int n, int k, int dim, int max_itr) {
int i = 0;
int *pre_indices;
double pre_total_dist, cur_total_dist;
double pre_centroids[256];
pre_indices = vpx_memalign(16, n * sizeof(indices[0]));
calc_indices(data, centroids, indices, n, k, dim);
vp9_calc_indices(data, centroids, indices, n, k, dim);
pre_total_dist = calc_total_dist(data, centroids, indices, n, k, dim);
vpx_memcpy(pre_centroids, centroids, sizeof(pre_centroids[0]) * k * dim);
vpx_memcpy(pre_indices, indices, sizeof(pre_indices[0]) * n);
while (i < max_itr) {
calc_centroids(data, centroids, indices, n, k, dim);
calc_indices(data, centroids, indices, n, k, dim);
vp9_calc_indices(data, centroids, indices, n, k, dim);
cur_total_dist = calc_total_dist(data, centroids, indices, n, k, dim);
if (cur_total_dist > pre_total_dist && 0) {
@ -295,13 +285,13 @@ int k_means(double *data, double *centroids, int *indices,
return i;
}
int is_in_boundary(int rows, int cols, int r, int c) {
static int is_in_boundary(int rows, int cols, int r, int c) {
if (r < 0 || r >= rows || c < 0 || c >= cols)
return 0;
return 1;
}
void zz_scan_order(int *order, int rows, int cols) {
static void zz_scan_order(int *order, int rows, int cols) {
int r, c, dir, idx;
vpx_memset(order, 0, sizeof(order[0]) * rows * cols);
@ -338,8 +328,8 @@ void zz_scan_order(int *order, int rows, int cols) {
order[idx] = (rows - 1) * cols + cols - 1;
}
void spiral_order(int *order, int cols, int r_start, int c_start,
int h, int w, int idx) {
static void spiral_order(int *order, int cols, int r_start, int c_start,
int h, int w, int idx) {
int r, c;
if (h <= 0 && w <= 0) {
@ -369,12 +359,12 @@ void spiral_order(int *order, int cols, int r_start, int c_start,
spiral_order(order, cols, r_start + 1, c_start + 1, h - 2, w - 2, idx);
}
void spiral_scan_order(int *order, int rows, int cols) {
static void spiral_scan_order(int *order, int rows, int cols) {
spiral_order(order, cols, 0, 0, rows - 1, cols - 1, 0);
}
void palette_scan(uint8_t *color_index_map, uint8_t *sequence,
int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order) {
void vp9_palette_scan(uint8_t *color_index_map, uint8_t *sequence, int rows,
int cols, PALETTE_SCAN_ORDER ps, int *scan_order) {
int i;
switch (ps) {
@ -399,8 +389,8 @@ void palette_scan(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) {
void vp9_palette_iscan(uint8_t *color_index_map, uint8_t *sequence, int rows,
int cols, PALETTE_SCAN_ORDER ps, int *scan_order) {
int i;
switch (ps) {
@ -425,21 +415,97 @@ void palette_iscan(uint8_t *color_index_map, uint8_t *sequence,
}
}
void update_palette_counts(FRAME_COUNTS *counts, MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize, int palette_ctx) {
void vp9_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]]++;
if (mbmi->palette_enabled[0])
counts->y_palette_size[idx][mbmi->palette_size[0] - 2]++;
if (mbmi->palette_enabled[1])
counts->uv_palette_size[idx][mbmi->palette_size[1] - 2]++;
}
static const int palette_color_context_lookup[PALETTE_COLOR_CONTEXTS] = {
3993, 4235, 4378, 4380, // (3, 0, 0, 0), (3, 2, 0, 0),
// (3, 3, 2, 0), (3, 3, 2, 2),
5720, 6655, 7018, 7040, // (4, 3, 3, 0), (5, 0, 0, 0),
// (5, 3, 0, 0), (5, 3, 2, 0),
7260, 8228, 8250, 8470, // (5, 5, 0, 0), (6, 2, 0, 0),
// (6, 2, 2, 0), (6, 4, 0, 0),
9680, 10648, 10890, 13310 // (7, 3, 0, 0), (8, 0, 0, 0),
// (8, 2, 0, 0), (10, 0, 0, 0)
};
int vp9_get_palette_color_context(uint8_t *color_map, int cols,
int r, int c, int n, int *color_order) {
int i, j, max, max_idx, temp;
int scores[PALETTE_MAX_SIZE];
int weights[4] = {3, 2, 3, 2};
int color_ctx = 0;
int color_neighbors[4];
assert(n <= PALETTE_MAX_SIZE);
if (c - 1 >= 0)
color_neighbors[0] = color_map[r * cols + c - 1];
else
color_neighbors[0] = -1;
if (c - 1 >= 0 && r - 1 >= 0)
color_neighbors[1] = color_map[(r - 1) * cols + c - 1];
else
color_neighbors[1] = -1;
if (r - 1 >= 0)
color_neighbors[2] = color_map[(r - 1) * cols + c];
else
color_neighbors[2] = -1;
if (r - 1 >= 0 && c + 1 <= cols - 1)
color_neighbors[3] = color_map[(r - 1) * cols + c + 1];
else
color_neighbors[3] = -1;
for (i = 0; i < PALETTE_MAX_SIZE; i++)
color_order[i] = i;
memset(scores, 0, PALETTE_MAX_SIZE * sizeof(scores[0]));
for (i = 0; i < 4; i++) {
if (color_neighbors[i] >= 0)
scores[color_neighbors[i]] += weights[i];
}
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]++;
for (i = 0; i < 4; i++) {
max = scores[i];
max_idx = i;
j = i + 1;
while (j < n) {
if (scores[j] > max) {
max = scores[j];
max_idx = j;
}
j++;
}
if (max_idx != i) {
temp = scores[i];
scores[i] = scores[max_idx];
scores[max_idx] = temp;
temp = color_order[i];
color_order[i] = color_order[max_idx];
color_order[max_idx] = temp;
}
}
for (i = 0; i < 4; i++)
color_ctx = color_ctx * 11 + scores[i];
for (i = 0; i < PALETTE_COLOR_CONTEXTS; i++)
if (color_ctx == palette_color_context_lookup[i]) {
color_ctx = i;
break;
}
return color_ctx;
}
#endif // CONFIG_PALETTE

42
vp9/common/vp9_palette.h
View File

@ -15,28 +15,26 @@
#include "vp9/common/vp9_entropymode.h"
#if CONFIG_PALETTE
int count_colors(const uint8_t *src, int stride, int rows, int cols);
void insertion_sort(double *data, int n);
int run_lengh_encoding(uint8_t *seq, int n, uint16_t *runs, int max_run);
int run_lengh_decoding(uint16_t *runs, int l, uint8_t *seq);
void transpose_block(uint8_t *seq_in, uint8_t *seq_out, int rows, int cols);
void palette_color_insertion(uint8_t *old_colors, int *m, int *count,
MB_MODE_INFO *mbmi);
int palette_color_lookup(uint8_t *dic, int n, uint8_t val, int bits);
int palette_max_run(BLOCK_SIZE bsize);
int get_bit_depth(int n);
int k_means(double *data, double *centroids, int *indices,
int n, int k, int dim, int max_itr);
void calc_indices(double *data, double *centroids, int *indices,
int n, int k, int dim);
void zz_scan_order(int *order, int rows, int cols);
void spiral_scan_order(int *order, int rows, int cols);
void palette_scan(uint8_t *color_index_map, uint8_t *sequence,
int rows, int cols, PALETTE_SCAN_ORDER ps, int *scan_order);
void palette_iscan(uint8_t *color_index_map, uint8_t *sequence,
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);
int vp9_count_colors(const uint8_t *src, int stride, int rows, int cols);
void vp9_insertion_sort(double *data, int n);
int vp9_run_lengh_encoding(uint8_t *seq, int n, uint16_t *runs, int max_run);
int vp9_run_lengh_decoding(uint16_t *runs, int l, uint8_t *seq);
void vp9_palette_color_insertion(uint8_t *old_colors, int *m, int *count,
MB_MODE_INFO *mbmi);
int vp9_palette_color_lookup(uint8_t *dic, int n, uint8_t val, int bits);
int vp9_get_bit_depth(int n);
int vp9_k_means(double *data, double *centroids, int *indices,
int n, int k, int dim, int max_itr);
void vp9_calc_indices(double *data, double *centroids, int *indices,
int n, int k, int dim);
void vp9_palette_scan(uint8_t *color_index_map, uint8_t *sequence, int rows,
int cols, PALETTE_SCAN_ORDER ps, int *scan_order);
void vp9_palette_iscan(uint8_t *color_index_map, uint8_t *sequence, int rows,
int cols, PALETTE_SCAN_ORDER ps, int *scan_order);
void vp9_update_palette_counts(FRAME_COUNTS *counts, MB_MODE_INFO *mbmi,
BLOCK_SIZE bsize, int palette_ctx);
int vp9_get_palette_color_context(uint8_t *color_map, int cols,
int r, int c, int n, int *color_order);
#endif
#endif // VP9_COMMON_VP9_PALETTE_H_

182
vp9/decoder/vp9_decodemv.c
View File

@ -240,10 +240,11 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
}
if (mbmi->palette_enabled[0]) {
int i, m1, m2, d, val;
int i, j, m1, m2, val, n, color_idx, color_ctx;
int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
PALETTE_RUN_LENGTH bits;
int color_order[PALETTE_MAX_SIZE];
uint8_t *color_map = xd->plane[0].color_index_map;
mbmi->mode = DC_PRED;
mbmi->palette_size[0] =
@ -265,19 +266,14 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
else
mbmi->palette_delta_bitdepth = 0;
mbmi->palette_run_length[0] =
vp9_read_literal(r, get_bit_depth(palette_max_run(bsize)));
mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1;
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;
m2 = mbmi->palette_literal_size;
n = mbmi->palette_size[0];
if (m1 > 0) {
for (i = 0; i < m1; i++)
mbmi->palette_indexed_colors[i] =
vp9_read_literal(r, get_bit_depth(cm->current_palette_size));
vp9_read_literal(r, vp9_get_bit_depth(cm->current_palette_size));
if (mbmi->palette_delta_bitdepth > 0) {
int s;
for (i = 0; i < m1; i++) {
@ -304,54 +300,40 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
}
}
d = get_bit_depth(rows * cols);
for (i = 0; i < mbmi->palette_run_length[0]; i += 2) {
mbmi->palette_runs[i] =
vp9_read_literal(r, get_bit_depth(m1 + m2));
vp9_palette_color_insertion(cm->current_palette_colors,
&cm ->current_palette_size,
cm->current_palette_count, mbmi);
bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc.palette_run_length_prob[bsize - BLOCK_8X8]);
if (bits == MAX_BITS)
mbmi->palette_runs[i + 1] = vp9_read_literal(r, d);
else
mbmi->palette_runs[i + 1] = vp9_read_literal(r, bits - ONE_BITS + 1);
mbmi->palette_runs[i + 1] += 1;
color_map[0] = vp9_read_literal(r,
vp9_get_bit_depth(mbmi->palette_size[0]));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
color_idx = vp9_read_tree(r, vp9_palette_color_tree,
cm->fc.palette_color_prob[n - 2][color_ctx]);
color_map[i * cols + j] = color_order[color_idx];
}
}
palette_color_insertion(cm->current_palette_colors,
&cm ->current_palette_size,
cm->current_palette_count, mbmi);
run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
mbmi->tx_size = MIN(max_txsize_lookup[bsize],
tx_mode_to_biggest_tx_size[cm->tx_mode]);
}
if (mbmi->palette_enabled[1]) {
int i, d;
int i, j;
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x;
PALETTE_RUN_LENGTH bits;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
mbmi->uv_mode = DC_PRED;
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
mbmi->palette_size[1] =
vp9_read_tree(r, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8]);
mbmi->palette_size[1] += 2;
mbmi->palette_run_length[1] =
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_scan_order[1] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8]);
} else {
mbmi->palette_size[1] = mbmi->palette_size[0];
}
@ -362,25 +344,21 @@ static void read_intra_frame_mode_info(VP9_COMMON *const cm,
mbmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = vp9_read_literal(r, 8);
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
d = get_bit_depth(rows * cols);
for (i = 0; i < mbmi->palette_run_length[1]; i += 2) {
mbmi->palette_runs[PALETTE_MAX_RUNS + i] =
vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1]));
bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc.
palette_uv_run_length_prob[bsize - BLOCK_8X8]);
if (bits == MAX_BITS)
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] = vp9_read_literal(r, d);
else
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] =
vp9_read_literal(r, bits - ONE_BITS + 1);
mbmi->palette_runs[ PALETTE_MAX_RUNS + i + 1] += 1;
}
int color_idx = 0, color_ctx = 0;
int n = mbmi->palette_size[1];
int color_order[PALETTE_MAX_SIZE];
uint8_t *color_map = xd->plane[1].color_index_map;
run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer, rows,
cols, mbmi->palette_scan_order[1], xd->palette_scan_buffer);
color_map[0] = vp9_read_literal(r, vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
color_idx = vp9_read_tree(r, vp9_palette_color_tree,
cm->fc.palette_uv_color_prob[n - 2][color_ctx]);
color_map[i * cols + j] = color_order[color_idx];
}
}
}
}
@ -1283,45 +1261,36 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
if (mbmi->palette_enabled[0]) {
BLOCK_SIZE bsize = mbmi->sb_type;
int i, d;
int i, j, n, color_ctx, color_idx;
int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
PALETTE_RUN_LENGTH bits;
int color_order[PALETTE_MAX_SIZE];
uint8_t *color_map = xd->plane[0].color_index_map;
mbmi->mode = DC_PRED;
mbmi->palette_size[0] =
vp9_read_tree(r, vp9_palette_size_tree,
cm->fc.palette_size_prob[bsize - BLOCK_8X8]);
mbmi->palette_size[0] += 2;
mbmi->palette_run_length[0] =
vp9_read_literal(r, get_bit_depth(palette_max_run(bsize)));
mbmi->palette_run_length[0] = (mbmi->palette_run_length[0]) << 1;
mbmi->palette_scan_order[0] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_scan_order_prob[bsize - BLOCK_8X8]);
n = mbmi->palette_size[0];
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);
color_map[0] = vp9_read_literal(r,
vp9_get_bit_depth(mbmi->palette_size[0]));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
color_idx = vp9_read_tree(r, vp9_palette_color_tree,
cm->fc.palette_color_prob[n - 2]
[color_ctx]);
color_map[i * cols + j] = color_order[color_idx];
}
}
d = get_bit_depth(rows * cols);
for (i = 0; i < mbmi->palette_run_length[0]; i += 2) {
mbmi->palette_runs[i] =
vp9_read_literal(r, get_bit_depth(mbmi->palette_size[0]));
bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc.palette_run_length_prob[bsize - BLOCK_8X8]);
if (bits == MAX_BITS)
mbmi->palette_runs[i + 1] = vp9_read_literal(r, d);
else
mbmi->palette_runs[i + 1] = vp9_read_literal(r, bits - ONE_BITS + 1);
mbmi->palette_runs[i + 1] += 1;
}
run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer, rows,
cols, mbmi->palette_scan_order[0], xd->palette_scan_buffer);
mbmi->tx_size = MIN(max_txsize_lookup[bsize],
tx_mode_to_biggest_tx_size[cm->tx_mode]);
if (!cm->frame_parallel_decoding_mode)
@ -1330,14 +1299,12 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
}
if (mbmi->palette_enabled[1]) {
int i, d;
int i, j;
BLOCK_SIZE bsize = mbmi->sb_type;
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x;
PALETTE_RUN_LENGTH bits;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
mbmi->uv_mode = DC_PRED;
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
@ -1345,12 +1312,6 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
vp9_read_tree(r, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8]);
mbmi->palette_size[1] += 2;
mbmi->palette_run_length[1] =
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_scan_order[1] =
vp9_read_tree(r, vp9_palette_scan_order_tree,
cm->fc.palette_uv_scan_order_prob[bsize - BLOCK_8X8]);
} else {
mbmi->palette_size[1] = mbmi->palette_size[0];
}
@ -1361,27 +1322,22 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
mbmi->palette_colors[2 * PALETTE_MAX_SIZE + i] = vp9_read_literal(r, 8);
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
d = get_bit_depth(rows * cols);
for (i = 0; i < mbmi->palette_run_length[1]; i += 2) {
mbmi->palette_runs[PALETTE_MAX_RUNS + i] =
vp9_read_literal(r, get_bit_depth(mbmi->palette_size[1]));
bits = vp9_read_tree(r, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[bsize -
BLOCK_8X8]);
if (bits == MAX_BITS)
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] =
vp9_read_literal(r, d);
else
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1] =
vp9_read_literal(r, bits - ONE_BITS + 1);
mbmi->palette_runs[ PALETTE_MAX_RUNS + i + 1] += 1;
}
int color_idx = 0, color_ctx = 0;
int n = mbmi->palette_size[1];
int color_order[PALETTE_MAX_SIZE];
uint8_t *color_map = xd->plane[1].color_index_map;
run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
color_map[0] = vp9_read_literal(r, vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
color_idx = vp9_read_tree(r, vp9_palette_color_tree,
cm->fc.palette_uv_color_prob[n - 2]
[color_ctx]);
color_map[i * cols + j] = color_order[color_idx];
}
}
}
}
@ -1397,7 +1353,7 @@ static void read_inter_frame_mode_info(VP9_COMMON *const cm,
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);
vp9_update_palette_counts(&cm->counts, mbmi, bsize, palette_ctx);
}
if (!mbmi->palette_enabled[0]) {

222
vp9/encoder/vp9_bitstream.c
View File

@ -22,7 +22,7 @@
#include "vp9/common/vp9_mvref_common.h"
#if CONFIG_PALETTE
#include "vp9/common/vp9_palette.h"
#endif
#endif // CONFIG_PALETTE
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_systemdependent.h"
@ -48,7 +48,8 @@ static struct vp9_token ext_tx_encodings[EXT_TX_TYPES];
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];
#endif
static struct vp9_token palette_color_encodings[PALETTE_COLORS];
#endif // CONFIG_PALETTE
#if CONFIG_COPY_MODE
static struct vp9_token copy_mode_encodings_l2[2];
static struct vp9_token copy_mode_encodings[COPY_MODE_COUNT - 1];
@ -83,7 +84,8 @@ void vp9_entropy_mode_init() {
vp9_palette_scan_order_tree);
vp9_tokens_from_tree(palette_run_length_encodings,
vp9_palette_run_length_tree);
#endif
vp9_tokens_from_tree(palette_color_encodings, vp9_palette_color_tree);
#endif // CONFIG_PALETTE
#if CONFIG_COMPOUND_MODES
vp9_tokens_from_tree(inter_compound_mode_encodings,
vp9_inter_compound_mode_tree);
@ -467,75 +469,70 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
#if CONFIG_PALETTE
if (!is_inter && bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
int l, n, i, d, bits, ctx;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
int n, i, j, k, rows, cols, palette_ctx, color_ctx;
int color_new_idx = -1, color_order[PALETTE_MAX_SIZE];
uint8_t buffer[4096];
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;
ctx = 0;
palette_ctx = 0;
if (above_mi)
ctx += (above_mi->mbmi.palette_enabled[0] == 1);
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
ctx += (left_mi->mbmi.palette_enabled[0] == 1);
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
vp9_write(w, mbmi->palette_enabled[0],
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][ctx]);
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][palette_ctx]);
vp9_write(w, mbmi->palette_enabled[1],
cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
if (mbmi->palette_enabled[0]) {
int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
rows = 4 * num_4x4_blocks_high_lookup[bsize];
cols = 4 * num_4x4_blocks_wide_lookup[bsize];
n = mbmi->palette_size[0];
l = mbmi->palette_run_length[0];
vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_size_prob[bsize - BLOCK_8X8],
&palette_size_encodings[n - 2]);
vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(bsize)));
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++)
vp9_write_literal(w, mbmi->palette_colors[i], 8);
d = get_bit_depth(rows * cols);
for (i = 0; i < l; i += 2) {
vp9_write_literal(w, mbmi->palette_runs[i],
get_bit_depth(n));
bits = get_bit_depth(mbmi->palette_runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_run_length_prob[bsize - BLOCK_8X8],
&palette_run_length_encodings[bits > 6 ?
6 : bits - 1]);
vp9_write_literal(w, mbmi->palette_runs[i + 1] - 1,
bits > 6 ? d : bits);
vp9_run_lengh_decoding(cpi->mb.e_mbd.mi->mbmi.palette_runs,
mbmi->palette_run_length[0],
cpi->mb.e_mbd.palette_map_buffer);
vp9_palette_iscan(buffer, cpi->mb.e_mbd.palette_map_buffer, rows, cols,
mbmi->palette_scan_order[0],
cpi->mb.e_mbd.palette_scan_buffer);
vp9_write_literal(w, buffer[0], vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(buffer, cols, i, j, n,
color_order);
for (k = 0; k < n; k++)
if (buffer[i * cols + j] == color_order[k]) {
color_new_idx = k;
break;
}
vp9_write_token(w, vp9_palette_color_tree,
cm->fc.palette_color_prob[n - 2][color_ctx],
&palette_color_encodings[color_new_idx]);
}
}
}
if (mbmi->palette_enabled[1]) {
const uint16_t *runs = mbmi->palette_runs + PALETTE_MAX_RUNS;
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x;
n = mbmi->palette_size[1];
l = mbmi->palette_run_length[1];
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8],
&palette_size_encodings[n - 2]);
vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(uv_bsize)));
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++)
@ -544,17 +541,27 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
vp9_write_literal(w, mbmi->palette_colors[2 * PALETTE_MAX_SIZE + i], 8);
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
d = get_bit_depth(rows * cols);
for (i = 0; i < l; i += 2) {
vp9_write_literal(w, runs[i],
get_bit_depth(mbmi->palette_size[1]));
bits = get_bit_depth(runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[bsize - BLOCK_8X8],
&palette_run_length_encodings[bits > 6 ?
6 : bits - 1]);
vp9_write_literal(w, runs[i + 1] - 1,
bits > 6 ? d : bits);
vp9_run_lengh_decoding(cpi->mb.e_mbd.mi->mbmi.palette_runs +
PALETTE_MAX_RUNS,
mbmi->palette_run_length[1],
cpi->mb.e_mbd.palette_map_buffer);
vp9_palette_iscan(buffer, cpi->mb.e_mbd.palette_map_buffer, rows,
cols, mbmi->palette_scan_order[1],
cpi->mb.e_mbd.palette_scan_buffer);
vp9_write_literal(w, buffer[0], vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(buffer, cols, i, j, n,
color_order);
for (k = 0; k < n; k++)
if (buffer[i * cols + j] == color_order[k]) {
color_new_idx = k;
break;
}
vp9_write_token(w, vp9_palette_color_tree,
cm->fc.palette_uv_color_prob[n - 2][color_ctx],
&palette_color_encodings[color_new_idx]);
}
}
}
}
@ -836,7 +843,12 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
}
}
static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
static void write_mb_modes_kf(const VP9_COMMON *cm,
#if CONFIG_PALETTE
MACROBLOCKD *xd,
#else
const MACROBLOCKD *xd,
#endif // CONFIG_PALETTE
MODE_INFO *mi_8x8, vp9_writer *w) {
const struct segmentation *const seg = &cm->seg;
const MODE_INFO *const mi = mi_8x8;
@ -853,25 +865,26 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
#if CONFIG_PALETTE
if (bsize >= BLOCK_8X8 && cm->allow_palette_mode) {
int l, m1, m2, i, d, bits, ctx;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
int n, m1, m2, i, j, k, rows, cols, palette_ctx, color_ctx;
int color_new_idx = -1, color_order[PALETTE_MAX_SIZE];
uint8_t buffer[4096];
ctx = 0;
palette_ctx = 0;
if (above_mi)
ctx += (above_mi->mbmi.palette_enabled[0] == 1);
palette_ctx += (above_mi->mbmi.palette_enabled[0] == 1);
if (left_mi)
ctx += (left_mi->mbmi.palette_enabled[0] == 1);
palette_ctx += (left_mi->mbmi.palette_enabled[0] == 1);
vp9_write(w, mbmi->palette_enabled[0],
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][ctx]);
cm->fc.palette_enabled_prob[bsize - BLOCK_8X8][palette_ctx]);
vp9_write(w, mbmi->palette_enabled[1],
cm->fc.palette_uv_enabled_prob[mbmi->palette_enabled[0]]);
if (mbmi->palette_enabled[0]) {
int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
rows = 4 * num_4x4_blocks_high_lookup[bsize];
cols = 4 * num_4x4_blocks_wide_lookup[bsize];
n = mbmi->palette_size[0];
m1 = mbmi->palette_indexed_size;
m2 = mbmi->palette_literal_size;
l = mbmi->palette_run_length[0];
vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_size_prob[bsize - BLOCK_8X8],
@ -880,20 +893,13 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
|| !mbmi->palette_enabled[1])
vp9_encode_uniform(w, MIN(mbmi->palette_size[0] + 1, 8),
mbmi->palette_indexed_size);
if (PALETTE_DELTA_BIT)
vp9_write_literal(w, mbmi->palette_delta_bitdepth, PALETTE_DELTA_BIT);
vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(bsize)));
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) {
for (i = 0; i < m1; i++)
vp9_write_literal(w, mbmi->palette_indexed_colors[i],
get_bit_depth(mbmi->current_palette_size));
vp9_get_bit_depth(mbmi->current_palette_size));
if (mbmi->palette_delta_bitdepth > 0) {
for (i = 0; i < m1; i++) {
vp9_write_bit(w, mbmi->palette_color_delta[i] < 0);
@ -907,57 +913,67 @@ static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
vp9_write_literal(w, mbmi->palette_literal_colors[i], 8);
}
d = get_bit_depth(rows * cols);
for (i = 0; i < l; i += 2) {
vp9_write_literal(w, mbmi->palette_runs[i],
get_bit_depth(m1 + m2));
bits = get_bit_depth(mbmi->palette_runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_run_length_prob[bsize - BLOCK_8X8],
&palette_run_length_encodings[bits > 6 ?
6 : bits - 1]);
vp9_write_literal(w, mbmi->palette_runs[i + 1] - 1,
bits > 6 ? d : bits);
vp9_run_lengh_decoding(mi_8x8->mbmi.palette_runs,
mbmi->palette_run_length[0],
xd->palette_map_buffer);
vp9_palette_iscan(buffer, xd->palette_map_buffer, rows, cols,
mbmi->palette_scan_order[0], xd->palette_scan_buffer);
vp9_write_literal(w, buffer[0], vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(buffer, cols, i, j, n,
color_order);
for (k = 0; k < n; k++)
if (buffer[i * cols + j] == color_order[k]) {
color_new_idx = k;
break;
}
vp9_write_token(w, vp9_palette_color_tree,
cm->fc.palette_color_prob[n - 2][color_ctx],
&palette_color_encodings[color_new_idx]);
}
}
}
if (mbmi->palette_enabled[1]) {
const uint16_t *runs = mbmi->palette_runs + PALETTE_MAX_RUNS;
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_x;
l = mbmi->palette_run_length[1];
n = mbmi->palette_size[1];
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
vp9_write_token(w, vp9_palette_size_tree,
cm->fc.palette_uv_size_prob[bsize - BLOCK_8X8],
&palette_size_encodings[mbmi->palette_size[1] - 2]);
vp9_write_literal(w, (l >> 1),
get_bit_depth(palette_max_run(uv_bsize)));
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]]);
&palette_size_encodings[n - 2]);
}
for (i = 0; i < mbmi->palette_size[1]; i++)
for (i = 0; i < n; i++)
vp9_write_literal(w, mbmi->palette_colors[PALETTE_MAX_SIZE + i], 8);
for (i = 0; i < mbmi->palette_size[1]; i++)
for (i = 0; i < n; i++)
vp9_write_literal(w, mbmi->palette_colors[2 * PALETTE_MAX_SIZE + i], 8);
if (xd->plane[1].subsampling_x && xd->plane[1].subsampling_y) {
d = get_bit_depth(rows * cols);
for (i = 0; i < l; i += 2) {
vp9_write_literal(w, runs[i],
get_bit_depth(mbmi->palette_size[1]));
bits = get_bit_depth(runs[i + 1]);
vp9_write_token(w, vp9_palette_run_length_tree,
cm->fc.palette_uv_run_length_prob[bsize - BLOCK_8X8],
&palette_run_length_encodings[bits > 6 ?
6 : bits - 1]);
vp9_write_literal(w, runs[i + 1] - 1,
bits > 6 ? d : bits);
vp9_run_lengh_decoding(mi_8x8->mbmi.palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1],
xd->palette_map_buffer);
vp9_palette_iscan(buffer, xd->palette_map_buffer, rows,
cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
vp9_write_literal(w, buffer[0], vp9_get_bit_depth(n));
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(buffer, cols, i, j, n,
color_order);
for (k = 0; k < n; k++)
if (buffer[i * cols + j] == color_order[k]) {
color_new_idx = k;
break;
}
vp9_write_token(w, vp9_palette_color_tree,
cm->fc.palette_uv_color_prob[n - 2][color_ctx],
&palette_color_encodings[color_new_idx]);
}
}
}
}

10
vp9/encoder/vp9_encodeframe.c
View File

@ -795,7 +795,7 @@ static void update_state(VP9_COMP *cpi, PICK_MODE_CONTEXT *ctx,
for (i = 0; i < 2; i++) {
pd[i].color_index_map = ctx->color_index_map[i];
}
#endif
#endif // CONFIG_PALETTE
// Restore the coding context of the MB to that that was in place
// when the mode was picked for it
@ -4989,9 +4989,9 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
vp9_tokenize_sb(cpi, t, !output_enabled, MAX(bsize, BLOCK_8X8));
#if CONFIG_PALETTE
if (mbmi->palette_enabled[0] && output_enabled) {
palette_color_insertion(cm->current_palette_colors,
&cm ->current_palette_size,
cm->current_palette_count, mbmi);
vp9_palette_color_insertion(cm->current_palette_colors,
&cm ->current_palette_size,
cm->current_palette_count, mbmi);
}
if (frame_is_intra_only(cm) && output_enabled && bsize >= BLOCK_8X8) {
cm->block_counter++;
@ -5080,7 +5080,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled,
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);
vp9_update_palette_counts(&cm->counts, mbmi, bsize, palette_ctx);
}
#endif // CONFIG_PALETTE
}

10
vp9/encoder/vp9_encoder.h
View File

@ -398,11 +398,17 @@ typedef struct VP9_COMP {
int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
#if CONFIG_EXT_TX
int ext_tx_costs[3][EXT_TX_TYPES];
#endif
#endif // CONFIG_EXT_TX
#if CONFIG_COPY_MODE
int copy_mode_cost_l2[COPY_MODE_CONTEXTS][2];
int copy_mode_cost[COPY_MODE_CONTEXTS][COPY_MODE_COUNT - 1];
#endif
#endif // CONFIG_COPY_MODE
#if CONFIG_PALETTE
int palette_color_costs[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS]
[PALETTE_COLORS];
int palette_uv_color_costs[PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS]
[PALETTE_COLORS];
#endif // CONFIG_PALETTE
PICK_MODE_CONTEXT *leaf_tree;
PC_TREE *pc_tree;

12
vp9/encoder/vp9_rd.c
View File

@ -85,7 +85,17 @@ static void fill_mode_costs(VP9_COMP *cpi) {
#if CONFIG_EXT_TX
for (i = TX_4X4; i <= TX_16X16; ++i)
vp9_cost_tokens(cpi->ext_tx_costs[i], fc->ext_tx_prob[i], vp9_ext_tx_tree);
#endif
#endif // CONFIG_EXT_TX
#if CONFIG_PALETTE
for (i = 0; i < PALETTE_MAX_SIZE - 1; ++i)
for (j = 0; j < PALETTE_COLOR_CONTEXTS; ++j)
vp9_cost_tokens(cpi->palette_color_costs[i][j],
fc->palette_color_prob[i][j], vp9_palette_color_tree);
for (i = 0; i < PALETTE_MAX_SIZE - 1; ++i)
for (j = 0; j < PALETTE_COLOR_CONTEXTS; ++j)
vp9_cost_tokens(cpi->palette_uv_color_costs[i][j],
fc->palette_uv_color_prob[i][j], vp9_palette_color_tree);
#endif // CONFIG_PALETTE
}
static void fill_token_costs(vp9_coeff_cost *c,

595
vp9/encoder/vp9_rdopt.c
View File

@ -22,7 +22,7 @@
#include "vp9/common/vp9_mvref_common.h"
#if CONFIG_PALETTE
#include "vp9/common/vp9_palette.h"
#endif
#endif // CONFIG_PALETTE
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_quant_common.h"
#include "vp9/common/vp9_reconinter.h"
@ -1506,17 +1506,19 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
#if CONFIG_PALETTE
mic->mbmi.current_palette_size = cpi->common.current_palette_size;
colors = count_colors(src, src_stride, rows, cols);
colors = vp9_count_colors(src, src_stride, rows, cols);
if (colors > 1 && colors <= 64 && cpi->common.allow_palette_mode) {
int n, r, c, i, j, temp, max_itr = 200, k;
int l, m1, m2, d = get_bit_depth(rows * cols);
int l, m1, m2;
int bits, best_bits = 0, total_bits, best_total_bits;
int color_ctx = 0, color_idx = 0;
int color_order[PALETTE_MAX_SIZE];
int palette_size_cost[PALETTE_SIZES];
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
int palette_run_length_cost[PALETTE_RUN_LENGTHS];
double centroids[PALETTE_MAX_SIZE];
double lb = src[0], ub = src[0], val;
int64_t local_tx_cache[TX_MODES];
uint8_t *color_map;
PALETTE_SCAN_ORDER ps;
#if CONFIG_TX_SKIP
int this_rate_tokenonly_s, s_s;
@ -1531,9 +1533,6 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
vp9_cost_tokens(palette_size_cost,
cpi->common.fc.palette_size_prob[bsize - BLOCK_8X8],
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,
cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8],
vp9_palette_run_length_tree);
@ -1556,9 +1555,9 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
n >= 2; n--) {
for (i = 0; i < n; i++)
centroids[i] = lb + (2 * i + 1) * (ub - lb) / n / 2;
r = k_means(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, n, 1, max_itr);
insertion_sort(centroids, n);
r = vp9_k_means(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, n, 1, max_itr);
vp9_insertion_sort(centroids, n);
i = 1;
k = n;
while (i < k) {
@ -1582,9 +1581,9 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
m1 = 0;
m2 = 0;
for (j = 0; j < k; j++) {
temp = palette_color_lookup(cpi->common.current_palette_colors,
cpi->common.current_palette_size,
mic->mbmi.palette_colors[j], bits);
temp = vp9_palette_color_lookup(cpi->common.current_palette_colors,
cpi->common.current_palette_size,
mic->mbmi.palette_colors[j], bits);
if (temp >= 0) {
mic->mbmi.palette_indexed_colors[m1] = temp;
mic->mbmi.palette_color_delta[m1] =
@ -1597,7 +1596,7 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
m2++;
}
}
total_bits = m1 * get_bit_depth(cpi->common.current_palette_size) +
total_bits = m1 * vp9_get_bit_depth(cpi->common.current_palette_size) +
m1 * (bits == 0 ? 0 : bits + 1) + m2 * 8;
if (total_bits <= best_total_bits) {
best_total_bits = total_bits;
@ -1608,9 +1607,9 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
m1 = 0;
m2 = 0;
for (i = 0; i < k; i++) {
temp = palette_color_lookup(cpi->common.current_palette_colors,
cpi->common.current_palette_size,
mic->mbmi.palette_colors[i], best_bits);
temp = vp9_palette_color_lookup(cpi->common.current_palette_colors,
cpi->common.current_palette_size,
mic->mbmi.palette_colors[i], best_bits);
if (temp >= 0) {
mic->mbmi.palette_indexed_colors[m1] = temp;
mic->mbmi.palette_color_delta[m1] =
@ -1639,8 +1638,8 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
for (i = 0; i < k; i++) {
centroids[i] = (double) mic->mbmi.palette_colors[i];
}
calc_indices(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, k, 1);
vp9_calc_indices(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, k, 1);
for (r = 0; r < rows; r++) {
for (c = 0; c < cols; c++) {
xd->plane[0].color_index_map[r * cols + c] =
@ -1684,63 +1683,71 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
continue;
}
for (ps = H_SCAN; ps < PALETTE_SCAN_ORDERS; ps++) {
palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mic->mbmi.palette_runs, palette_max_run(bsize));
if (!l)
continue;
this_rate = this_rate_tokenonly +
(vp9_encode_uniform_cost(MIN(k + 1, 8), m1) + PALETTE_DELTA_BIT
+ get_bit_depth(palette_max_run(bsize)) +
get_bit_depth(mic->mbmi.current_palette_size) * m1 +
best_bits * m1 +
8 * m2 + get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) +
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) {
int bits = get_bit_depth(mic->mbmi.palette_runs[i + 1]);
this_rate += palette_run_length_cost[bits > 6 ? 6 : bits - 1];
this_rate += (bits > 6 ? d : bits) * vp9_cost_bit(128, 0);
for (ps = H_SCAN; ps <= PALETTE_SCAN_ORDERS; ps++) {
vp9_palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = vp9_run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mic->mbmi.palette_runs,
PALETTE_MAX_RUNS >> 1);
if (l)
break;
}
if (!l)
continue;
this_rate = this_rate_tokenonly +
(1 + vp9_encode_uniform_cost(MIN(k + 1, 8), m1) + PALETTE_DELTA_BIT
+ vp9_get_bit_depth(mic->mbmi.current_palette_size) * m1 +
best_bits * m1 + 8 * m2) * vp9_cost_bit(128, 0) +
palette_size_cost[k - 2];
color_map = xd->plane[0].color_index_map;
this_rate += vp9_get_bit_depth(k) * vp9_cost_bit(128, 0);
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
for (r = 0; r < n; r++)
if (color_map[i * cols + j] == color_order[r]) {
color_idx = r;
break;
}
this_rate += cpi->palette_color_costs[k - 2][color_ctx][color_idx];
}
}
#if CONFIG_TX_SKIP
this_rate += vp9_cost_bit(cpi->common.fc.y_tx_skip_prob[0],
mic->mbmi.tx_skip[0]);
this_rate += vp9_cost_bit(cpi->common.fc.y_tx_skip_prob[0],
mic->mbmi.tx_skip[0]);
#endif // CONFIG_TX_SKIP
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
mode_selected = DC_PRED;
best_rd = this_rd;
best_tx = mic->mbmi.tx_size;
*rate = this_rate;
*rate_tokenonly = this_rate_tokenonly;
*distortion = this_distortion;
*skippable = s;
best_n = k;
best_l = l;
palette_selected = 1;
best_ps = ps;
best_m1 = m1;
best_m2 = m2;
palette_delta_bitdepth = best_bits;
vpx_memcpy(best_palette, mic->mbmi.palette_colors,
k * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mic->mbmi.palette_runs,
l * sizeof(best_runs[0]));
vpx_memcpy(best_index, mic->mbmi.palette_indexed_colors,
best_m1 * sizeof(best_index[0]));
vpx_memcpy(palette_color_delta, mic->mbmi.palette_color_delta,
best_m1 * sizeof(palette_color_delta[0]));
vpx_memcpy(best_literal, mic->mbmi.palette_literal_colors,
best_m2 * sizeof(best_literal[0]));
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
mode_selected = DC_PRED;
best_rd = this_rd;
best_tx = mic->mbmi.tx_size;
*rate = this_rate;
*rate_tokenonly = this_rate_tokenonly;
*distortion = this_distortion;
*skippable = s;
best_n = k;
best_l = l;
palette_selected = 1;
best_ps = ps;
best_m1 = m1;
best_m2 = m2;
palette_delta_bitdepth = best_bits;
vpx_memcpy(best_palette, mic->mbmi.palette_colors,
k * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mic->mbmi.palette_runs,
l * sizeof(best_runs[0]));
vpx_memcpy(best_index, mic->mbmi.palette_indexed_colors,
best_m1 * sizeof(best_index[0]));
vpx_memcpy(palette_color_delta, mic->mbmi.palette_color_delta,
best_m1 * sizeof(palette_color_delta[0]));
vpx_memcpy(best_literal, mic->mbmi.palette_literal_colors,
best_m2 * sizeof(best_literal[0]));
#if CONFIG_TX_SKIP
tx_skipped = mic->mbmi.tx_skip[0];
tx_skipped = mic->mbmi.tx_skip[0];
#endif // CONFIG_TX_SKIP
}
}
}
}
@ -1776,11 +1783,12 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
best_m1 * sizeof(palette_color_delta[0]));
vpx_memcpy(mic->mbmi.palette_literal_colors, best_literal,
best_m2 * sizeof(best_literal[0]));
run_lengh_decoding(mic->mbmi.palette_runs, mic->mbmi.palette_run_length[0],
xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mic->mbmi.palette_scan_order[0],
xd->palette_scan_buffer);
vp9_run_lengh_decoding(mic->mbmi.palette_runs,
mic->mbmi.palette_run_length[0],
xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mic->mbmi.palette_scan_order[0],
xd->palette_scan_buffer);
#if CONFIG_FILTERINTRA
mic->mbmi.filterbit = 0;
#endif // CONFIG_FILTERINTRA
@ -2011,14 +2019,14 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
if (xd->mi[0].src_mi->mbmi.sb_type >= BLOCK_8X8 &&
xd->plane[1].subsampling_x && xd->plane[1].subsampling_y &&
cpi->common.allow_palette_mode) {
int colors_u = count_colors(src_u, src_stride, rows, cols);
int colors_v = count_colors(src_v, src_stride, rows, cols);
int colors_u = vp9_count_colors(src_u, src_stride, rows, cols);
int colors_v = vp9_count_colors(src_v, src_stride, rows, cols);
int colors = colors_u > colors_v ? colors_u : colors_v;
if (colors > 1 && colors <= 64) {
int n, r, c, i, j, max_itr = 200;
int l, d = get_bit_depth(rows * cols);
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
int n, r, c, i, j, l, max_itr = 200;
int color_ctx = 0, color_idx = 0;
int color_order[PALETTE_MAX_SIZE];
int palette_run_length_cost[PALETTE_RUN_LENGTHS];
int palette_size_cost[PALETTE_SIZES];
double centroids[2 * PALETTE_MAX_SIZE];
@ -2026,15 +2034,13 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
double lb_v = src_v[0], ub_v = src_v[0], val;
PALETTE_SCAN_ORDER ps;
BLOCK_SIZE uv_bsize = get_plane_block_size(bsize, &xd->plane[1]);
uint8_t *color_map;
#if CONFIG_TX_SKIP
int this_rate_tokenonly_s, s_s;
int64_t this_distortion_s;
#endif // CONFIG_TX_SKIP
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,
cpi->common.fc.palette_uv_size_prob[i],
vp9_palette_size_tree);
@ -2073,8 +2079,8 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
centroids[i * 2 + 1] =
lb_v + (2 * i + 1) * (ub_v - lb_v) / n / 2;;
}
r = k_means(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, n, 2, max_itr);
r = vp9_k_means(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, n, 2, max_itr);
mbmi->palette_size[1] = n;
for (i = 1; i < 3; i++) {
@ -2126,55 +2132,62 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
}
for (ps = H_SCAN; ps < PALETTE_SCAN_ORDERS; ps++) {
palette_scan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs + PALETTE_MAX_RUNS,
palette_max_run(uv_bsize));
if (!l)
continue;
vp9_palette_scan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = vp9_run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs + PALETTE_MAX_RUNS,
PALETTE_MAX_RUNS >> 1);
if (l)
break;
}
if (!l)
continue;
this_rate = this_rate_tokenonly +
(get_bit_depth(palette_max_run(uv_bsize)) + 2 * 8 * n +
get_bit_depth(n) * (l >> 1)) * vp9_cost_bit(128, 0) +
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) {
int bits = get_bit_depth(
mbmi->palette_runs[PALETTE_MAX_RUNS + i + 1]);
this_rate += palette_run_length_cost[bits > 6 ? 6 : bits - 1];
this_rate += (bits > 6 ? d : bits) * vp9_cost_bit(128, 0);
color_map = xd->plane[1].color_index_map;
this_rate = this_rate_tokenonly +
(1 + 2 * 8 * n) * vp9_cost_bit(128, 0) +
palette_size_cost[n - 2];
this_rate += vp9_get_bit_depth(n) * vp9_cost_bit(128, 0);
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
for (r = 0; r < n; r++)
if (color_map[i * cols + j] == color_order[r]) {
color_idx = r;
break;
}
this_rate += cpi->palette_uv_color_costs[n - 2][color_ctx]
[color_idx];
}
}
#if CONFIG_TX_SKIP
this_rate += vp9_cost_bit(cpi->common.fc.
uv_tx_skip_prob[mbmi->tx_skip[0]],
mbmi->tx_skip[1]);
this_rate += vp9_cost_bit(cpi->common.fc.
uv_tx_skip_prob[mbmi->tx_skip[0]],
mbmi->tx_skip[1]);
#endif // CONFIG_TX_SKIP
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
mode_selected = DC_PRED;
best_rd = this_rd;
*rate = this_rate;
*rate_tokenonly = this_rate_tokenonly;
*distortion = this_distortion;
*skippable = s;
best_n = n;
best_l = l;
palette_selected = 1;
best_ps = ps;
vpx_memcpy(best_palette, mbmi->palette_colors + PALETTE_MAX_SIZE,
2 * PALETTE_MAX_SIZE * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mbmi->palette_runs + PALETTE_MAX_RUNS,
PALETTE_MAX_RUNS * sizeof(best_runs[0]));
this_rd = RDCOST(x->rdmult, x->rddiv, this_rate, this_distortion);
if (this_rd < best_rd) {
mode_selected = DC_PRED;
best_rd = this_rd;
*rate = this_rate;
*rate_tokenonly = this_rate_tokenonly;
*distortion = this_distortion;
*skippable = s;
best_n = n;
best_l = l;
palette_selected = 1;
best_ps = ps;
vpx_memcpy(best_palette, mbmi->palette_colors + PALETTE_MAX_SIZE,
2 * PALETTE_MAX_SIZE * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mbmi->palette_runs + PALETTE_MAX_RUNS,
PALETTE_MAX_RUNS * sizeof(best_runs[0]));
#if CONFIG_TX_SKIP
tx_skipped = mbmi->tx_skip[1];
tx_skipped = mbmi->tx_skip[1];
#endif // CONFIG_TX_SKIP
#if CONFIG_FILTERINTRA
fbit_selected = 0;
fbit_selected = 0;
#endif // CONFIG_FILTERINTRA
}
}
}
}
@ -2198,11 +2211,11 @@ static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
2 * PALETTE_MAX_SIZE * sizeof(best_palette[0]));
vpx_memcpy(mbmi->palette_runs + PALETTE_MAX_RUNS, best_runs,
best_l * sizeof(best_runs[0]));
run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
vp9_run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
}
#endif // CONFIG_PALETTE
return best_rd;
@ -4858,7 +4871,7 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
int src_stride_y = x->plane[0].src.stride;
int src_stride_uv = x->plane[1].src.stride;
int colors = count_colors(src_y, src_stride_y, rows, cols);
int colors = vp9_count_colors(src_y, src_stride_y, rows, cols);
if (colors >= 2 && colors <= 64 && cm->allow_palette_mode) {
uint16_t best_runs[PALETTE_MAX_RUNS];
@ -4867,17 +4880,19 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
int8_t palette_color_delta[PALETTE_MAX_SIZE];
int64_t local_tx_cache[TX_MODES], sse;
int m1, m2, n, l, best_bits, best_n = 0, best_l = 0;
int r, c, i, j;
int d = get_bit_depth(rows * cols), max_itr = 200;
int r, c, i, j, max_itr = 200;
int palette_run_length_cost[PALETTE_RUN_LENGTHS];
int palette_size_cost[PALETTE_SIZES];
int best_m1 = 0, best_m2 = 0, palette_delta_bitdepth = 0;
int color_ctx = 0, color_idx = 0;
int color_order[PALETTE_MAX_SIZE];
double centroids[3 * PALETTE_MAX_SIZE];
double lb = src_y[0], ub = src_y[0];
MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
MB_MODE_INFO mbmi_copy;
RD_COST palette_rd, palette_best_rd;
PALETTE_SCAN_ORDER ps, best_ps = H_SCAN;
uint8_t *color_map;
#if CONFIG_TX_SKIP
int q_idx = vp9_get_qindex(&cpi->common.seg, mbmi->segment_id,
cpi->common.base_qindex);
@ -4926,8 +4941,8 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
centroids[i * 3 + 1] = 128;
centroids[i * 3 + 2] = 128;
}
r = k_means(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, n, 3, max_itr);
r = vp9_k_means(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, n, 3, max_itr);
for (i = 0; i < 3; i++) {
for (j = 0; j < n; j++)
mbmi->palette_colors[i * PALETTE_MAX_SIZE + j] =
@ -4936,13 +4951,12 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
for (r = 0; r < rows; r++)
for (c = 0; c < cols; c++)
xd->plane[0].color_index_map[r * cols + c] =
x->kmeans_data_buffer[r * cols + c];
x->kmeans_indices_buffer[r * cols + c];
m1 = 0;
m2 = n;
best_bits = 0;
vpx_memcpy(mbmi->palette_literal_colors, mbmi->palette_colors,
m2 * sizeof(mbmi->palette_literal_colors[0]));
#if CONFIG_TX_SKIP
mbmi->tx_skip[0] = 0;
mbmi->tx_skip[1] = 0;
@ -5014,65 +5028,76 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
continue;
for (ps = H_SCAN; ps < PALETTE_SCAN_ORDERS; ps++) {
palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs, palette_max_run(bsize));
if (!l)
continue;
vp9_palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = vp9_run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs, PALETTE_MAX_RUNS >> 1);
if (l)
break;
}
if (!l)
continue;
rate_y = rate_y_tokenonly +
(1 + PALETTE_DELTA_BIT + get_bit_depth(palette_max_run(bsize)) +
2 + n * m2 + get_bit_depth(n) * (l >> 1)) *
vp9_cost_bit(128, 0) + palette_size_cost[n - 2];
for (i = 0; i < l; i += 2) {
int bits = get_bit_depth(mbmi->palette_runs[i + 1]);
rate_y += palette_run_length_cost[bits > 6 ? 6 : bits - 1];
rate_y += (bits > 6 ? d : bits) * vp9_cost_bit(128, 0);
rate_y = rate_y_tokenonly +
(1 + PALETTE_DELTA_BIT + n * m2) * vp9_cost_bit(128, 0) +
palette_size_cost[n - 2];
color_map = xd->plane[0].color_index_map;
rate_y += vp9_get_bit_depth(n) * vp9_cost_bit(128, 0);
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
for (r = 0; r < n; r++)
if (color_map[i * cols + j] == color_order[r]) {
color_idx = r;
break;
}
rate_y += cpi->palette_color_costs[n - 2][color_ctx][color_idx];
}
rate_uv = rate_uv_tokenonly +
(1 + 8 * 2 * n) * vp9_cost_bit(128, 0);
}
rate_uv = rate_uv_tokenonly +
(1 + 8 * 2 * n) * vp9_cost_bit(128, 0);
#if CONFIG_TX_SKIP
rate_y += vp9_cost_bit(cpi->common.fc.y_tx_skip_prob[0],
mbmi->tx_skip[0]);
rate_uv +=
vp9_cost_bit(cpi->common.fc.uv_tx_skip_prob[mbmi->tx_skip[0]],
mbmi->tx_skip[1]);
rate_y += vp9_cost_bit(cpi->common.fc.y_tx_skip_prob[0],
mbmi->tx_skip[0]);
rate_uv +=
vp9_cost_bit(cpi->common.fc.uv_tx_skip_prob[mbmi->tx_skip[0]],
mbmi->tx_skip[1]);
#endif // CONFIG_TX_SKIP
if (y_skip && uv_skip) {
palette_rd.rate = rate_y + rate_uv - rate_y_tokenonly -
rate_uv_tokenonly + vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
palette_rd.dist = dist_y + dist_uv;
} else {
palette_rd.rate = rate_y + rate_uv +
vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
palette_rd.dist = dist_y + dist_uv;
}
palette_rd.rdcost =
RDCOST(x->rdmult, x->rddiv, palette_rd.rate, palette_rd.dist);
if (palette_rd.rdcost < palette_best_rd.rdcost) {
palette_best_rd = palette_rd;
best_n = n;
best_l = l;
best_ps = ps;
best_m1 = m1;
best_m2 = m2;
palette_delta_bitdepth = best_bits;
if (y_skip && uv_skip) {
palette_rd.rate = rate_y + rate_uv - rate_y_tokenonly -
rate_uv_tokenonly + vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1);
palette_rd.dist = dist_y + dist_uv;
} else {
palette_rd.rate = rate_y + rate_uv +
vp9_cost_bit(vp9_get_skip_prob(cm, xd), 0);
palette_rd.dist = dist_y + dist_uv;
}
palette_rd.rdcost =
RDCOST(x->rdmult, x->rddiv, palette_rd.rate, palette_rd.dist);
if (palette_rd.rdcost < palette_best_rd.rdcost) {
palette_best_rd = palette_rd;
best_n = n;
best_l = l;
best_ps = ps;
best_m1 = m1;
best_m2 = m2;
palette_delta_bitdepth = best_bits;
#if CONFIG_TX_SKIP
tx_skipped = mbmi->tx_skip[0];
tx_skipped_uv = mbmi->tx_skip[1];
tx_skipped = mbmi->tx_skip[0];
tx_skipped_uv = mbmi->tx_skip[1];
#endif // CONFIG_TX_SKIP
vpx_memcpy(best_palette, mbmi->palette_colors,
PALETTE_MAX_SIZE * 3 * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mbmi->palette_runs, l * sizeof(best_runs[0]));
vpx_memcpy(best_index, mbmi->palette_indexed_colors,
best_m1 * sizeof(best_index[0]));
vpx_memcpy(palette_color_delta, mbmi->palette_color_delta,
best_m1 * sizeof(palette_color_delta[0]));
vpx_memcpy(best_literal, mbmi->palette_literal_colors,
best_m2 * sizeof(best_literal[0]));
}
vpx_memcpy(best_palette, mbmi->palette_colors,
PALETTE_MAX_SIZE * 3 * sizeof(best_palette[0]));
vpx_memcpy(best_runs, mbmi->palette_runs, l * sizeof(best_runs[0]));
vpx_memcpy(best_index, mbmi->palette_indexed_colors,
best_m1 * sizeof(best_index[0]));
vpx_memcpy(palette_color_delta, mbmi->palette_color_delta,
best_m1 * sizeof(palette_color_delta[0]));
vpx_memcpy(best_literal, mbmi->palette_literal_colors,
best_m2 * sizeof(best_literal[0]));
}
}
@ -5109,23 +5134,32 @@ void vp9_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
#endif // CONFIG_TX_SKIP
} else {
*mbmi = mbmi_copy;
if (mbmi->palette_enabled[0]) {
run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
}
}
if (mbmi->palette_enabled[0]) {
vp9_run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
}
if (mbmi->palette_enabled[1]) {
vp9_run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1],
xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
}
ctx->mic = *xd->mi[0].src_mi;
}
}
if (xd->mi[0].src_mi->mbmi.palette_enabled[0]) {
palette_color_insertion(ctx->palette_colors_buf,
&ctx->palette_buf_size,
ctx->palette_count_buf,
&(xd->mi[0].src_mi->mbmi));
vp9_palette_color_insertion(ctx->palette_colors_buf,
&ctx->palette_buf_size,
ctx->palette_count_buf,
&(xd->mi[0].src_mi->mbmi));
}
#endif // CONFIG_PALETTE
}
@ -6379,26 +6413,27 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
if (bsize >= BLOCK_8X8 && cpi->common.allow_palette_mode &&
!is_inter_block(mbmi)) {
MB_MODE_INFO mbmi_copy = *mbmi;
colors = count_colors(src, src_stride, rows, cols);
colors = vp9_count_colors(src, src_stride, rows, cols);
x->skip = 0;
if (colors > 1 && colors <= 64) {
int n, r, c, i, j, max_itr = 200, k;
int l, d = get_bit_depth(rows * cols);
int n, r, c, i, j, max_itr = 200, k, l;
int color_ctx = 0, color_idx = 0;
int color_order[PALETTE_MAX_SIZE];
int palette_size_cost[PALETTE_SIZES];
int palette_run_length_cost[PALETTE_RUN_LENGTHS];
int palette_scan_order_cost[PALETTE_SCAN_ORDERS];
double centroids[PALETTE_MAX_SIZE];
double lb = src[0], ub = src[0], val;
PALETTE_SCAN_ORDER ps;
int64_t this_rd = INT64_MAX, this_rd_y, best_rd_y;
int rate2, rate_y , rate_uv, best_token_rate_y = INT_MAX;
int total_rate_y, current_best_total_rate_y, best_total_rate_y = INT_MAX;
int total_rate_y, best_total_rate_y = INT_MAX;
int64_t distortion2, distortion_y, distortion_uv;
int64_t best_distortion_y = INT64_MAX;
int skippable, skip_y = 0;
int64_t tx_cache[TX_MODES];
TX_SIZE uv_tx;
uint8_t *color_map;
#if CONFIG_TX_SKIP
int rate_y_s, skippable_s;
int64_t distortion_y_s;
@ -6417,9 +6452,6 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
vp9_cost_tokens(palette_run_length_cost,
cpi->common.fc.palette_run_length_prob[bsize - BLOCK_8X8],
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->mode = DC_PRED;
for (r = 0; r < rows; r++) {
@ -6444,9 +6476,9 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
n >= 2; n--) {
for (i = 0; i < n; i++)
centroids[i] = lb + (2 * i + 1) * (ub - lb) / n / 2;
r = k_means(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, n, 1, max_itr);
insertion_sort(centroids, n);
r = vp9_k_means(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, n, 1, max_itr);
vp9_insertion_sort(centroids, n);
i = 1;
k = n;
while (i < k) {
@ -6467,8 +6499,8 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
mbmi->palette_colors[i] = clip_pixel(round(centroids[i]));
centroids[i] = (double) mbmi->palette_colors[i];
}
calc_indices(x->kmeans_data_buffer, centroids, x->kmeans_indices_buffer,
rows * cols, k, 1);
vp9_calc_indices(x->kmeans_data_buffer, centroids,
x->kmeans_indices_buffer, rows * cols, k, 1);
for (r = 0; r < rows; r++) {
for (c = 0; c < cols; c++) {
xd->plane[0].color_index_map[r * cols + c] =
@ -6508,52 +6540,46 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
continue;
}
current_best_total_rate_y = INT_MAX;
for (ps = H_SCAN; ps < PALETTE_SCAN_ORDERS; ps++) {
palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs, palette_max_run(bsize));
if (!l)
continue;
vp9_palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, ps, xd->palette_scan_buffer);
l = vp9_run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs, PALETTE_MAX_RUNS >> 1);
if (l)
break;
}
if (!l)
continue;
total_rate_y = rate_y +
(get_bit_depth(palette_max_run(bsize)) + 8 * k +
get_bit_depth(k) * (l >> 1)) * vp9_cost_bit(128, 0) +
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) {
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 += (bits > 6 ? d : bits) * vp9_cost_bit(128, 0);
total_rate_y = rate_y + palette_size_cost[k - 2] +
8 * k * vp9_cost_bit(128, 0) +
vp9_cost_bit(cm->fc.palette_enabled_prob
[bsize - BLOCK_8X8][palette_ctx], 1);
color_map = xd->plane[0].color_index_map;
total_rate_y += vp9_get_bit_depth(k) * vp9_cost_bit(128, 0);
for (i = 0; i < rows; i++) {
for (j = (i == 0 ? 1 : 0); j < cols; j++) {
color_ctx = vp9_get_palette_color_context(color_map, cols, i, j, n,
color_order);
for (r = 0; r < n; r++)
if (color_map[i * cols + j] == color_order[r]) {
color_idx = r;
break;
}
total_rate_y += cpi->palette_color_costs[k - 2][color_ctx]
[color_idx];
}
}
#if CONFIG_TX_SKIP
total_rate_y += vp9_cost_bit(cpi->common.fc.y_tx_skip_prob[0],
mbmi->tx_skip[0]);
#endif // CONFIG_TX_SKIP
if (total_rate_y < current_best_total_rate_y) {
mbmi->palette_scan_order[0] = ps;
current_best_total_rate_y = total_rate_y;
}
}
palette_scan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
l = run_lengh_encoding(xd->palette_map_buffer, rows * cols,
mbmi->palette_runs, palette_max_run(bsize));
if (!l)
continue;
this_rd_y = RDCOST(x->rdmult, x->rddiv,
current_best_total_rate_y, distortion_y);
this_rd_y = RDCOST(x->rdmult, x->rddiv, total_rate_y, distortion_y);
if (this_rd_y < best_rd_y) {
best_rd_y = this_rd_y;
skip_y = skippable;
best_distortion_y = distortion_y;
best_total_rate_y = current_best_total_rate_y;
best_total_rate_y = total_rate_y;
best_token_rate_y = rate_y;
best_n = k;
best_l = l;
@ -6572,57 +6598,18 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
uv_tx = get_uv_tx_size_impl(mbmi->tx_size, bsize,
xd->plane[1].subsampling_x,
xd->plane[1].subsampling_y);
if (rate_uv_intra[uv_tx] == INT_MAX) {
choose_intra_uv_mode(cpi, ctx, bsize, uv_tx,
&rate_uv_intra[uv_tx], &rate_uv_tokenonly[uv_tx],
&dist_uv[uv_tx], &skip_uv[uv_tx],
choose_intra_uv_mode(cpi, ctx, bsize, uv_tx,
&rate_uv_intra[uv_tx], &rate_uv_tokenonly[uv_tx],
&dist_uv[uv_tx], &skip_uv[uv_tx],
#if CONFIG_FILTERINTRA
&fbit_uv[uv_tx],
&fbit_uv[uv_tx],
#endif // CONFIG_FILTERINTRA
&mode_uv[uv_tx]);
palette_enabled_uv[uv_tx] = mbmi->palette_enabled[1];
if (palette_enabled_uv[uv_tx]) {
palette_size_uv[uv_tx] = mbmi->palette_size[1];
palette_run_length_uv[uv_tx] = mbmi->palette_run_length[1];
ps_uv[uv_tx] = mbmi->palette_scan_order[1];
vpx_memcpy(&palette_colors_uv[uv_tx][0],
mbmi->palette_colors + PALETTE_MAX_SIZE,
2 * PALETTE_MAX_SIZE *
sizeof(palette_colors_uv[uv_tx][0]));
vpx_memcpy(&palette_runs_uv[uv_tx][0],
mbmi->palette_runs + PALETTE_MAX_RUNS,
PALETTE_MAX_RUNS * sizeof(palette_runs_uv[uv_tx][0]));
}
#if CONFIG_TX_SKIP
tx_skipped_uv[uv_tx] = mbmi->tx_skip[1];
#endif // CONFIG_TX_SKIP
}
&mode_uv[uv_tx]);
rate_uv = rate_uv_tokenonly[uv_tx];
distortion_uv = dist_uv[uv_tx];
skippable = skip_y && skip_uv[uv_tx];
mbmi->uv_mode = mode_uv[uv_tx];
mbmi->palette_enabled[1] = palette_enabled_uv[uv_tx];
if (mbmi->palette_enabled[1]) {
mbmi->palette_size[1] = palette_size_uv[uv_tx];
mbmi->palette_run_length[1] = palette_run_length_uv[uv_tx];
mbmi->palette_scan_order[1] = ps_uv[uv_tx];
vpx_memcpy(mbmi->palette_colors + PALETTE_MAX_SIZE,
&palette_colors_uv[uv_tx][0],
2 * PALETTE_MAX_SIZE *
sizeof(palette_colors_uv[uv_tx][0]));
vpx_memcpy(mbmi->palette_runs + PALETTE_MAX_RUNS,
&palette_runs_uv[uv_tx][0],
PALETTE_MAX_RUNS * sizeof(palette_runs_uv[uv_tx][0]));
}
#if CONFIG_FILTERINTRA
mbmi->uv_filterbit = fbit_uv[uv_tx];
#endif // CONFIG_FILTERINTRA
#if CONFIG_TX_SKIP
mbmi->tx_skip[1] = tx_skipped_uv[uv_tx];
#endif // CONFIG_TX_SKIP
rate2 = best_total_rate_y + rate_uv_intra[uv_tx];
distortion2 = best_distortion_y + distortion_uv;
x->skip = skippable;
@ -6675,24 +6662,24 @@ void vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
int rows = 4 * num_4x4_blocks_high_lookup[bsize];
int cols = 4 * num_4x4_blocks_wide_lookup[bsize];
run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
vp9_run_lengh_decoding(mbmi->palette_runs, mbmi->palette_run_length[0],
xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[0].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[0],
xd->palette_scan_buffer);
}
if (mbmi->palette_enabled[1]) {
int rows = 4 * num_4x4_blocks_high_lookup[bsize] >>
xd->plane[1].subsampling_y;
int cols = 4 * num_4x4_blocks_wide_lookup[bsize] >>
xd->plane[1].subsampling_y;
xd->plane[1].subsampling_x;
run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
vp9_run_lengh_decoding(mbmi->palette_runs + PALETTE_MAX_RUNS,
mbmi->palette_run_length[1], xd->palette_map_buffer);
vp9_palette_iscan(xd->plane[1].color_index_map, xd->palette_map_buffer,
rows, cols, mbmi->palette_scan_order[1],
xd->palette_scan_buffer);
}
#endif // CONFIG_PALETTE
}