From 2891d70b2376562f1ccf33c2d4ab5d4b9e742743 Mon Sep 17 00:00:00 2001
From: Dmitry Kovalev <dkovalev@google.com>
Date: Mon, 11 Mar 2013 17:02:27 -0700
Subject: [PATCH] Code cleanup.
Removing redundant code, introducing new functions for better
decomposition, adding 'clamp' function to vp9_common.h.
Change-Id: Ic3b8ca13bbc38f60f0c9c43910b5802005e31aaf
---
vp9/common/vp9_common.h | 4 +
vp9/decoder/vp9_decodframe.c | 242 +++++++++++++++++------------------
vp9/encoder/vp9_lookahead.c | 54 +++-----
vp9/encoder/vp9_lookahead.h | 31 ++---
4 files changed, 151 insertions(+), 180 deletions(-)
diff --git a/vp9/common/vp9_common.h b/vp9/common/vp9_common.h
index dcc5073e6c..f72d25e7f4 100644
--- a/vp9/common/vp9_common.h
+++ b/vp9/common/vp9_common.h
@@ -51,4 +51,8 @@ static INLINE uint8_t clip_pixel(int val) {
return (val > 255) ? 255u : (val < 0) ? 0u : val;
}
+static INLINE int clamp(int value, int low, int high) {
+ return value < low ? low : (value > high ? high : value);
+}
+
#endif // VP9_COMMON_VP9_COMMON_H_
diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 5b3e1bdede..572ba2905c 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -95,50 +95,46 @@ void vp9_init_de_quantizer(VP9D_COMP *pbi) {
}
}
-static void mb_init_dequantizer(VP9D_COMP *pbi, MACROBLOCKD *xd) {
+static int get_qindex(MACROBLOCKD *mb, int segment_id, int base_qindex) {
+ // Set the Q baseline allowing for any segment level adjustment
+ if (vp9_segfeature_active(mb, segment_id, SEG_LVL_ALT_Q)) {
+ if (mb->mb_segment_abs_delta == SEGMENT_ABSDATA)
+ return vp9_get_segdata(mb, segment_id, SEG_LVL_ALT_Q); // Abs Value
+ else
+ return clamp(base_qindex + vp9_get_segdata(mb, segment_id, SEG_LVL_ALT_Q),
+ 0, MAXQ); // Delta Value
+ } else {
+ return base_qindex;
+ }
+}
+
+static void mb_init_dequantizer(VP9D_COMP *pbi, MACROBLOCKD *mb) {
int i;
- int qindex;
- VP9_COMMON *const pc = &pbi->common;
- int segment_id = xd->mode_info_context->mbmi.segment_id;
- // Set the Q baseline allowing for any segment level adjustment
- if (vp9_segfeature_active(xd, segment_id, SEG_LVL_ALT_Q)) {
- if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
- /* Abs Value */
- qindex = vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
- else {
- /* Delta Value */
- qindex = pc->base_qindex +
- vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
- /* Clamp to valid range */
- qindex = (qindex >= 0) ? ((qindex <= MAXQ) ? qindex : MAXQ) : 0;
- }
- } else
- qindex = pc->base_qindex;
+ VP9_COMMON *const pc = &pbi->common;
+ int segment_id = mb->mode_info_context->mbmi.segment_id;
+ int qindex = get_qindex(mb, segment_id, pc->base_qindex);
+ mb->q_index = qindex;
- xd->q_index = qindex;
+ for (i = 0; i < 16; i++)
+ mb->block[i].dequant = pc->Y1dequant[qindex];
- /* Set up the block level dequant pointers */
- for (i = 0; i < 16; i++) {
- xd->block[i].dequant = pc->Y1dequant[qindex];
- }
+ for (i = 16; i < 24; i++)
+ mb->block[i].dequant = pc->UVdequant[qindex];
- xd->inv_txm4x4_1 = vp9_short_idct4x4llm_1;
- xd->inv_txm4x4 = vp9_short_idct4x4llm;
- xd->itxm_add = vp9_dequant_idct_add;
- xd->itxm_add_y_block = vp9_dequant_idct_add_y_block;
- xd->itxm_add_uv_block = vp9_dequant_idct_add_uv_block;
- if (xd->lossless) {
+ if (mb->lossless) {
assert(qindex == 0);
- xd->inv_txm4x4_1 = vp9_short_inv_walsh4x4_1_x8;
- xd->inv_txm4x4 = vp9_short_inv_walsh4x4_x8;
- xd->itxm_add = vp9_dequant_idct_add_lossless_c;
- xd->itxm_add_y_block = vp9_dequant_idct_add_y_block_lossless_c;
- xd->itxm_add_uv_block = vp9_dequant_idct_add_uv_block_lossless_c;
- }
-
- for (i = 16; i < 24; i++) {
- xd->block[i].dequant = pc->UVdequant[qindex];
+ mb->inv_txm4x4_1 = vp9_short_inv_walsh4x4_1_x8;
+ mb->inv_txm4x4 = vp9_short_inv_walsh4x4_x8;
+ mb->itxm_add = vp9_dequant_idct_add_lossless_c;
+ mb->itxm_add_y_block = vp9_dequant_idct_add_y_block_lossless_c;
+ mb->itxm_add_uv_block = vp9_dequant_idct_add_uv_block_lossless_c;
+ } else {
+ mb->inv_txm4x4_1 = vp9_short_idct4x4llm_1;
+ mb->inv_txm4x4 = vp9_short_idct4x4llm;
+ mb->itxm_add = vp9_dequant_idct_add;
+ mb->itxm_add_y_block = vp9_dequant_idct_add_y_block;
+ mb->itxm_add_uv_block = vp9_dequant_idct_add_uv_block;
}
}
@@ -333,10 +329,8 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
int ib = vp9_i8x8_block[i];
const int iblock[4] = {0, 1, 4, 5};
int j;
- int i8x8mode;
- BLOCKD *b;
- b = &xd->block[ib];
- i8x8mode = b->bmi.as_mode.first;
+ BLOCKD *b = &xd->block[ib];
+ int i8x8mode = b->bmi.as_mode.first;
vp9_intra8x8_predict(xd, b, i8x8mode, b->predictor);
for (j = 0; j < 4; j++) {
b = &xd->block[ib + iblock[j]];
@@ -363,9 +357,8 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
}
} else if (mode == B_PRED) {
for (i = 0; i < 16; i++) {
- int b_mode;
BLOCKD *b = &xd->block[i];
- b_mode = xd->mode_info_context->bmi[i].as_mode.first;
+ int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
#if CONFIG_NEWBINTRAMODES
xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
vp9_find_bpred_context(b);
@@ -503,10 +496,11 @@ static void decode_superblock64(VP9D_COMP *pbi, MACROBLOCKD *xd,
case TX_32X32:
for (n = 0; n < 4; n++) {
const int x_idx = n & 1, y_idx = n >> 1;
+ const int y_offset = x_idx * 32 + y_idx * xd->dst.y_stride * 32;
vp9_dequant_idct_add_32x32(xd->qcoeff + n * 1024,
xd->block[0].dequant,
- xd->dst.y_buffer + x_idx * 32 + y_idx * xd->dst.y_stride * 32,
- xd->dst.y_buffer + x_idx * 32 + y_idx * xd->dst.y_stride * 32,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 64]);
}
vp9_dequant_idct_add_32x32(xd->qcoeff + 4096,
@@ -519,96 +513,103 @@ static void decode_superblock64(VP9D_COMP *pbi, MACROBLOCKD *xd,
case TX_16X16:
for (n = 0; n < 16; n++) {
const int x_idx = n & 3, y_idx = n >> 2;
+ const int y_offset = y_idx * 16 * xd->dst.y_stride + x_idx * 16;
const TX_TYPE tx_type = get_tx_type_16x16(xd,
(y_idx * 16 + x_idx) * 4);
+
if (tx_type == DCT_DCT) {
vp9_dequant_idct_add_16x16(xd->qcoeff + n * 256,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 16]);
} else {
vp9_ht_dequant_idct_add_16x16_c(tx_type, xd->qcoeff + n * 256,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 16]);
}
}
for (n = 0; n < 4; n++) {
const int x_idx = n & 1, y_idx = n >> 1;
+ const int uv_offset = y_idx * 16 * xd->dst.uv_stride + x_idx * 16;
vp9_dequant_idct_add_16x16(xd->qcoeff + 4096 + n * 256,
xd->block[16].dequant,
- xd->dst.u_buffer + y_idx * 16 * xd->dst.uv_stride + x_idx * 16,
- xd->dst.u_buffer + y_idx * 16 * xd->dst.uv_stride + x_idx * 16,
+ xd->dst.u_buffer + uv_offset,
+ xd->dst.u_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[256 + n * 16]);
vp9_dequant_idct_add_16x16(xd->qcoeff + 4096 + 1024 + n * 256,
xd->block[20].dequant,
- xd->dst.v_buffer + y_idx * 16 * xd->dst.uv_stride + x_idx * 16,
- xd->dst.v_buffer + y_idx * 16 * xd->dst.uv_stride + x_idx * 16,
+ xd->dst.v_buffer + uv_offset,
+ xd->dst.v_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[320 + n * 16]);
}
break;
case TX_8X8:
for (n = 0; n < 64; n++) {
const int x_idx = n & 7, y_idx = n >> 3;
+ const int y_offset = y_idx * 8 * xd->dst.y_stride + x_idx * 8;
const TX_TYPE tx_type = get_tx_type_8x8(xd, (y_idx * 16 + x_idx) * 2);
if (tx_type == DCT_DCT) {
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 4]);
} else {
vp9_ht_dequant_idct_add_8x8_c(tx_type, xd->qcoeff + n * 64,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 4]);
}
}
for (n = 0; n < 16; n++) {
const int x_idx = n & 3, y_idx = n >> 2;
+ const int uv_offset = y_idx * 8 * xd->dst.uv_stride + x_idx * 8;
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64 + 4096,
xd->block[16].dequant,
- xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
- xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
+ xd->dst.u_buffer + uv_offset,
+ xd->dst.u_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[256 + n * 4]);
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64 + 4096 + 1024,
xd->block[20].dequant,
- xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
- xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
+ xd->dst.v_buffer + uv_offset,
+ xd->dst.v_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[320 + n * 4]);
}
break;
case TX_4X4:
for (n = 0; n < 256; n++) {
const int x_idx = n & 15, y_idx = n >> 4;
+ const int y_offset = y_idx * 4 * xd->dst.y_stride + x_idx * 4;
const TX_TYPE tx_type = get_tx_type_4x4(xd, y_idx * 16 + x_idx);
if (tx_type == DCT_DCT) {
xd->itxm_add(xd->qcoeff + n * 16, xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n]);
} else {
vp9_ht_dequant_idct_add_c(tx_type, xd->qcoeff + n * 16,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n]);
}
}
for (n = 0; n < 64; n++) {
const int x_idx = n & 7, y_idx = n >> 3;
+ const int uv_offset = y_idx * 4 * xd->dst.uv_stride + x_idx * 4;
xd->itxm_add(xd->qcoeff + 4096 + n * 16,
xd->block[16].dequant,
- xd->dst.u_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
- xd->dst.u_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
+ xd->dst.u_buffer + uv_offset,
+ xd->dst.u_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[256 + n]);
xd->itxm_add(xd->qcoeff + 4096 + 1024 + n * 16,
xd->block[20].dequant,
- xd->dst.v_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
- xd->dst.v_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
+ xd->dst.v_buffer + uv_offset,
+ xd->dst.v_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[320 + n]);
}
break;
@@ -681,19 +682,20 @@ static void decode_superblock32(VP9D_COMP *pbi, MACROBLOCKD *xd,
case TX_16X16:
for (n = 0; n < 4; n++) {
const int x_idx = n & 1, y_idx = n >> 1;
+ const int y_offset = y_idx * 16 * xd->dst.y_stride + x_idx * 16;
const TX_TYPE tx_type = get_tx_type_16x16(xd,
(y_idx * 8 + x_idx) * 4);
if (tx_type == DCT_DCT) {
vp9_dequant_idct_add_16x16(
xd->qcoeff + n * 256, xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 16]);
} else {
vp9_ht_dequant_idct_add_16x16_c(tx_type, xd->qcoeff + n * 256,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
- xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 16]);
}
}
@@ -706,63 +708,69 @@ static void decode_superblock32(VP9D_COMP *pbi, MACROBLOCKD *xd,
case TX_8X8:
for (n = 0; n < 16; n++) {
const int x_idx = n & 3, y_idx = n >> 2;
+ const int y_offset = y_idx * 8 * xd->dst.y_stride + x_idx * 8;
const TX_TYPE tx_type = get_tx_type_8x8(xd, (y_idx * 8 + x_idx) * 2);
if (tx_type == DCT_DCT) {
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 4]);
} else {
vp9_ht_dequant_idct_add_8x8_c(tx_type, xd->qcoeff + n * 64,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
- xd->dst.y_buffer + y_idx * 8 * xd->dst.y_stride + x_idx * 8,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n * 4]);
}
}
for (n = 0; n < 4; n++) {
const int x_idx = n & 1, y_idx = n >> 1;
+ const int uv_offset = y_idx * 8 * xd->dst.uv_stride + x_idx * 8;
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64 + 1024,
xd->block[16].dequant,
- xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
- xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
+ xd->dst.u_buffer + uv_offset,
+ xd->dst.u_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[64 + n * 4]);
vp9_dequant_idct_add_8x8_c(xd->qcoeff + n * 64 + 1280,
xd->block[20].dequant,
- xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
- xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
+ xd->dst.v_buffer + uv_offset,
+ xd->dst.v_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[80 + n * 4]);
}
break;
case TX_4X4:
for (n = 0; n < 64; n++) {
const int x_idx = n & 7, y_idx = n >> 3;
+ const int y_offset = y_idx * 4 * xd->dst.y_stride + x_idx * 4;
+
const TX_TYPE tx_type = get_tx_type_4x4(xd, y_idx * 8 + x_idx);
if (tx_type == DCT_DCT) {
xd->itxm_add(xd->qcoeff + n * 16, xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n]);
} else {
vp9_ht_dequant_idct_add_c(tx_type, xd->qcoeff + n * 16,
xd->block[0].dequant,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
- xd->dst.y_buffer + y_idx * 4 * xd->dst.y_stride + x_idx * 4,
+ xd->dst.y_buffer + y_offset,
+ xd->dst.y_buffer + y_offset,
xd->dst.y_stride, xd->dst.y_stride, xd->eobs[n]);
}
}
+
for (n = 0; n < 16; n++) {
const int x_idx = n & 3, y_idx = n >> 2;
+ const int uv_offset = y_idx * 4 * xd->dst.uv_stride + x_idx * 4;
xd->itxm_add(xd->qcoeff + 1024 + n * 16,
xd->block[16].dequant,
- xd->dst.u_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
- xd->dst.u_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
+ xd->dst.u_buffer + uv_offset,
+ xd->dst.u_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[64 + n]);
xd->itxm_add(xd->qcoeff + 1280 + n * 16,
xd->block[20].dequant,
- xd->dst.v_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
- xd->dst.v_buffer + y_idx * 4 * xd->dst.uv_stride + x_idx * 4,
+ xd->dst.v_buffer + uv_offset,
+ xd->dst.v_buffer + uv_offset,
xd->dst.uv_stride, xd->dst.uv_stride, xd->eobs[80 + n]);
}
break;
@@ -1047,13 +1055,10 @@ static void decode_sb_row(VP9D_COMP *pbi, VP9_COMMON *pc,
}
static unsigned int read_partition_size(const unsigned char *cx_size) {
- const unsigned int size =
- cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
- return size;
+ return cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
}
-static int read_is_valid(const unsigned char *start,
- size_t len,
+static int read_is_valid(const unsigned char *start, size_t len,
const unsigned char *end) {
return start + len > start && start + len <= end;
}
@@ -1062,22 +1067,15 @@ static int read_is_valid(const unsigned char *start,
static void setup_token_decoder(VP9D_COMP *pbi,
const unsigned char *cx_data,
BOOL_DECODER* const bool_decoder) {
- VP9_COMMON *pc = &pbi->common;
+ VP9_COMMON *pc = &pbi->common;
const unsigned char *user_data_end = pbi->Source + pbi->source_sz;
- const unsigned char *partition;
-
- ptrdiff_t partition_size;
- ptrdiff_t bytes_left;
+ const unsigned char *partition = cx_data;
+ ptrdiff_t bytes_left = user_data_end - partition;
+ ptrdiff_t partition_size = bytes_left;
- // Set up pointers to token partition
- partition = cx_data;
- bytes_left = user_data_end - partition;
- partition_size = bytes_left;
-
- /* Validate the calculated partition length. If the buffer
- * described by the partition can't be fully read, then restrict
- * it to the portion that can be (for EC mode) or throw an error.
- */
+ // Validate the calculated partition length. If the buffer
+ // described by the partition can't be fully read, then restrict
+ // it to the portion that can be (for EC mode) or throw an error.
if (!read_is_valid(partition, partition_size, user_data_end)) {
vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt partition "
@@ -1096,19 +1094,16 @@ static void init_frame(VP9D_COMP *pbi) {
if (pc->frame_type == KEY_FRAME) {
vp9_setup_past_independence(pc, xd);
- /* All buffers are implicitly updated on key frames. */
+ // All buffers are implicitly updated on key frames.
pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
} else if (pc->error_resilient_mode) {
vp9_setup_past_independence(pc, xd);
}
if (pc->frame_type != KEY_FRAME) {
- if (!pc->use_bilinear_mc_filter)
- pc->mcomp_filter_type = EIGHTTAP;
- else
- pc->mcomp_filter_type = BILINEAR;
+ pc->mcomp_filter_type = pc->use_bilinear_mc_filter ? BILINEAR : EIGHTTAP;
- /* To enable choice of different interpolation filters */
+ // To enable choice of different interpolation filters
vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
}
@@ -1117,11 +1112,9 @@ static void init_frame(VP9D_COMP *pbi) {
xd->frame_type = pc->frame_type;
xd->mode_info_context->mbmi.mode = DC_PRED;
xd->mode_info_stride = pc->mode_info_stride;
- xd->corrupted = 0; /* init without corruption */
+ xd->corrupted = 0;
- xd->fullpixel_mask = 0xffffffff;
- if (pc->full_pixel)
- xd->fullpixel_mask = 0xfffffff8;
+ xd->fullpixel_mask = pc->full_pixel ? 0xfffffff8 : 0xffffffff;
}
#if CONFIG_CODE_NONZEROCOUNT
@@ -1234,15 +1227,14 @@ static void read_coef_probs(VP9D_COMP *pbi, BOOL_DECODER* const bc) {
read_coef_probs_common(bc, pc->fc.coef_probs_4x4, BLOCK_TYPES);
- if (pbi->common.txfm_mode != ONLY_4X4) {
+ if (pbi->common.txfm_mode != ONLY_4X4)
read_coef_probs_common(bc, pc->fc.coef_probs_8x8, BLOCK_TYPES);
- }
- if (pbi->common.txfm_mode > ALLOW_8X8) {
+
+ if (pbi->common.txfm_mode > ALLOW_8X8)
read_coef_probs_common(bc, pc->fc.coef_probs_16x16, BLOCK_TYPES);
- }
- if (pbi->common.txfm_mode > ALLOW_16X16) {
+
+ if (pbi->common.txfm_mode > ALLOW_16X16)
read_coef_probs_common(bc, pc->fc.coef_probs_32x32, BLOCK_TYPES);
- }
}
static void update_frame_size(VP9D_COMP *pbi) {
diff --git a/vp9/encoder/vp9_lookahead.c b/vp9/encoder/vp9_lookahead.c
index 1bca9d267c..2214ac99bb 100644
--- a/vp9/encoder/vp9_lookahead.c
+++ b/vp9/encoder/vp9_lookahead.c
@@ -9,7 +9,9 @@
*/
#include <assert.h>
#include <stdlib.h>
+
#include "vpx_config.h"
+#include "vp9/common/vp9_common.h"
#include "vp9/encoder/vp9_lookahead.h"
#include "vp9/common/vp9_extend.h"
@@ -25,10 +27,9 @@ struct lookahead_ctx {
/* Return the buffer at the given absolute index and increment the index */
-static struct lookahead_entry *
-pop(struct lookahead_ctx *ctx,
- unsigned int *idx) {
- unsigned int index = *idx;
+static struct lookahead_entry * pop(struct lookahead_ctx *ctx,
+ unsigned int *idx) {
+ unsigned int index = *idx;
struct lookahead_entry *buf = ctx->buf + index;
assert(index < ctx->max_sz);
@@ -39,8 +40,7 @@ pop(struct lookahead_ctx *ctx,
}
-void
-vp9_lookahead_destroy(struct lookahead_ctx *ctx) {
+void vp9_lookahead_destroy(struct lookahead_ctx *ctx) {
if (ctx) {
if (ctx->buf) {
unsigned int i;
@@ -54,23 +54,19 @@ vp9_lookahead_destroy(struct lookahead_ctx *ctx) {
}
-struct lookahead_ctx *
-vp9_lookahead_init(unsigned int width,
- unsigned int height,
- unsigned int depth) {
+struct lookahead_ctx * vp9_lookahead_init(unsigned int width,
+ unsigned int height,
+ unsigned int depth) {
struct lookahead_ctx *ctx = NULL;
- /* Clamp the lookahead queue depth */
- if (depth < 1)
- depth = 1;
- else if (depth > MAX_LAG_BUFFERS)
- depth = MAX_LAG_BUFFERS;
+ // Clamp the lookahead queue depth
+ depth = clamp(depth, 1, MAX_LAG_BUFFERS);
- /* Align the buffer dimensions */
+ // Align the buffer dimensions
width = (width + 15) &~15;
height = (height + 15) &~15;
- /* Allocate the lookahead structures */
+ // Allocate the lookahead structures
ctx = calloc(1, sizeof(*ctx));
if (ctx) {
unsigned int i;
@@ -90,13 +86,9 @@ bail:
}
-int
-vp9_lookahead_push(struct lookahead_ctx *ctx,
- YV12_BUFFER_CONFIG *src,
- int64_t ts_start,
- int64_t ts_end,
- unsigned int flags,
- unsigned char *active_map) {
+int vp9_lookahead_push(struct lookahead_ctx *ctx, YV12_BUFFER_CONFIG *src,
+ int64_t ts_start, int64_t ts_end, unsigned int flags,
+ unsigned char *active_map) {
struct lookahead_entry *buf;
int row, col, active_end;
int mb_rows = (src->y_height + 15) >> 4;
@@ -156,9 +148,8 @@ vp9_lookahead_push(struct lookahead_ctx *ctx,
}
-struct lookahead_entry *
-vp9_lookahead_pop(struct lookahead_ctx *ctx,
- int drain) {
+struct lookahead_entry * vp9_lookahead_pop(struct lookahead_ctx *ctx,
+ int drain) {
struct lookahead_entry *buf = NULL;
if (ctx->sz && (drain || ctx->sz == ctx->max_sz)) {
@@ -169,9 +160,8 @@ vp9_lookahead_pop(struct lookahead_ctx *ctx,
}
-struct lookahead_entry *
-vp9_lookahead_peek(struct lookahead_ctx *ctx,
- int index) {
+struct lookahead_entry * vp9_lookahead_peek(struct lookahead_ctx *ctx,
+ int index) {
struct lookahead_entry *buf = NULL;
assert(index < (int)ctx->max_sz);
@@ -184,8 +174,6 @@ vp9_lookahead_peek(struct lookahead_ctx *ctx,
return buf;
}
-
-unsigned int
-vp9_lookahead_depth(struct lookahead_ctx *ctx) {
+unsigned int vp9_lookahead_depth(struct lookahead_ctx *ctx) {
return ctx->sz;
}
diff --git a/vp9/encoder/vp9_lookahead.h b/vp9/encoder/vp9_lookahead.h
index a7aad46a59..2406618b9c 100644
--- a/vp9/encoder/vp9_lookahead.h
+++ b/vp9/encoder/vp9_lookahead.h
@@ -28,17 +28,13 @@ struct lookahead_ctx;
*
* The lookahead stage is a queue of frame buffers on which some analysis
* may be done when buffers are enqueued.
- *
- *
*/
struct lookahead_ctx *vp9_lookahead_init(unsigned int width,
unsigned int height,
- unsigned int depth
- );
+ unsigned int depth);
/**\brief Destroys the lookahead stage
- *
*/
void vp9_lookahead_destroy(struct lookahead_ctx *ctx);
@@ -58,13 +54,9 @@ void vp9_lookahead_destroy(struct lookahead_ctx *ctx);
* \param[in] flags Flags set on this frame
* \param[in] active_map Map that specifies which macroblock is active
*/
-int
-vp9_lookahead_push(struct lookahead_ctx *ctx,
- YV12_BUFFER_CONFIG *src,
- int64_t ts_start,
- int64_t ts_end,
- unsigned int flags,
- unsigned char *active_map);
+int vp9_lookahead_push(struct lookahead_ctx *ctx, YV12_BUFFER_CONFIG *src,
+ int64_t ts_start, int64_t ts_end, unsigned int flags,
+ unsigned char *active_map);
/**\brief Get the next source buffer to encode
@@ -76,11 +68,9 @@ vp9_lookahead_push(struct lookahead_ctx *ctx,
*
* \retval NULL, if drain set and queue is empty
* \retval NULL, if drain not set and queue not of the configured depth
- *
*/
-struct lookahead_entry *
-vp9_lookahead_pop(struct lookahead_ctx *ctx,
- int drain);
+struct lookahead_entry *vp9_lookahead_pop(struct lookahead_ctx *ctx,
+ int drain);
/**\brief Get a future source buffer to encode
@@ -89,18 +79,15 @@ vp9_lookahead_pop(struct lookahead_ctx *ctx,
* \param[in] index Index of the frame to be returned, 0 == next frame
*
* \retval NULL, if no buffer exists at the specified index
- *
*/
-struct lookahead_entry *
-vp9_lookahead_peek(struct lookahead_ctx *ctx,
- int index);
+struct lookahead_entry *vp9_lookahead_peek(struct lookahead_ctx *ctx,
+ int index);
/**\brief Get the number of frames currently in the lookahead queue
*
* \param[in] ctx Pointer to the lookahead context
*/
-unsigned int
-vp9_lookahead_depth(struct lookahead_ctx *ctx);
+unsigned int vp9_lookahead_depth(struct lookahead_ctx *ctx);
#endif // VP9_ENCODER_VP9_LOOKAHEAD_H_
--
GitLab