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

Cleaning up tile code.

Browse Source 
Removing tile_rows and tile_columns from VP9Common, removing redundant
constants MIN_TILE_WIDTH and MAX_TILE_WIDTH, changing signature of
vp9_get_tile_n_bits.

Change-Id: I8ff3104a38179b2c6900df965c144c1d6f602267
This commit is contained in:
Dmitry Kovalev 2013-07-16 14:47:15 -07:00
parent 98e132bde0
commit 9482a0bf10
8 changed files with 77 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vp9/common/vp9_onyxc_int.h
View File

@ -254,9 +254,8 @@ typedef struct VP9Common {
int error_resilient_mode;
int frame_parallel_decoding_mode;
int tile_columns, log2_tile_columns;
int log2_tile_cols, log2_tile_rows;
int cur_tile_mi_col_start, cur_tile_mi_col_end, cur_tile_col_idx;
int tile_rows, log2_tile_rows;
int cur_tile_mi_row_start, cur_tile_mi_row_end, cur_tile_row_idx;
} VP9_COMMON;

38
vp9/common/vp9_tile_common.c
View File

@ -10,18 +10,15 @@
#include "vp9/common/vp9_tile_common.h"
#define MIN_TILE_WIDTH 256
#define MAX_TILE_WIDTH 4096
#define MIN_TILE_WIDTH_SBS (MIN_TILE_WIDTH >> 6)
#define MAX_TILE_WIDTH_SBS (MAX_TILE_WIDTH >> 6)
#define MIN_TILE_WIDTH_B64 4
#define MAX_TILE_WIDTH_B64 64
static int to_sbs(n_mis) {
return mi_cols_aligned_to_sb(n_mis) >> LOG2_MI_BLOCK_SIZE;
}
static void vp9_get_tile_offsets(VP9_COMMON *cm, int *min_tile_off,
int *max_tile_off, int tile_idx,
int log2_n_tiles, int n_mis) {
static void vp9_get_tile_offsets(int *min_tile_off, int *max_tile_off,
int tile_idx, int log2_n_tiles, int n_mis) {
const int n_sbs = to_sbs(n_mis);
const int sb_off1 = (tile_idx * n_sbs) >> log2_n_tiles;
const int sb_off2 = ((tile_idx + 1) * n_sbs) >> log2_n_tiles;
@ -32,36 +29,35 @@ static void vp9_get_tile_offsets(VP9_COMMON *cm, int *min_tile_off,
void vp9_get_tile_col_offsets(VP9_COMMON *cm, int tile_col_idx) {
cm->cur_tile_col_idx = tile_col_idx;
vp9_get_tile_offsets(cm, &cm->cur_tile_mi_col_start,
&cm->cur_tile_mi_col_end, tile_col_idx,
cm->log2_tile_columns, cm->mi_cols);
vp9_get_tile_offsets(&cm->cur_tile_mi_col_start, &cm->cur_tile_mi_col_end,
tile_col_idx, cm->log2_tile_cols, cm->mi_cols);
}
void vp9_get_tile_row_offsets(VP9_COMMON *cm, int tile_row_idx) {
cm->cur_tile_row_idx = tile_row_idx;
vp9_get_tile_offsets(cm, &cm->cur_tile_mi_row_start,
&cm->cur_tile_mi_row_end, tile_row_idx,
cm->log2_tile_rows, cm->mi_rows);
vp9_get_tile_offsets(&cm->cur_tile_mi_row_start, &cm->cur_tile_mi_row_end,
tile_row_idx, cm->log2_tile_rows, cm->mi_rows);
}
void vp9_get_tile_n_bits(VP9_COMMON *cm, int *min_log2_n_tiles_ptr,
int *delta_log2_n_tiles) {
const int sb_cols = to_sbs(cm->mi_cols);
void vp9_get_tile_n_bits(int mi_cols,
int *min_log2_tile_cols, int *max_log2_tile_cols) {
const int sb_cols = to_sbs(mi_cols);
int min_log2_n_tiles, max_log2_n_tiles;
for (max_log2_n_tiles = 0;
(sb_cols >> max_log2_n_tiles) >= MIN_TILE_WIDTH_SBS;
(sb_cols >> max_log2_n_tiles) >= MIN_TILE_WIDTH_B64;
max_log2_n_tiles++) {}
max_log2_n_tiles--;
if (max_log2_n_tiles < 0)
max_log2_n_tiles = 0;
for (min_log2_n_tiles = 0;
(MAX_TILE_WIDTH_SBS << min_log2_n_tiles) < sb_cols;
(MAX_TILE_WIDTH_B64 << min_log2_n_tiles) < sb_cols;
min_log2_n_tiles++) {}
assert(max_log2_n_tiles >= min_log2_n_tiles);
*min_log2_n_tiles_ptr = min_log2_n_tiles;
*delta_log2_n_tiles = max_log2_n_tiles - min_log2_n_tiles;
assert(min_log2_n_tiles <= max_log2_n_tiles);
*min_log2_tile_cols = min_log2_n_tiles;
*max_log2_tile_cols = max_log2_n_tiles;
}

4
vp9/common/vp9_tile_common.h
View File

@ -17,7 +17,7 @@ void vp9_get_tile_col_offsets(VP9_COMMON *cm, int tile_col_idx);
void vp9_get_tile_row_offsets(VP9_COMMON *cm, int tile_row_idx);
void vp9_get_tile_n_bits(VP9_COMMON *cm, int *min_log2_n_tiles,
int *delta_log2_n_tiles);
void vp9_get_tile_n_bits(int mi_cols,
int *min_log2_tile_cols, int *max_log2_tile_cols);
#endif // VP9_COMMON_VP9_TILE_COMMON_H_

46
vp9/decoder/vp9_decodframe.c
View File

@ -632,23 +632,19 @@ static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
}
static void setup_tile_info(VP9_COMMON *cm, struct vp9_read_bit_buffer *rb) {
int delta_log2_tiles;
int min_log2_tile_cols, max_log2_tile_cols, max_ones;
vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
vp9_get_tile_n_bits(cm, &cm->log2_tile_columns, &delta_log2_tiles);
while (delta_log2_tiles--) {
if (vp9_rb_read_bit(rb)) {
cm->log2_tile_columns++;
} else {
break;
}
}
// columns
max_ones = max_log2_tile_cols - min_log2_tile_cols;
cm->log2_tile_cols = min_log2_tile_cols;
while (max_ones-- && vp9_rb_read_bit(rb))
cm->log2_tile_cols++;
// rows
cm->log2_tile_rows = vp9_rb_read_bit(rb);
if (cm->log2_tile_rows)
cm->log2_tile_rows += vp9_rb_read_bit(rb);
cm->tile_columns = 1 << cm->log2_tile_columns;
cm->tile_rows = 1 << cm->log2_tile_rows;
}
static void decode_tiles(VP9D_COMP *pbi,
@ -659,6 +655,8 @@ static void decode_tiles(VP9D_COMP *pbi,
const uint8_t *data_ptr = data + first_partition_size;
const uint8_t *const data_end = pbi->source + pbi->source_sz;
const int aligned_mi_cols = mi_cols_aligned_to_sb(pc->mi_cols);
const int tile_cols = 1 << pc->log2_tile_cols;
const int tile_rows = 1 << pc->log2_tile_rows;
int tile_row, tile_col;
// Note: this memset assumes above_context[0], [1] and [2]
@ -670,20 +668,19 @@ static void decode_tiles(VP9D_COMP *pbi,
sizeof(PARTITION_CONTEXT) * aligned_mi_cols);
if (pbi->oxcf.inv_tile_order) {
const int n_cols = pc->tile_columns;
const uint8_t *data_ptr2[4][1 << 6];
vp9_reader bc_bak = {0};
// pre-initialize the offsets, we're going to read in inverse order
data_ptr2[0][0] = data_ptr;
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
if (tile_row) {
const int size = read_be32(data_ptr2[tile_row - 1][n_cols - 1]);
data_ptr2[tile_row - 1][n_cols - 1] += 4;
data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][n_cols - 1] + size;
const int size = read_be32(data_ptr2[tile_row - 1][tile_cols - 1]);
data_ptr2[tile_row - 1][tile_cols - 1] += 4;
data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][tile_cols - 1] + size;
}
for (tile_col = 1; tile_col < n_cols; tile_col++) {
for (tile_col = 1; tile_col < tile_cols; tile_col++) {
const int size = read_be32(data_ptr2[tile_row][tile_col - 1]);
data_ptr2[tile_row][tile_col - 1] += 4;
data_ptr2[tile_row][tile_col] =
@ -691,15 +688,15 @@ static void decode_tiles(VP9D_COMP *pbi,
}
}
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
vp9_get_tile_row_offsets(pc, tile_row);
for (tile_col = n_cols - 1; tile_col >= 0; tile_col--) {
for (tile_col = tile_cols - 1; tile_col >= 0; tile_col--) {
vp9_get_tile_col_offsets(pc, tile_col);
setup_token_decoder(pbi, data_ptr2[tile_row][tile_col],
data_end - data_ptr2[tile_row][tile_col],
residual_bc);
decode_tile(pbi, residual_bc);
if (tile_row == pc->tile_rows - 1 && tile_col == n_cols - 1)
if (tile_row == tile_rows - 1 && tile_col == tile_cols - 1)
bc_bak = *residual_bc;
}
}
@ -707,15 +704,14 @@ static void decode_tiles(VP9D_COMP *pbi,
} else {
int has_more;
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
vp9_get_tile_row_offsets(pc, tile_row);
for (tile_col = 0; tile_col < pc->tile_columns; tile_col++) {
for (tile_col = 0; tile_col < tile_cols; tile_col++) {
size_t size;
vp9_get_tile_col_offsets(pc, tile_col);
has_more = tile_col < pc->tile_columns - 1 ||
tile_row < pc->tile_rows - 1;
has_more = tile_col < tile_cols - 1 || tile_row < tile_rows - 1;
if (has_more) {
if (!read_is_valid(data_ptr, 4, data_end))
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,

40
vp9/encoder/vp9_bitstream.c
View File

@ -1136,18 +1136,18 @@ static void fix_mcomp_filter_type(VP9_COMP *cpi) {
}
static void write_tile_info(VP9_COMMON *cm, struct vp9_write_bit_buffer *wb) {
int min_log2_tiles, delta_log2_tiles, n_tile_bits, n;
vp9_get_tile_n_bits(cm, &min_log2_tiles, &delta_log2_tiles);
n_tile_bits = cm->log2_tile_columns - min_log2_tiles;
for (n = 0; n < delta_log2_tiles; n++) {
if (n_tile_bits--) {
vp9_wb_write_bit(wb, 1);
} else {
vp9_wb_write_bit(wb, 0);
break;
}
}
int min_log2_tile_cols, max_log2_tile_cols, ones;
vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
// columns
ones = cm->log2_tile_cols - min_log2_tile_cols;
while (ones--)
vp9_wb_write_bit(wb, 1);
if (cm->log2_tile_cols < max_log2_tile_cols)
vp9_wb_write_bit(wb, 0);
// rows
vp9_wb_write_bit(wb, cm->log2_tile_rows != 0);
if (cm->log2_tile_rows != 0)
vp9_wb_write_bit(wb, cm->log2_tile_rows != 1);
@ -1195,28 +1195,30 @@ static size_t encode_tiles(VP9_COMP *cpi, uint8_t *data_ptr) {
int tile_row, tile_col;
TOKENEXTRA *tok[4][1 << 6], *tok_end;
size_t total_size = 0;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
vpx_memset(cm->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
mi_cols_aligned_to_sb(cm->mi_cols));
tok[0][0] = cpi->tok;
for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
if (tile_row)
tok[tile_row][0] = tok[tile_row - 1][cm->tile_columns - 1] +
cpi->tok_count[tile_row - 1][cm->tile_columns - 1];
tok[tile_row][0] = tok[tile_row - 1][tile_cols - 1] +
cpi->tok_count[tile_row - 1][tile_cols - 1];
for (tile_col = 1; tile_col < cm->tile_columns; tile_col++)
for (tile_col = 1; tile_col < tile_cols; tile_col++)
tok[tile_row][tile_col] = tok[tile_row][tile_col - 1] +
cpi->tok_count[tile_row][tile_col - 1];
}
for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
vp9_get_tile_row_offsets(cm, tile_row);
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
for (tile_col = 0; tile_col < tile_cols; tile_col++) {
vp9_get_tile_col_offsets(cm, tile_col);
tok_end = tok[tile_row][tile_col] + cpi->tok_count[tile_row][tile_col];
if (tile_col < cm->tile_columns - 1 || tile_row < cm->tile_rows - 1)
if (tile_col < tile_cols - 1 || tile_row < tile_rows - 1)
vp9_start_encode(&residual_bc, data_ptr + total_size + 4);
else
vp9_start_encode(&residual_bc, data_ptr + total_size);
@ -1224,7 +1226,7 @@ static size_t encode_tiles(VP9_COMP *cpi, uint8_t *data_ptr) {
write_modes(cpi, &residual_bc, &tok[tile_row][tile_col], tok_end);
assert(tok[tile_row][tile_col] == tok_end);
vp9_stop_encode(&residual_bc);
if (tile_col < cm->tile_columns - 1 || tile_row < cm->tile_rows - 1) {
if (tile_col < tile_cols - 1 || tile_row < tile_rows - 1) {
// size of this tile
write_be32(data_ptr + total_size, residual_bc.pos);
total_size += 4;

11
vp9/encoder/vp9_encodeframe.c
View File

@ -1839,22 +1839,23 @@ static void encode_frame_internal(VP9_COMP *cpi) {
// Take tiles into account and give start/end MB
int tile_col, tile_row;
TOKENEXTRA *tp = cpi->tok;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
for (tile_row = 0; tile_row < cm->tile_rows; tile_row++) {
for (tile_row = 0; tile_row < tile_rows; tile_row++) {
vp9_get_tile_row_offsets(cm, tile_row);
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
for (tile_col = 0; tile_col < tile_cols; tile_col++) {
TOKENEXTRA *tp_old = tp;
// For each row of SBs in the frame
vp9_get_tile_col_offsets(cm, tile_col);
for (mi_row = cm->cur_tile_mi_row_start;
mi_row < cm->cur_tile_mi_row_end; mi_row += 8)
mi_row < cm->cur_tile_mi_row_end; mi_row += 8)
encode_sb_row(cpi, mi_row, &tp, &totalrate);
cpi->tok_count[tile_row][tile_col] = (unsigned int)(tp - tp_old);
assert(tp - cpi->tok <=
get_token_alloc(cm->mb_rows, cm->mb_cols));
assert(tp - cpi->tok <= get_token_alloc(cm->mb_rows, cm->mb_cols));
}
}
}

16
vp9/encoder/vp9_onyx_if.c
View File

@ -1068,19 +1068,13 @@ static int64_t rescale(int val, int64_t num, int denom) {
static void set_tile_limits(VP9_COMP *cpi) {
VP9_COMMON *const cm = &cpi->common;
int min_log2_tiles, max_log2_tiles;
cm->log2_tile_columns = cpi->oxcf.tile_columns;
int min_log2_tile_cols, max_log2_tile_cols;
vp9_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
cm->log2_tile_cols = clamp(cpi->oxcf.tile_columns,
min_log2_tile_cols, max_log2_tile_cols);
cm->log2_tile_rows = cpi->oxcf.tile_rows;
vp9_get_tile_n_bits(cm, &min_log2_tiles, &max_log2_tiles);
max_log2_tiles += min_log2_tiles;
cm->log2_tile_columns = clamp(cm->log2_tile_columns,
min_log2_tiles, max_log2_tiles);
cm->tile_columns = 1 << cm->log2_tile_columns;
cm->tile_rows = 1 << cm->log2_tile_rows;
}
static void init_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {

11
vp9/encoder/vp9_segmentation.c
View File

@ -216,8 +216,7 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
int no_pred_cost;
int t_pred_cost = INT_MAX;
int i;
int tile_col, mi_row, mi_col;
int i, tile_col, mi_row, mi_col;
int temporal_predictor_count[PREDICTION_PROBS][2];
int no_pred_segcounts[MAX_MB_SEGMENTS];
@ -241,18 +240,16 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
// First of all generate stats regarding how well the last segment map
// predicts this one
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
for (tile_col = 0; tile_col < 1 << cm->log2_tile_cols; tile_col++) {
vp9_get_tile_col_offsets(cm, tile_col);
mi_ptr = cm->mi + cm->cur_tile_mi_col_start;
for (mi_row = 0; mi_row < cm->mi_rows;
mi_row += 8, mi_ptr += 8 * mis) {
mi = mi_ptr;
for (mi_col = cm->cur_tile_mi_col_start;
mi_col < cm->cur_tile_mi_col_end;
mi_col += 8, mi += 8) {
for (mi_col = cm->cur_tile_mi_col_start; mi_col < cm->cur_tile_mi_col_end;
mi_col += 8, mi += 8)
count_segs_sb(cpi, mi, no_pred_segcounts, temporal_predictor_count,
t_unpred_seg_counts, mi_row, mi_col, BLOCK_SIZE_SB64X64);
}
}
}