ref: 6e336f6e5f623929018c2db84472f1b2f5d67a85
parent: 5b55bcc5640f34e4b595dbbf41806abab6e18cf1
parent: 7f3e07f1c842c586508a36ade0ca6cdcc809645b
author: James Zern <jzern@google.com>
date: Tue Jul 19 17:24:29 EDT 2016
Merge "vp8: apply clang-tidy google-readability-braces-around-statements"
--- a/vp8/common/alloccommon.c
+++ b/vp8/common/alloccommon.c
@@ -19,14 +19,16 @@
void vp8_de_alloc_frame_buffers(VP8_COMMON *oci) {int i;
- for (i = 0; i < NUM_YV12_BUFFERS; ++i)
+ for (i = 0; i < NUM_YV12_BUFFERS; ++i) {vp8_yv12_de_alloc_frame_buffer(&oci->yv12_fb[i]);
+ }
vp8_yv12_de_alloc_frame_buffer(&oci->temp_scale_frame);
#if CONFIG_POSTPROC
vp8_yv12_de_alloc_frame_buffer(&oci->post_proc_buffer);
- if (oci->post_proc_buffer_int_used)
+ if (oci->post_proc_buffer_int_used) {vp8_yv12_de_alloc_frame_buffer(&oci->post_proc_buffer_int);
+ }
vpx_free(oci->pp_limits_buffer);
oci->pp_limits_buffer = NULL;
@@ -60,8 +62,9 @@
oci->fb_idx_ref_cnt[i] = 0;
oci->yv12_fb[i].flags = 0;
if (vp8_yv12_alloc_frame_buffer(&oci->yv12_fb[i], width, height,
- VP8BORDERINPIXELS) < 0)
+ VP8BORDERINPIXELS) < 0) {goto allocation_fail;
+ }
}
oci->new_fb_idx = 0;
@@ -75,8 +78,9 @@
oci->fb_idx_ref_cnt[3] = 1;
if (vp8_yv12_alloc_frame_buffer(&oci->temp_scale_frame, width, 16,
- VP8BORDERINPIXELS) < 0)
+ VP8BORDERINPIXELS) < 0) {goto allocation_fail;
+ }
oci->mb_rows = height >> 4;
oci->mb_cols = width >> 4;
@@ -99,8 +103,9 @@
#if CONFIG_POSTPROC
if (vp8_yv12_alloc_frame_buffer(&oci->post_proc_buffer, width, height,
- VP8BORDERINPIXELS) < 0)
+ VP8BORDERINPIXELS) < 0) {goto allocation_fail;
+ }
oci->post_proc_buffer_int_used = 0;
memset(&oci->postproc_state, 0, sizeof(oci->postproc_state));
--- a/vp8/common/filter.c
+++ b/vp8/common/filter.c
@@ -51,10 +51,11 @@
/* Normalize back to 0-255 */
Temp = Temp >> VP8_FILTER_SHIFT;
- if (Temp < 0)
+ if (Temp < 0) {Temp = 0;
- else if (Temp > 255)
+ } else if (Temp > 255) {Temp = 255;
+ }
output_ptr[j] = Temp;
src_ptr++;
@@ -90,10 +91,11 @@
/* Normalize back to 0-255 */
Temp = Temp >> VP8_FILTER_SHIFT;
- if (Temp < 0)
+ if (Temp < 0) {Temp = 0;
- else if (Temp > 255)
+ } else if (Temp > 255) {Temp = 255;
+ }
output_ptr[j] = (unsigned char)Temp;
src_ptr++;
--- a/vp8/common/findnearmv.c
+++ b/vp8/common/findnearmv.c
@@ -62,8 +62,9 @@
}
*cntx += 2;
- } else
+ } else {cnt[CNT_INTRA] += 2;
+ }
}
/* Process above left */
@@ -81,8 +82,9 @@
}
*cntx += 1;
- } else
+ } else {cnt[CNT_INTRA] += 1;
+ }
}
/* If we have three distinct MV's ... */
@@ -107,8 +109,9 @@
}
/* Use near_mvs[0] to store the "best" MV */
- if (cnt[CNT_NEAREST] >= cnt[CNT_INTRA])
+ if (cnt[CNT_NEAREST] >= cnt[CNT_INTRA]) {near_mvs[CNT_INTRA] = near_mvs[CNT_NEAREST];
+ }
/* Set up return values */
best_mv->as_int = near_mvs[0].as_int;
--- a/vp8/common/findnearmv.h
+++ b/vp8/common/findnearmv.h
@@ -32,15 +32,17 @@
#define LEFT_TOP_MARGIN (16 << 3)
#define RIGHT_BOTTOM_MARGIN (16 << 3)
static INLINE void vp8_clamp_mv2(int_mv *mv, const MACROBLOCKD *xd) {- if (mv->as_mv.col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
+ if (mv->as_mv.col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN)) {mv->as_mv.col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
- else if (mv->as_mv.col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
+ } else if (mv->as_mv.col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN) {mv->as_mv.col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
+ }
- if (mv->as_mv.row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
+ if (mv->as_mv.row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN)) {mv->as_mv.row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
- else if (mv->as_mv.row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
+ } else if (mv->as_mv.row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN) {mv->as_mv.row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
+ }
}
static INLINE void vp8_clamp_mv(int_mv *mv, int mb_to_left_edge,
--- a/vp8/common/idct_blk.c
+++ b/vp8/common/idct_blk.c
@@ -24,9 +24,9 @@
for (i = 0; i < 4; ++i) { for (j = 0; j < 4; ++j) {- if (*eobs++ > 1)
+ if (*eobs++ > 1) {vp8_dequant_idct_add_c(q, dq, dst, stride);
- else {+ } else {vp8_dc_only_idct_add_c(q[0] * dq[0], dst, stride, dst, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
@@ -46,9 +46,9 @@
for (i = 0; i < 2; ++i) { for (j = 0; j < 2; ++j) {- if (*eobs++ > 1)
+ if (*eobs++ > 1) {vp8_dequant_idct_add_c(q, dq, dstu, stride);
- else {+ } else {vp8_dc_only_idct_add_c(q[0] * dq[0], dstu, stride, dstu, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
@@ -62,9 +62,9 @@
for (i = 0; i < 2; ++i) { for (j = 0; j < 2; ++j) {- if (*eobs++ > 1)
+ if (*eobs++ > 1) {vp8_dequant_idct_add_c(q, dq, dstv, stride);
- else {+ } else {vp8_dc_only_idct_add_c(q[0] * dq[0], dstv, stride, dstv, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
--- a/vp8/common/loopfilter_filters.c
+++ b/vp8/common/loopfilter_filters.c
@@ -298,13 +298,15 @@
vp8_mbloop_filter_horizontal_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_horizontal_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_mbloop_filter_horizontal_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
}
/* Vertical MB Filtering */
@@ -314,13 +316,15 @@
vp8_mbloop_filter_vertical_edge_c(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_vertical_edge_c(u_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_mbloop_filter_vertical_edge_c(v_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
}
/* Horizontal B Filtering */
@@ -334,13 +338,15 @@
vp8_loop_filter_horizontal_edge_c(y_ptr + 12 * y_stride, y_stride, lfi->blim,
lfi->lim, lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_horizontal_edge_c(u_ptr + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_loop_filter_horizontal_edge_c(v_ptr + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
+ }
}
void vp8_loop_filter_bhs_c(unsigned char *y_ptr, int y_stride,
@@ -364,13 +370,15 @@
vp8_loop_filter_vertical_edge_c(y_ptr + 12, y_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_vertical_edge_c(u_ptr + 4, uv_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_loop_filter_vertical_edge_c(v_ptr + 4, uv_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 1);
+ }
}
void vp8_loop_filter_bvs_c(unsigned char *y_ptr, int y_stride,
--- a/vp8/common/mfqe.c
+++ b/vp8/common/mfqe.c
@@ -196,19 +196,21 @@
{vp8_copy_mem8x8(y, y_stride, yd, yd_stride);
for (up = u, udp = ud, i = 0; i < uvblksize;
- ++i, up += uv_stride, udp += uvd_stride)
+ ++i, up += uv_stride, udp += uvd_stride) {memcpy(udp, up, uvblksize);
+ }
for (vp = v, vdp = vd, i = 0; i < uvblksize;
- ++i, vp += uv_stride, vdp += uvd_stride)
+ ++i, vp += uv_stride, vdp += uvd_stride) {memcpy(vdp, vp, uvblksize);
+ }
}
}
}
static int qualify_inter_mb(const MODE_INFO *mode_info_context, int *map) {- if (mode_info_context->mbmi.mb_skip_coeff)
+ if (mode_info_context->mbmi.mb_skip_coeff) {map[0] = map[1] = map[2] = map[3] = 1;
- else if (mode_info_context->mbmi.mode == SPLITMV) {+ } else if (mode_info_context->mbmi.mode == SPLITMV) { static int ndx[4][4] = { { 0, 1, 4, 5 }, { 2, 3, 6, 7 }, { 8, 9, 12, 13 }, { 10, 11, 14, 15 }};
@@ -215,9 +217,10 @@
int i, j;
for (i = 0; i < 4; ++i) {map[i] = 1;
- for (j = 0; j < 4 && map[j]; ++j)
+ for (j = 0; j < 4 && map[j]; ++j) {map[i] &= (mode_info_context->bmi[ndx[i][j]].mv.as_mv.row <= 2 &&
mode_info_context->bmi[ndx[i][j]].mv.as_mv.col <= 2);
+ }
}
} else {map[0] = map[1] = map[2] = map[3] =
@@ -256,14 +259,15 @@
for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) { for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {/* if motion is high there will likely be no benefit */
- if (frame_type == INTER_FRAME)
+ if (frame_type == INTER_FRAME) {totmap = qualify_inter_mb(mode_info_context, map);
- else
+ } else {totmap = (frame_type == KEY_FRAME ? 4 : 0);
+ }
if (totmap) { if (totmap < 4) {int i, j;
- for (i = 0; i < 2; ++i)
+ for (i = 0; i < 2; ++i) { for (j = 0; j < 2; ++j) { if (map[i * 2 + j]) {multiframe_quality_enhance_block(
@@ -292,6 +296,7 @@
}
}
}
+ }
} else /* totmap = 4 */
{multiframe_quality_enhance_block(
--- a/vp8/common/postproc.c
+++ b/vp8/common/postproc.c
@@ -116,10 +116,11 @@
for (mbc = 0; mbc < cm->mb_cols; ++mbc) {unsigned char mb_ppl;
- if (mode_info_context->mbmi.mb_skip_coeff)
+ if (mode_info_context->mbmi.mb_skip_coeff) {mb_ppl = (unsigned char)ppl >> 1;
- else
+ } else {mb_ppl = (unsigned char)ppl;
+ }
memset(ylptr, mb_ppl, 16);
memset(uvlptr, mb_ppl, 8);
@@ -378,9 +379,10 @@
int height = (oci->Height + 15) & ~15;
if (vp8_yv12_alloc_frame_buffer(&oci->post_proc_buffer_int, width, height,
- VP8BORDERINPIXELS))
+ VP8BORDERINPIXELS)) {vpx_internal_error(&oci->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate MFQE framebuffer");
+ }
oci->post_proc_buffer_int_used = 1;
--- a/vp8/common/quant_common.c
+++ b/vp8/common/quant_common.c
@@ -39,10 +39,11 @@
QIndex = QIndex + Delta;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
retval = dc_qlookup[QIndex];
return retval;
@@ -53,10 +54,11 @@
QIndex = QIndex + Delta;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
retval = dc_qlookup[QIndex] * 2;
return retval;
@@ -66,10 +68,11 @@
QIndex = QIndex + Delta;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
retval = dc_qlookup[QIndex];
@@ -81,10 +84,11 @@
int vp8_ac_yquant(int QIndex) {int retval;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
retval = ac_qlookup[QIndex];
return retval;
@@ -95,10 +99,11 @@
QIndex = QIndex + Delta;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
/* For all x in [0..284], x*155/100 is bitwise equal to (x*101581) >> 16.
* The smallest precision for that is '(x*6349) >> 12' but 16 is a good
@@ -114,10 +119,11 @@
QIndex = QIndex + Delta;
- if (QIndex > 127)
+ if (QIndex > 127) {QIndex = 127;
- else if (QIndex < 0)
+ } else if (QIndex < 0) {QIndex = 0;
+ }
retval = ac_qlookup[QIndex];
return retval;
--- a/vp8/common/reconinter.c
+++ b/vp8/common/reconinter.c
@@ -208,9 +208,9 @@
BLOCKD *d0 = &x->block[i];
BLOCKD *d1 = &x->block[i + 1];
- if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
+ if (d0->bmi.mv.as_int == d1->bmi.mv.as_int) {build_inter_predictors2b(x, d0, d0->predictor, 8, base_pre, pre_stride);
- else {+ } else {vp8_build_inter_predictors_b(d0, 8, base_pre, pre_stride,
x->subpixel_predict);
vp8_build_inter_predictors_b(d1, 8, base_pre, pre_stride,
@@ -223,9 +223,9 @@
BLOCKD *d0 = &x->block[i];
BLOCKD *d1 = &x->block[i + 1];
- if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
+ if (d0->bmi.mv.as_int == d1->bmi.mv.as_int) {build_inter_predictors2b(x, d0, d0->predictor, 8, base_pre, pre_stride);
- else {+ } else {vp8_build_inter_predictors_b(d0, 8, base_pre, pre_stride,
x->subpixel_predict);
vp8_build_inter_predictors_b(d1, 8, base_pre, pre_stride,
@@ -264,15 +264,17 @@
* filtering. The bottom and right edges use 16 pixels plus 2 pixels
* left of the central pixel when filtering.
*/
- if (mv->col < (xd->mb_to_left_edge - (19 << 3)))
+ if (mv->col < (xd->mb_to_left_edge - (19 << 3))) {mv->col = xd->mb_to_left_edge - (16 << 3);
- else if (mv->col > xd->mb_to_right_edge + (18 << 3))
+ } else if (mv->col > xd->mb_to_right_edge + (18 << 3)) {mv->col = xd->mb_to_right_edge + (16 << 3);
+ }
- if (mv->row < (xd->mb_to_top_edge - (19 << 3)))
+ if (mv->row < (xd->mb_to_top_edge - (19 << 3))) {mv->row = xd->mb_to_top_edge - (16 << 3);
- else if (mv->row > xd->mb_to_bottom_edge + (18 << 3))
+ } else if (mv->row > xd->mb_to_bottom_edge + (18 << 3)) {mv->row = xd->mb_to_bottom_edge + (16 << 3);
+ }
}
/* A version of the above function for chroma block MVs.*/
@@ -392,10 +394,10 @@
clamp_mv_to_umv_border(&x->block[i + 1].bmi.mv.as_mv, x);
}
- if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
+ if (d0->bmi.mv.as_int == d1->bmi.mv.as_int) {build_inter_predictors2b(x, d0, base_dst + d0->offset, dst_stride,
base_pre, dst_stride);
- else {+ } else {build_inter_predictors_b(d0, base_dst + d0->offset, dst_stride,
base_pre, dst_stride, x->subpixel_predict);
build_inter_predictors_b(d1, base_dst + d1->offset, dst_stride,
@@ -412,10 +414,10 @@
/* Note: uv mvs already clamped in build_4x4uvmvs() */
- if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
+ if (d0->bmi.mv.as_int == d1->bmi.mv.as_int) {build_inter_predictors2b(x, d0, base_dst + d0->offset, dst_stride,
base_pre, dst_stride);
- else {+ } else {build_inter_predictors_b(d0, base_dst + d0->offset, dst_stride, base_pre,
dst_stride, x->subpixel_predict);
build_inter_predictors_b(d1, base_dst + d1->offset, dst_stride, base_pre,
@@ -432,10 +434,10 @@
/* Note: uv mvs already clamped in build_4x4uvmvs() */
- if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
+ if (d0->bmi.mv.as_int == d1->bmi.mv.as_int) {build_inter_predictors2b(x, d0, base_dst + d0->offset, dst_stride,
base_pre, dst_stride);
- else {+ } else {build_inter_predictors_b(d0, base_dst + d0->offset, dst_stride, base_pre,
dst_stride, x->subpixel_predict);
build_inter_predictors_b(d1, base_dst + d1->offset, dst_stride, base_pre,
@@ -473,8 +475,9 @@
x->block[uoffset].bmi.mv.as_mv.col = (temp / 8) & x->fullpixel_mask;
- if (x->mode_info_context->mbmi.need_to_clamp_mvs)
+ if (x->mode_info_context->mbmi.need_to_clamp_mvs) {clamp_uvmv_to_umv_border(&x->block[uoffset].bmi.mv.as_mv, x);
+ }
x->block[voffset].bmi.mv.as_int = x->block[uoffset].bmi.mv.as_int;
}
--- a/vp8/common/setupintrarecon.c
+++ b/vp8/common/setupintrarecon.c
@@ -16,16 +16,19 @@
/* set up frame new frame for intra coded blocks */
memset(ybf->y_buffer - 1 - ybf->y_stride, 127, ybf->y_width + 5);
- for (i = 0; i < ybf->y_height; ++i)
+ for (i = 0; i < ybf->y_height; ++i) {ybf->y_buffer[ybf->y_stride * i - 1] = (unsigned char)129;
+ }
memset(ybf->u_buffer - 1 - ybf->uv_stride, 127, ybf->uv_width + 5);
- for (i = 0; i < ybf->uv_height; ++i)
+ for (i = 0; i < ybf->uv_height; ++i) {ybf->u_buffer[ybf->uv_stride * i - 1] = (unsigned char)129;
+ }
memset(ybf->v_buffer - 1 - ybf->uv_stride, 127, ybf->uv_width + 5);
- for (i = 0; i < ybf->uv_height; ++i)
+ for (i = 0; i < ybf->uv_height; ++i) {ybf->v_buffer[ybf->uv_stride * i - 1] = (unsigned char)129;
+ }
}
void vp8_setup_intra_recon_top_line(YV12_BUFFER_CONFIG *ybf) {--- a/vp8/common/treecoder.c
+++ b/vp8/common/treecoder.c
@@ -26,8 +26,9 @@
if (j <= 0) {p[-j].value = v;
p[-j].Len = L;
- } else
+ } else {tree2tok(p, t, j, v, L);
+ }
} while (++v & 1);
}
@@ -103,7 +104,8 @@
if (tot) {const unsigned int p = ((c[0] * Pfac) + (rd ? tot >> 1 : 0)) / tot;
probs[t] = p < 256 ? (p ? p : 1) : 255; /* agree w/old version for now */
- } else
+ } else {probs[t] = vp8_prob_half;
+ }
} while (++t < tree_len);
}
--- a/vp8/common/vp8_loopfilter.c
+++ b/vp8/common/vp8_loopfilter.c
@@ -60,8 +60,9 @@
block_inside_limit = block_inside_limit >> (sharpness_lvl > 4);
if (sharpness_lvl > 0) {- if (block_inside_limit > (9 - sharpness_lvl))
+ if (block_inside_limit > (9 - sharpness_lvl)) {block_inside_limit = (9 - sharpness_lvl);
+ }
}
if (block_inside_limit < 1) block_inside_limit = 1;
--- a/vp8/common/x86/idct_blk_mmx.c
+++ b/vp8/common/x86/idct_blk_mmx.c
@@ -27,30 +27,30 @@
int i;
for (i = 0; i < 4; ++i) {- if (eobs[0] > 1)
+ if (eobs[0] > 1) {vp8_dequant_idct_add_mmx(q, dq, dst, stride);
- else if (eobs[0] == 1) {+ } else if (eobs[0] == 1) {vp8_dc_only_idct_add_mmx(q[0] * dq[0], dst, stride, dst, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
- if (eobs[1] > 1)
+ if (eobs[1] > 1) {vp8_dequant_idct_add_mmx(q + 16, dq, dst + 4, stride);
- else if (eobs[1] == 1) {+ } else if (eobs[1] == 1) {vp8_dc_only_idct_add_mmx(q[16] * dq[0], dst + 4, stride, dst + 4, stride);
memset(q + 16, 0, 2 * sizeof(q[0]));
}
- if (eobs[2] > 1)
+ if (eobs[2] > 1) {vp8_dequant_idct_add_mmx(q + 32, dq, dst + 8, stride);
- else if (eobs[2] == 1) {+ } else if (eobs[2] == 1) {vp8_dc_only_idct_add_mmx(q[32] * dq[0], dst + 8, stride, dst + 8, stride);
memset(q + 32, 0, 2 * sizeof(q[0]));
}
- if (eobs[3] > 1)
+ if (eobs[3] > 1) {vp8_dequant_idct_add_mmx(q + 48, dq, dst + 12, stride);
- else if (eobs[3] == 1) {+ } else if (eobs[3] == 1) {vp8_dc_only_idct_add_mmx(q[48] * dq[0], dst + 12, stride, dst + 12,
stride);
memset(q + 48, 0, 2 * sizeof(q[0]));
@@ -68,16 +68,16 @@
int i;
for (i = 0; i < 2; ++i) {- if (eobs[0] > 1)
+ if (eobs[0] > 1) {vp8_dequant_idct_add_mmx(q, dq, dstu, stride);
- else if (eobs[0] == 1) {+ } else if (eobs[0] == 1) {vp8_dc_only_idct_add_mmx(q[0] * dq[0], dstu, stride, dstu, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
- if (eobs[1] > 1)
+ if (eobs[1] > 1) {vp8_dequant_idct_add_mmx(q + 16, dq, dstu + 4, stride);
- else if (eobs[1] == 1) {+ } else if (eobs[1] == 1) {vp8_dc_only_idct_add_mmx(q[16] * dq[0], dstu + 4, stride, dstu + 4,
stride);
memset(q + 16, 0, 2 * sizeof(q[0]));
@@ -89,16 +89,16 @@
}
for (i = 0; i < 2; ++i) {- if (eobs[0] > 1)
+ if (eobs[0] > 1) {vp8_dequant_idct_add_mmx(q, dq, dstv, stride);
- else if (eobs[0] == 1) {+ } else if (eobs[0] == 1) {vp8_dc_only_idct_add_mmx(q[0] * dq[0], dstv, stride, dstv, stride);
memset(q, 0, 2 * sizeof(q[0]));
}
- if (eobs[1] > 1)
+ if (eobs[1] > 1) {vp8_dequant_idct_add_mmx(q + 16, dq, dstv + 4, stride);
- else if (eobs[1] == 1) {+ } else if (eobs[1] == 1) {vp8_dc_only_idct_add_mmx(q[16] * dq[0], dstv + 4, stride, dstv + 4,
stride);
memset(q + 16, 0, 2 * sizeof(q[0]));
--- a/vp8/common/x86/idct_blk_sse2.c
+++ b/vp8/common/x86/idct_blk_sse2.c
@@ -22,16 +22,18 @@
for (i = 0; i < 4; ++i) { if (((short *)(eobs))[0]) {- if (((short *)(eobs))[0] & 0xfefe)
+ if (((short *)(eobs))[0] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q, dq, dst, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q, dq, dst, stride);
+ }
}
if (((short *)(eobs))[1]) {- if (((short *)(eobs))[1] & 0xfefe)
+ if (((short *)(eobs))[1] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q + 32, dq, dst + 8, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q + 32, dq, dst + 8, stride);
+ }
}
q += 64;
dst += stride * 4;
@@ -44,35 +46,39 @@
unsigned char *dstv, int stride,
char *eobs) { if (((short *)(eobs))[0]) {- if (((short *)(eobs))[0] & 0xfefe)
+ if (((short *)(eobs))[0] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q, dq, dstu, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q, dq, dstu, stride);
+ }
}
q += 32;
dstu += stride * 4;
if (((short *)(eobs))[1]) {- if (((short *)(eobs))[1] & 0xfefe)
+ if (((short *)(eobs))[1] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q, dq, dstu, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q, dq, dstu, stride);
+ }
}
q += 32;
if (((short *)(eobs))[2]) {- if (((short *)(eobs))[2] & 0xfefe)
+ if (((short *)(eobs))[2] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q, dq, dstv, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q, dq, dstv, stride);
+ }
}
q += 32;
dstv += stride * 4;
if (((short *)(eobs))[3]) {- if (((short *)(eobs))[3] & 0xfefe)
+ if (((short *)(eobs))[3] & 0xfefe) {vp8_idct_dequant_full_2x_sse2(q, dq, dstv, stride);
- else
+ } else {vp8_idct_dequant_0_2x_sse2(q, dq, dstv, stride);
+ }
}
}
--- a/vp8/common/x86/loopfilter_x86.c
+++ b/vp8/common/x86/loopfilter_x86.c
@@ -52,13 +52,15 @@
vp8_mbloop_filter_horizontal_edge_mmx(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_horizontal_edge_mmx(u_ptr, uv_stride, lfi->mblim,
lfi->lim, lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_mbloop_filter_horizontal_edge_mmx(v_ptr, uv_stride, lfi->mblim,
lfi->lim, lfi->hev_thr, 1);
+ }
}
/* Vertical MB Filtering */
@@ -68,13 +70,15 @@
vp8_mbloop_filter_vertical_edge_mmx(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_vertical_edge_mmx(u_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_mbloop_filter_vertical_edge_mmx(v_ptr, uv_stride, lfi->mblim, lfi->lim,
lfi->hev_thr, 1);
+ }
}
/* Horizontal B Filtering */
@@ -88,13 +92,15 @@
vp8_loop_filter_horizontal_edge_mmx(y_ptr + 12 * y_stride, y_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_horizontal_edge_mmx(u_ptr + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_loop_filter_horizontal_edge_mmx(v_ptr + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr, 1);
+ }
}
void vp8_loop_filter_bhs_mmx(unsigned char *y_ptr, int y_stride,
@@ -118,13 +124,15 @@
vp8_loop_filter_vertical_edge_mmx(y_ptr + 12, y_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 2);
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_vertical_edge_mmx(u_ptr + 4, uv_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 1);
+ }
- if (v_ptr)
+ if (v_ptr) {vp8_loop_filter_vertical_edge_mmx(v_ptr + 4, uv_stride, lfi->blim, lfi->lim,
lfi->hev_thr, 1);
+ }
}
void vp8_loop_filter_bvs_mmx(unsigned char *y_ptr, int y_stride,
@@ -143,9 +151,10 @@
vp8_mbloop_filter_horizontal_edge_sse2(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_horizontal_edge_uv_sse2(u_ptr, uv_stride, lfi->mblim,
lfi->lim, lfi->hev_thr, v_ptr);
+ }
}
/* Vertical MB Filtering */
@@ -155,9 +164,10 @@
vp8_mbloop_filter_vertical_edge_sse2(y_ptr, y_stride, lfi->mblim, lfi->lim,
lfi->hev_thr);
- if (u_ptr)
+ if (u_ptr) {vp8_mbloop_filter_vertical_edge_uv_sse2(u_ptr, uv_stride, lfi->mblim,
lfi->lim, lfi->hev_thr, v_ptr);
+ }
}
/* Horizontal B Filtering */
@@ -176,10 +186,11 @@
lfi->blim, lfi->lim, lfi->hev_thr);
#endif
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_horizontal_edge_uv_sse2(u_ptr + 4 * uv_stride, uv_stride,
lfi->blim, lfi->lim, lfi->hev_thr,
v_ptr + 4 * uv_stride);
+ }
}
void vp8_loop_filter_bhs_sse2(unsigned char *y_ptr, int y_stride,
@@ -208,9 +219,10 @@
lfi->hev_thr);
#endif
- if (u_ptr)
+ if (u_ptr) {vp8_loop_filter_vertical_edge_uv_sse2(u_ptr + 4, uv_stride, lfi->blim,
lfi->lim, lfi->hev_thr, v_ptr + 4);
+ }
}
void vp8_loop_filter_bvs_sse2(unsigned char *y_ptr, int y_stride,
--- a/vp8/decoder/decodeframe.c
+++ b/vp8/decoder/decodeframe.c
@@ -63,18 +63,20 @@
/* Decide whether to use the default or alternate baseline Q value. */
if (xd->segmentation_enabled) {/* Abs Value */
- if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
+ if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA) {QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
- /* Delta Value */
- else
+ /* Delta Value */
+ } else {QIndex = pc->base_qindex +
xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
+ }
QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ)
: 0; /* Clamp to valid range */
- } else
+ } else {QIndex = pc->base_qindex;
+ }
/* Set up the macroblock dequant constants */
xd->dequant_y1_dc[0] = 1;
@@ -602,14 +604,15 @@
if (pc->filter_level) { if (mb_row > 0) {- if (pc->filter_type == NORMAL_LOOPFILTER)
+ if (pc->filter_type == NORMAL_LOOPFILTER) {vp8_loop_filter_row_normal(pc, lf_mic, mb_row - 1, recon_y_stride,
recon_uv_stride, lf_dst[0], lf_dst[1],
lf_dst[2]);
- else
+ } else {vp8_loop_filter_row_simple(pc, lf_mic, mb_row - 1, recon_y_stride,
recon_uv_stride, lf_dst[0], lf_dst[1],
lf_dst[2]);
+ }
if (mb_row > 1) {yv12_extend_frame_left_right_c(yv12_fb_new, eb_dst[0], eb_dst[1],
eb_dst[2]);
@@ -638,14 +641,15 @@
}
if (pc->filter_level) {- if (pc->filter_type == NORMAL_LOOPFILTER)
+ if (pc->filter_type == NORMAL_LOOPFILTER) {vp8_loop_filter_row_normal(pc, lf_mic, mb_row - 1, recon_y_stride,
recon_uv_stride, lf_dst[0], lf_dst[1],
lf_dst[2]);
- else
+ } else {vp8_loop_filter_row_simple(pc, lf_mic, mb_row - 1, recon_y_stride,
recon_uv_stride, lf_dst[0], lf_dst[1],
lf_dst[2]);
+ }
yv12_extend_frame_left_right_c(yv12_fb_new, eb_dst[0], eb_dst[1],
eb_dst[2]);
@@ -688,15 +692,17 @@
* or throw an error.
*/
if (i < num_part - 1) {- if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
+ if (read_is_valid(partition_size_ptr, 3, first_fragment_end)) {partition_size = read_partition_size(pbi, partition_size_ptr);
- else if (pbi->ec_active)
+ } else if (pbi->ec_active) {partition_size = (unsigned int)bytes_left;
- else
+ } else {vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated partition size data");
- } else
+ }
+ } else {partition_size = (unsigned int)bytes_left;
+ }
/* Validate the calculated partition length. If the buffer
* described by the partition can't be fully read, then restrict
@@ -703,13 +709,14 @@
* it to the portion that can be (for EC mode) or throw an error.
*/
if (!read_is_valid(fragment_start, partition_size, fragment_end)) {- if (pbi->ec_active)
+ if (pbi->ec_active) {partition_size = (unsigned int)bytes_left;
- else
+ } else {vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt partition "
"%d length",
i + 1);
+ }
}
return partition_size;
}
@@ -725,8 +732,9 @@
TOKEN_PARTITION multi_token_partition =
(TOKEN_PARTITION)vp8_read_literal(&pbi->mbc[8], 2);
- if (!vp8dx_bool_error(&pbi->mbc[8]))
+ if (!vp8dx_bool_error(&pbi->mbc[8])) {pbi->common.multi_token_partition = multi_token_partition;
+ }
num_token_partitions = 1 << pbi->common.multi_token_partition;
/* Check for partitions within the fragments and unpack the fragments
@@ -777,9 +785,10 @@
++partition_idx) {if (vp8dx_start_decode(bool_decoder, pbi->fragments.ptrs[partition_idx],
pbi->fragments.sizes[partition_idx], pbi->decrypt_cb,
- pbi->decrypt_state))
+ pbi->decrypt_state)) {vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate bool decoder %d", partition_idx);
+ }
bool_decoder++;
}
@@ -786,8 +795,9 @@
#if CONFIG_MULTITHREAD
/* Clamp number of decoder threads */
- if (pbi->decoding_thread_count > num_token_partitions - 1)
+ if (pbi->decoding_thread_count > num_token_partitions - 1) {pbi->decoding_thread_count = num_token_partitions - 1;
+ }
#endif
}
@@ -836,8 +846,9 @@
xd->subpixel_predict16x16 = vp8_bilinear_predict16x16;
}
- if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active)
+ if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active) {pbi->ec_active = 1;
+ }
}
xd->left_context = &pc->left_context;
@@ -900,9 +911,10 @@
(clear[0] | (clear[1] << 8) | (clear[2] << 16)) >> 5;
if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end ||
- data + first_partition_length_in_bytes < data))
+ data + first_partition_length_in_bytes < data)) {vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt partition 0 length");
+ }
data += 3;
clear += 3;
@@ -915,9 +927,10 @@
* code if we have enough bits available
*/
if (!pbi->ec_active || data + 3 < data_end) {- if (clear[0] != 0x9d || clear[1] != 0x01 || clear[2] != 0x2a)
+ if (clear[0] != 0x9d || clear[1] != 0x01 || clear[2] != 0x2a) {vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
"Invalid frame sync code");
+ }
}
/* If error concealment is enabled we should only parse the new size
@@ -943,9 +956,10 @@
init_frame(pbi);
if (vp8dx_start_decode(bc, data, (unsigned int)(data_end - data),
- pbi->decrypt_cb, pbi->decrypt_state))
+ pbi->decrypt_cb, pbi->decrypt_state)) {vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate bool decoder 0");
+ }
if (pc->frame_type == KEY_FRAME) {(void)vp8_read_bit(bc); // colorspace
pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc);
@@ -973,10 +987,12 @@
xd->segment_feature_data[i][j] =
(signed char)vp8_read_literal(bc, mb_feature_data_bits[i]);
- if (vp8_read_bit(bc))
+ if (vp8_read_bit(bc)) {xd->segment_feature_data[i][j] = -xd->segment_feature_data[i][j];
- } else
+ }
+ } else {xd->segment_feature_data[i][j] = 0;
+ }
}
}
}
@@ -988,8 +1004,9 @@
/* Read the probs used to decode the segment id for each macro block. */
for (i = 0; i < MB_FEATURE_TREE_PROBS; ++i) {/* If not explicitly set value is defaulted to 255 by memset above */
- if (vp8_read_bit(bc))
+ if (vp8_read_bit(bc)) {xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
+ }
}
}
} else {@@ -1019,8 +1036,9 @@
/*sign = vp8_read_bit( bc );*/
xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);
- if (vp8_read_bit(bc)) /* Apply sign */
+ if (vp8_read_bit(bc)) { /* Apply sign */xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
+ }
}
}
@@ -1030,8 +1048,9 @@
/*sign = vp8_read_bit( bc );*/
xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);
- if (vp8_read_bit(bc)) /* Apply sign */
+ if (vp8_read_bit(bc)) { /* Apply sign */xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
+ }
}
}
}
@@ -1083,8 +1102,9 @@
/* Buffer to buffer copy flags. */
pc->copy_buffer_to_gf = 0;
- if (!pc->refresh_golden_frame)
+ if (!pc->refresh_golden_frame) {pc->copy_buffer_to_gf = vp8_read_literal(bc, 2);
+ }
#if CONFIG_ERROR_CONCEALMENT
/* Assume we shouldn't copy to the golden if the bit is missing */
@@ -1094,8 +1114,9 @@
pc->copy_buffer_to_arf = 0;
- if (!pc->refresh_alt_ref_frame)
+ if (!pc->refresh_alt_ref_frame) {pc->copy_buffer_to_arf = vp8_read_literal(bc, 2);
+ }
#if CONFIG_ERROR_CONCEALMENT
/* Assume we shouldn't copy to the alt-ref if the bit is missing */
@@ -1138,9 +1159,9 @@
pbi->independent_partitions = 1;
/* read coef probability tree */
- for (i = 0; i < BLOCK_TYPES; ++i)
- for (j = 0; j < COEF_BANDS; ++j)
- for (k = 0; k < PREV_COEF_CONTEXTS; ++k)
+ for (i = 0; i < BLOCK_TYPES; ++i) {+ for (j = 0; j < COEF_BANDS; ++j) {+ for (k = 0; k < PREV_COEF_CONTEXTS; ++k) { for (l = 0; l < ENTROPY_NODES; ++l) {vp8_prob *const p = pc->fc.coef_probs[i][j][k] + l;
@@ -1147,9 +1168,13 @@
if (vp8_read(bc, vp8_coef_update_probs[i][j][k][l])) {*p = (vp8_prob)vp8_read_literal(bc, 8);
}
- if (k > 0 && *p != pc->fc.coef_probs[i][j][k - 1][l])
+ if (k > 0 && *p != pc->fc.coef_probs[i][j][k - 1][l]) {pbi->independent_partitions = 0;
+ }
}
+ }
+ }
+ }
}
/* clear out the coeff buffer */
@@ -1174,8 +1199,9 @@
unsigned int thread;
vp8mt_decode_mb_rows(pbi, xd);
vp8_yv12_extend_frame_borders(yv12_fb_new);
- for (thread = 0; thread < pbi->decoding_thread_count; ++thread)
+ for (thread = 0; thread < pbi->decoding_thread_count; ++thread) {corrupt_tokens |= pbi->mb_row_di[thread].mbd.corrupted;
+ }
} else
#endif
{@@ -1190,11 +1216,12 @@
yv12_fb_new->corrupted |= corrupt_tokens;
if (!pbi->decoded_key_frame) {- if (pc->frame_type == KEY_FRAME && !yv12_fb_new->corrupted)
+ if (pc->frame_type == KEY_FRAME && !yv12_fb_new->corrupted) {pbi->decoded_key_frame = 1;
- else
+ } else {vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
"A stream must start with a complete key frame");
+ }
}
/* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes--- a/vp8/decoder/decodemv.c
+++ b/vp8/decoder/decodemv.c
@@ -82,8 +82,9 @@
} while (--i > 3);
if (!(x & 0xFFF0) || vp8_read(r, p[MVPbits + 3])) x += 8;
- } else /* small */
+ } else { /* small */x = vp8_treed_read(r, vp8_small_mvtree, p + MVPshort);
+ }
if (x && vp8_read(r, p[MVPsign])) x = -x;
@@ -135,8 +136,9 @@
pbi->common.mb_no_coeff_skip = (int)vp8_read_bit(bc);
pbi->prob_skip_false = 0;
- if (pbi->common.mb_no_coeff_skip)
+ if (pbi->common.mb_no_coeff_skip) {pbi->prob_skip_false = (vp8_prob)vp8_read_literal(bc, 8);
+ }
if (pbi->common.frame_type != KEY_FRAME) {pbi->prob_intra = (vp8_prob)vp8_read_literal(bc, 8);
@@ -218,21 +220,25 @@
if (!(k & 3)) {/* On L edge, get from MB to left of us */
- if (left_mb->mbmi.mode != SPLITMV)
+ if (left_mb->mbmi.mode != SPLITMV) {leftmv.as_int = left_mb->mbmi.mv.as_int;
- else
+ } else {leftmv.as_int = (left_mb->bmi + k + 4 - 1)->mv.as_int;
- } else
+ }
+ } else {leftmv.as_int = (mi->bmi + k - 1)->mv.as_int;
+ }
if (!(k >> 2)) {/* On top edge, get from MB above us */
- if (above_mb->mbmi.mode != SPLITMV)
+ if (above_mb->mbmi.mode != SPLITMV) {abovemv.as_int = above_mb->mbmi.mv.as_int;
- else
+ } else {abovemv.as_int = (above_mb->bmi + k + 16 - 4)->mv.as_int;
- } else
+ }
+ } else {abovemv.as_int = (mi->bmi + k - 4)->mv.as_int;
+ }
prob = get_sub_mv_ref_prob(leftmv.as_int, abovemv.as_int);
@@ -332,8 +338,9 @@
}
*cntx += 2;
- } else
+ } else {cnt[CNT_INTRA] += 2;
+ }
}
/* Process above left */
@@ -351,8 +358,9 @@
}
*cntx += 1;
- } else
+ } else {cnt[CNT_INTRA] += 1;
+ }
}
if (vp8_read(bc, vp8_mode_contexts[cnt[CNT_INTRA]][0])) {@@ -471,12 +479,13 @@
/* Is segmentation enabled */
if (x->segmentation_enabled && x->update_mb_segmentation_map) {/* If so then read the segment id. */
- if (vp8_read(r, x->mb_segment_tree_probs[0]))
+ if (vp8_read(r, x->mb_segment_tree_probs[0])) {mi->segment_id =
(unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
- else
+ } else {mi->segment_id =
(unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
+ }
}
}
@@ -488,23 +497,26 @@
* this frame (reset to 0 above by default)
* By default on a key frame reset all MBs to segment 0
*/
- if (pbi->mb.update_mb_segmentation_map)
+ if (pbi->mb.update_mb_segmentation_map) {read_mb_features(&pbi->mbc[8], &mi->mbmi, &pbi->mb);
- else if (pbi->common.frame_type == KEY_FRAME)
+ } else if (pbi->common.frame_type == KEY_FRAME) {mi->mbmi.segment_id = 0;
+ }
/* Read the macroblock coeff skip flag if this feature is in use,
* else default to 0 */
- if (pbi->common.mb_no_coeff_skip)
+ if (pbi->common.mb_no_coeff_skip) {mi->mbmi.mb_skip_coeff = vp8_read(&pbi->mbc[8], pbi->prob_skip_false);
- else
+ } else {mi->mbmi.mb_skip_coeff = 0;
+ }
mi->mbmi.is_4x4 = 0;
- if (pbi->common.frame_type == KEY_FRAME)
+ if (pbi->common.frame_type == KEY_FRAME) {read_kf_modes(pbi, mi);
- else
+ } else {read_mb_modes_mv(pbi, mi, &mi->mbmi);
+ }
}
void vp8_decode_mode_mvs(VP8D_COMP *pbi) {--- a/vp8/decoder/onyxd_if.c
+++ b/vp8/decoder/onyxd_if.c
@@ -125,13 +125,13 @@
VP8_COMMON *cm = &pbi->common;
int ref_fb_idx;
- if (ref_frame_flag == VP8_LAST_FRAME)
+ if (ref_frame_flag == VP8_LAST_FRAME) {ref_fb_idx = cm->lst_fb_idx;
- else if (ref_frame_flag == VP8_GOLD_FRAME)
+ } else if (ref_frame_flag == VP8_GOLD_FRAME) {ref_fb_idx = cm->gld_fb_idx;
- else if (ref_frame_flag == VP8_ALTR_FRAME)
+ } else if (ref_frame_flag == VP8_ALTR_FRAME) {ref_fb_idx = cm->alt_fb_idx;
- else {+ } else {vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
"Invalid reference frame");
return pbi->common.error.error_code;
@@ -156,13 +156,13 @@
int *ref_fb_ptr = NULL;
int free_fb;
- if (ref_frame_flag == VP8_LAST_FRAME)
+ if (ref_frame_flag == VP8_LAST_FRAME) {ref_fb_ptr = &cm->lst_fb_idx;
- else if (ref_frame_flag == VP8_GOLD_FRAME)
+ } else if (ref_frame_flag == VP8_GOLD_FRAME) {ref_fb_ptr = &cm->gld_fb_idx;
- else if (ref_frame_flag == VP8_ALTR_FRAME)
+ } else if (ref_frame_flag == VP8_ALTR_FRAME) {ref_fb_ptr = &cm->alt_fb_idx;
- else {+ } else {vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
"Invalid reference frame");
return pbi->common.error.error_code;
@@ -191,8 +191,9 @@
static int get_free_fb(VP8_COMMON *cm) {int i;
- for (i = 0; i < NUM_YV12_BUFFERS; ++i)
+ for (i = 0; i < NUM_YV12_BUFFERS; ++i) {if (cm->fb_idx_ref_cnt[i] == 0) break;
+ }
assert(i < NUM_YV12_BUFFERS);
cm->fb_idx_ref_cnt[i] = 1;
@@ -219,12 +220,13 @@
if (cm->copy_buffer_to_arf) {int new_fb = 0;
- if (cm->copy_buffer_to_arf == 1)
+ if (cm->copy_buffer_to_arf == 1) {new_fb = cm->lst_fb_idx;
- else if (cm->copy_buffer_to_arf == 2)
+ } else if (cm->copy_buffer_to_arf == 2) {new_fb = cm->gld_fb_idx;
- else
+ } else {err = -1;
+ }
ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->alt_fb_idx, new_fb);
}
@@ -232,28 +234,32 @@
if (cm->copy_buffer_to_gf) {int new_fb = 0;
- if (cm->copy_buffer_to_gf == 1)
+ if (cm->copy_buffer_to_gf == 1) {new_fb = cm->lst_fb_idx;
- else if (cm->copy_buffer_to_gf == 2)
+ } else if (cm->copy_buffer_to_gf == 2) {new_fb = cm->alt_fb_idx;
- else
+ } else {err = -1;
+ }
ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->gld_fb_idx, new_fb);
}
- if (cm->refresh_golden_frame)
+ if (cm->refresh_golden_frame) {ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->gld_fb_idx, cm->new_fb_idx);
+ }
- if (cm->refresh_alt_ref_frame)
+ if (cm->refresh_alt_ref_frame) {ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->alt_fb_idx, cm->new_fb_idx);
+ }
if (cm->refresh_last_frame) {ref_cnt_fb(cm->fb_idx_ref_cnt, &cm->lst_fb_idx, cm->new_fb_idx);
cm->frame_to_show = &cm->yv12_fb[cm->lst_fb_idx];
- } else
+ } else {cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
+ }
cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
@@ -322,8 +328,9 @@
*/
cm->yv12_fb[cm->lst_fb_idx].corrupted = 1;
- if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0)
+ if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0) {cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
+ }
goto decode_exit;
}
@@ -333,8 +340,9 @@
retcode = vp8_decode_frame(pbi);
if (retcode < 0) {- if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0)
+ if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0) {cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
+ }
pbi->common.error.error_code = VPX_CODEC_ERROR;
goto decode_exit;
@@ -456,8 +464,9 @@
if (!pbi) return VPX_CODEC_ERROR;
#if CONFIG_MULTITHREAD
- if (pbi->b_multithreaded_rd)
+ if (pbi->b_multithreaded_rd) {vp8mt_de_alloc_temp_buffers(pbi, pbi->common.mb_rows);
+ }
vp8_decoder_remove_threads(pbi);
#endif
--- a/vp8/decoder/threading.c
+++ b/vp8/decoder/threading.c
@@ -166,10 +166,11 @@
/*Caution: For some b_mode, it needs 8 pixels (4 above + 4
* above-right).*/
- if (i < 4 && pbi->common.filter_level)
+ if (i < 4 && pbi->common.filter_level) {Above = xd->recon_above[0] + b->offset;
- else
+ } else {Above = dst - dst_stride;
+ }
if (i % 4 == 0 && pbi->common.filter_level) {yleft = xd->recon_left[0] + i;
@@ -179,10 +180,11 @@
left_stride = dst_stride;
}
- if ((i == 4 || i == 8 || i == 12) && pbi->common.filter_level)
+ if ((i == 4 || i == 8 || i == 12) && pbi->common.filter_level) {top_left = *(xd->recon_left[0] + i - 1);
- else
+ } else {top_left = Above[-1];
+ }
vp8_intra4x4_predict(Above, yleft, left_stride, b_mode, dst, dst_stride,
top_left);
@@ -299,10 +301,11 @@
/* select bool coder for current partition */
xd->current_bc = &pbi->mbc[mb_row % num_part];
- if (mb_row > 0)
+ if (mb_row > 0) {last_row_current_mb_col = &pbi->mt_current_mb_col[mb_row - 1];
- else
+ } else {last_row_current_mb_col = &first_row_no_sync_above;
+ }
current_mb_col = &pbi->mt_current_mb_col[mb_row];
@@ -452,9 +455,10 @@
MODE_INFO *next = xd->mode_info_context + 1;
if (next->mbmi.ref_frame == INTRA_FRAME) {- for (i = 0; i < 16; ++i)
+ for (i = 0; i < 16; ++i) {pbi->mt_yleft_col[mb_row][i] =
xd->dst.y_buffer[i * recon_y_stride + 15];
+ }
for (i = 0; i < 8; ++i) {pbi->mt_uleft_col[mb_row][i] =
xd->dst.u_buffer[i * recon_uv_stride + 7];
@@ -539,9 +543,10 @@
pbi->mt_vabove_row[mb_row + 1][lastuv - 1];
}
}
- } else
+ } else {vp8_extend_mb_row(yv12_fb_new, xd->dst.y_buffer + 16,
xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
+ }
/* last MB of row is ready just after extension is done */
protected_write(&pbi->pmutex[mb_row], current_mb_col, mb_col + nsync);
@@ -567,9 +572,9 @@
if (protected_read(&pbi->mt_mutex, &pbi->b_multithreaded_rd) == 0) break;
if (sem_wait(&pbi->h_event_start_decoding[ithread]) == 0) {- if (protected_read(&pbi->mt_mutex, &pbi->b_multithreaded_rd) == 0)
+ if (protected_read(&pbi->mt_mutex, &pbi->b_multithreaded_rd) == 0) {break;
- else {+ } else {MACROBLOCKD *xd = &mbrd->mbd;
xd->left_context = &mb_row_left_context;
@@ -593,8 +598,9 @@
core_count = (pbi->max_threads > 8) ? 8 : pbi->max_threads;
/* limit decoding threads to the available cores */
- if (core_count > pbi->common.processor_core_count)
+ if (core_count > pbi->common.processor_core_count) {core_count = pbi->common.processor_core_count;
+ }
if (core_count > 1) {pbi->b_multithreaded_rd = 1;
@@ -709,14 +715,15 @@
/* our internal buffers are always multiples of 16 */
if ((width & 0xf) != 0) width += 16 - (width & 0xf);
- if (width < 640)
+ if (width < 640) {pbi->sync_range = 1;
- else if (width <= 1280)
+ } else if (width <= 1280) {pbi->sync_range = 8;
- else if (width <= 2560)
+ } else if (width <= 2560) {pbi->sync_range = 16;
- else
+ } else {pbi->sync_range = 32;
+ }
uv_width = width >> 1;
@@ -838,14 +845,16 @@
/* Initialize the loop filter for this frame. */
vp8_loop_filter_frame_init(pc, &pbi->mb, filter_level);
- } else
+ } else {vp8_setup_intra_recon_top_line(yv12_fb_new);
+ }
setup_decoding_thread_data(pbi, xd, pbi->mb_row_di,
pbi->decoding_thread_count);
- for (i = 0; i < pbi->decoding_thread_count; ++i)
+ for (i = 0; i < pbi->decoding_thread_count; ++i) {sem_post(&pbi->h_event_start_decoding[i]);
+ }
mt_decode_mb_rows(pbi, xd, 0);
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -400,8 +400,9 @@
rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
/* Calculate the probabilities used to code the ref frame based on usage */
- if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter)))
+ if (!(cpi->prob_intra_coded = rf_intra * 255 / (rf_intra + rf_inter))) {cpi->prob_intra_coded = 1;
+ }
cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
@@ -478,11 +479,13 @@
active_section = 9;
#endif
- if (cpi->mb.e_mbd.update_mb_segmentation_map)
+ if (cpi->mb.e_mbd.update_mb_segmentation_map) {write_mb_features(w, mi, &cpi->mb.e_mbd);
+ }
- if (pc->mb_no_coeff_skip)
+ if (pc->mb_no_coeff_skip) {vp8_encode_bool(w, m->mbmi.mb_skip_coeff, prob_skip_false);
+ }
if (rf == INTRA_FRAME) {vp8_write(w, 0, cpi->prob_intra_coded);
@@ -494,9 +497,9 @@
if (mode == B_PRED) {int j = 0;
- do
+ do {write_bmode(w, m->bmi[j].as_mode, pc->fc.bmode_prob);
- while (++j < 16);
+ } while (++j < 16);
}
write_uv_mode(w, mi->uv_mode, pc->fc.uv_mode_prob);
@@ -566,8 +569,9 @@
blockmode = cpi->mb.partition_info->bmi[j].mode;
blockmv = cpi->mb.partition_info->bmi[j].mv;
#if CONFIG_DEBUG
- while (j != L[++k])
+ while (j != L[++k]) {if (k >= 16) assert(0);
+ }
#else
while (j != L[++k])
;
@@ -627,11 +631,13 @@
while (++mb_col < c->mb_cols) {const int ym = m->mbmi.mode;
- if (cpi->mb.e_mbd.update_mb_segmentation_map)
+ if (cpi->mb.e_mbd.update_mb_segmentation_map) {write_mb_features(bc, &m->mbmi, &cpi->mb.e_mbd);
+ }
- if (c->mb_no_coeff_skip)
+ if (c->mb_no_coeff_skip) {vp8_encode_bool(bc, m->mbmi.mb_skip_coeff, prob_skip_false);
+ }
kfwrite_ymode(bc, ym, vp8_kf_ymode_prob);
@@ -734,8 +740,9 @@
probs = (const unsigned int(*)[MAX_ENTROPY_TOKENS])x->coef_counts[i][j];
/* Reset to default probabilities at key frames */
- if (cpi->common.frame_type == KEY_FRAME)
+ if (cpi->common.frame_type == KEY_FRAME) {probs = default_coef_counts[i][j];
+ }
sum_probs_over_prev_coef_context(probs, prev_coef_count_sum);
@@ -758,8 +765,9 @@
const int s = prob_update_savings(ct, oldp, newp, upd);
if (cpi->common.frame_type != KEY_FRAME ||
- (cpi->common.frame_type == KEY_FRAME && newp != oldp))
+ (cpi->common.frame_type == KEY_FRAME && newp != oldp)) {prev_coef_savings[t] += s;
+ }
} while (++t < ENTROPY_NODES);
} while (++k < PREV_COEF_CONTEXTS);
k = 0;
@@ -769,8 +777,9 @@
* to get the equal probabilities across the prev coef
* contexts.
*/
- if (prev_coef_savings[k] > 0 || cpi->common.frame_type == KEY_FRAME)
+ if (prev_coef_savings[k] > 0 || cpi->common.frame_type == KEY_FRAME) {savings += prev_coef_savings[k];
+ }
} while (++k < ENTROPY_NODES);
} while (++j < COEF_BANDS);
} while (++i < BLOCK_TYPES);
@@ -873,10 +882,11 @@
savings += (oldtotal - newtotal) / 256;
}
- if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS)
+ if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) {savings += independent_coef_context_savings(cpi);
- else
+ } else {savings += default_coef_context_savings(cpi);
+ }
return savings;
}
@@ -961,8 +971,9 @@
*/
if ((cpi->oxcf.error_resilient_mode &
VPX_ERROR_RESILIENT_PARTITIONS) &&
- cpi->common.frame_type == KEY_FRAME && newp != *Pold)
+ cpi->common.frame_type == KEY_FRAME && newp != *Pold) {u = 1;
+ }
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
cpi->update_probs[i][j][k][t] = u;
@@ -1111,8 +1122,9 @@
vp8_write_bit(bc, 0);
vp8_write_bit(bc, pc->clamp_type);
- } else
+ } else {vp8_start_encode(bc, cx_data, cx_data_end);
+ }
/* Signal whether or not Segmentation is enabled */
vp8_write_bit(bc, xd->segmentation_enabled);
@@ -1270,10 +1282,11 @@
#if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS) {- if (pc->frame_type == KEY_FRAME)
+ if (pc->frame_type == KEY_FRAME) {pc->refresh_entropy_probs = 1;
- else
+ } else {pc->refresh_entropy_probs = 0;
+ }
}
#endif
@@ -1410,9 +1423,9 @@
vp8_start_encode(&cpi->bc[1], cx_data, cx_data_end);
#if CONFIG_MULTITHREAD
- if (cpi->b_multi_threaded)
+ if (cpi->b_multi_threaded) {pack_mb_row_tokens(cpi, &cpi->bc[1]);
- else
+ } else
#endif // CONFIG_MULTITHREAD
vp8_pack_tokens(&cpi->bc[1], cpi->tok, cpi->tok_count);
--- a/vp8/encoder/boolhuff.c
+++ b/vp8/encoder/boolhuff.c
@@ -61,6 +61,7 @@
void vp8_encode_value(BOOL_CODER *br, int data, int bits) {int bit;
- for (bit = bits - 1; bit >= 0; bit--)
+ for (bit = bits - 1; bit >= 0; bit--) {vp8_encode_bool(br, (1 & (data >> bit)), 0x80);
+ }
}
--- a/vp8/encoder/boolhuff.h
+++ b/vp8/encoder/boolhuff.h
@@ -47,11 +47,12 @@
static int validate_buffer(const unsigned char *start, size_t len,
const unsigned char *end,
struct vpx_internal_error_info *error) {- if (start + len > start && start + len < end)
+ if (start + len > start && start + len < end) {return 1;
- else
+ } else {vpx_internal_error(error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet or corrupt partition ");
+ }
return 0;
}
--- a/vp8/encoder/denoising.c
+++ b/vp8/encoder/denoising.c
@@ -96,25 +96,28 @@
running_avg_y[c] = mc_running_avg_y[c];
col_sum[c] += diff;
} else {- if (absdiff >= 4 + shift_inc1 && absdiff <= 7)
+ if (absdiff >= 4 + shift_inc1 && absdiff <= 7) {adjustment = adj_val[0];
- else if (absdiff >= 8 && absdiff <= 15)
+ } else if (absdiff >= 8 && absdiff <= 15) {adjustment = adj_val[1];
- else
+ } else {adjustment = adj_val[2];
+ }
if (diff > 0) {- if ((sig[c] + adjustment) > 255)
+ if ((sig[c] + adjustment) > 255) {running_avg_y[c] = 255;
- else
+ } else {running_avg_y[c] = sig[c] + adjustment;
+ }
col_sum[c] += adjustment;
} else {- if ((sig[c] - adjustment) < 0)
+ if ((sig[c] - adjustment) < 0) {running_avg_y[c] = 0;
- else
+ } else {running_avg_y[c] = sig[c] - adjustment;
+ }
col_sum[c] -= adjustment;
}
@@ -169,17 +172,19 @@
if (adjustment > delta) adjustment = delta;
if (diff > 0) {// Bring denoised signal down.
- if (running_avg_y[c] - adjustment < 0)
+ if (running_avg_y[c] - adjustment < 0) {running_avg_y[c] = 0;
- else
+ } else {running_avg_y[c] = running_avg_y[c] - adjustment;
+ }
col_sum[c] -= adjustment;
} else if (diff < 0) {// Bring denoised signal up.
- if (running_avg_y[c] + adjustment > 255)
+ if (running_avg_y[c] + adjustment > 255) {running_avg_y[c] = 255;
- else
+ } else {running_avg_y[c] = running_avg_y[c] + adjustment;
+ }
col_sum[c] += adjustment;
}
}
@@ -263,23 +268,26 @@
running_avg_uv[c] = mc_running_avg_uv[c];
sum_diff += diff;
} else {- if (absdiff >= 4 && absdiff <= 7)
+ if (absdiff >= 4 && absdiff <= 7) {adjustment = adj_val[0];
- else if (absdiff >= 8 && absdiff <= 15)
+ } else if (absdiff >= 8 && absdiff <= 15) {adjustment = adj_val[1];
- else
+ } else {adjustment = adj_val[2];
+ }
if (diff > 0) {- if ((sig[c] + adjustment) > 255)
+ if ((sig[c] + adjustment) > 255) {running_avg_uv[c] = 255;
- else
+ } else {running_avg_uv[c] = sig[c] + adjustment;
+ }
sum_diff += adjustment;
} else {- if ((sig[c] - adjustment) < 0)
+ if ((sig[c] - adjustment) < 0) {running_avg_uv[c] = 0;
- else
+ } else {running_avg_uv[c] = sig[c] - adjustment;
+ }
sum_diff -= adjustment;
}
}
@@ -315,17 +323,19 @@
if (adjustment > delta) adjustment = delta;
if (diff > 0) {// Bring denoised signal down.
- if (running_avg_uv[c] - adjustment < 0)
+ if (running_avg_uv[c] - adjustment < 0) {running_avg_uv[c] = 0;
- else
+ } else {running_avg_uv[c] = running_avg_uv[c] - adjustment;
+ }
sum_diff -= adjustment;
} else if (diff < 0) {// Bring denoised signal up.
- if (running_avg_uv[c] + adjustment > 255)
+ if (running_avg_uv[c] + adjustment > 255) {running_avg_uv[c] = 255;
- else
+ } else {running_avg_uv[c] = running_avg_uv[c] + adjustment;
+ }
sum_diff += adjustment;
}
}
@@ -508,8 +518,9 @@
// we will always choose zero_mv for denoising if
// zero_mv_see <= best_sse (i.e., sse_diff <= 0).
if ((unsigned int)(mv_row * mv_row + mv_col * mv_col) <=
- NOISE_MOTION_THRESHOLD)
+ NOISE_MOTION_THRESHOLD) {sse_diff_thresh = (int)SSE_DIFF_THRESHOLD;
+ }
if (frame == INTRA_FRAME || sse_diff <= sse_diff_thresh) {/*
@@ -539,15 +550,18 @@
denoiser->denoise_pars.scale_motion_thresh * NOISE_MOTION_THRESHOLD;
if (motion_magnitude2 <
- denoiser->denoise_pars.scale_increase_filter * NOISE_MOTION_THRESHOLD)
+ denoiser->denoise_pars.scale_increase_filter * NOISE_MOTION_THRESHOLD) {x->increase_denoising = 1;
+ }
sse_thresh = denoiser->denoise_pars.scale_sse_thresh * SSE_THRESHOLD;
- if (x->increase_denoising)
+ if (x->increase_denoising) {sse_thresh = denoiser->denoise_pars.scale_sse_thresh * SSE_THRESHOLD_HIGH;
+ }
- if (best_sse > sse_thresh || motion_magnitude2 > motion_threshold)
+ if (best_sse > sse_thresh || motion_magnitude2 > motion_threshold) {decision = COPY_BLOCK;
+ }
// If block is considered skin, don't denoise if the block
// (1) is selected as non-zero motion for current frame, or
@@ -555,8 +569,9 @@
// in a row.
// TODO(marpan): Parameter "x" should be varied with framerate.
// In particualar, should be reduced for layers (base layer/LAST).
- if (x->is_skin && (consec_zero_last < 2 || motion_magnitude2 > 0))
+ if (x->is_skin && (consec_zero_last < 2 || motion_magnitude2 > 0)) {decision = COPY_BLOCK;
+ }
if (decision == FILTER_BLOCK) {saved_pre = filter_xd->pre;
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -168,8 +168,9 @@
cpi->activity_avg = (unsigned int)(activity_sum / cpi->common.MBs);
#endif
- if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN)
+ if (cpi->activity_avg < VP8_ACTIVITY_AVG_MIN) {cpi->activity_avg = VP8_ACTIVITY_AVG_MIN;
+ }
/* Experimental code: return fixed value normalized for several clips */
if (ALT_ACT_MEASURE) cpi->activity_avg = 100000;
@@ -347,10 +348,11 @@
const int *last_row_current_mb_col;
int *current_mb_col = &cpi->mt_current_mb_col[mb_row];
- if ((cpi->b_multi_threaded != 0) && (mb_row != 0))
+ if ((cpi->b_multi_threaded != 0) && (mb_row != 0)) {last_row_current_mb_col = &cpi->mt_current_mb_col[mb_row - 1];
- else
+ } else {last_row_current_mb_col = &rightmost_col;
+ }
#endif
#if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
@@ -437,16 +439,18 @@
/* Code to set segment id in xd->mbmi.segment_id for current MB
* (with range checking)
*/
- if (cpi->segmentation_map[map_index + mb_col] <= 3)
+ if (cpi->segmentation_map[map_index + mb_col] <= 3) {xd->mode_info_context->mbmi.segment_id =
cpi->segmentation_map[map_index + mb_col];
- else
+ } else {xd->mode_info_context->mbmi.segment_id = 0;
+ }
vp8cx_mb_init_quantizer(cpi, x, 1);
- } else
+ } else {/* Set to Segment 0 by default */
xd->mode_info_context->mbmi.segment_id = 0;
+ }
x->active_ptr = cpi->active_map + map_index + mb_col;
@@ -479,16 +483,19 @@
if (xd->mode_info_context->mbmi.mode == ZEROMV &&
xd->mode_info_context->mbmi.ref_frame == LAST_FRAME) {// Increment, check for wrap-around.
- if (cpi->consec_zero_last[map_index + mb_col] < 255)
+ if (cpi->consec_zero_last[map_index + mb_col] < 255) {cpi->consec_zero_last[map_index + mb_col] += 1;
- if (cpi->consec_zero_last_mvbias[map_index + mb_col] < 255)
+ }
+ if (cpi->consec_zero_last_mvbias[map_index + mb_col] < 255) {cpi->consec_zero_last_mvbias[map_index + mb_col] += 1;
+ }
} else {cpi->consec_zero_last[map_index + mb_col] = 0;
cpi->consec_zero_last_mvbias[map_index + mb_col] = 0;
}
- if (x->zero_last_dot_suppress)
+ if (x->zero_last_dot_suppress) {cpi->consec_zero_last_mvbias[map_index + mb_col] = 0;
+ }
}
/* Special case code for cyclic refresh
@@ -509,14 +516,16 @@
* been refreshed then mark it as a candidate for cleanup
* next time (marked 0) else mark it as dirty (1).
*/
- if (xd->mode_info_context->mbmi.segment_id)
+ if (xd->mode_info_context->mbmi.segment_id) {cpi->cyclic_refresh_map[map_index + mb_col] = -1;
- else if ((xd->mode_info_context->mbmi.mode == ZEROMV) &&
- (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)) {- if (cpi->cyclic_refresh_map[map_index + mb_col] == 1)
+ } else if ((xd->mode_info_context->mbmi.mode == ZEROMV) &&
+ (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)) {+ if (cpi->cyclic_refresh_map[map_index + mb_col] == 1) {cpi->cyclic_refresh_map[map_index + mb_col] = 0;
- } else
+ }
+ } else {cpi->cyclic_refresh_map[map_index + mb_col] = 1;
+ }
}
}
@@ -557,8 +566,9 @@
xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
#if CONFIG_MULTITHREAD
- if (cpi->b_multi_threaded != 0)
+ if (cpi->b_multi_threaded != 0) {protected_write(&cpi->pmutex[mb_row], current_mb_col, rightmost_col);
+ }
#endif
/* this is to account for the border */
@@ -611,18 +621,19 @@
/* Special case treatment when GF and ARF are not sensible options
* for reference
*/
- if (cpi->ref_frame_flags == VP8_LAST_FRAME)
+ if (cpi->ref_frame_flags == VP8_LAST_FRAME) {vp8_calc_ref_frame_costs(x->ref_frame_cost, cpi->prob_intra_coded, 255,
128);
- else if ((cpi->oxcf.number_of_layers > 1) &&
- (cpi->ref_frame_flags == VP8_GOLD_FRAME))
+ } else if ((cpi->oxcf.number_of_layers > 1) &&
+ (cpi->ref_frame_flags == VP8_GOLD_FRAME)) {vp8_calc_ref_frame_costs(x->ref_frame_cost, cpi->prob_intra_coded, 1, 255);
- else if ((cpi->oxcf.number_of_layers > 1) &&
- (cpi->ref_frame_flags == VP8_ALTR_FRAME))
+ } else if ((cpi->oxcf.number_of_layers > 1) &&
+ (cpi->ref_frame_flags == VP8_ALTR_FRAME)) {vp8_calc_ref_frame_costs(x->ref_frame_cost, cpi->prob_intra_coded, 1, 1);
- else
+ } else {vp8_calc_ref_frame_costs(x->ref_frame_cost, cpi->prob_intra_coded,
cpi->prob_last_coded, cpi->prob_gf_coded);
+ }
xd->fullpixel_mask = 0xffffffff;
if (cm->full_pixel) xd->fullpixel_mask = 0xfffffff8;
@@ -673,10 +684,11 @@
totalrate = 0;
if (cpi->compressor_speed == 2) {- if (cpi->oxcf.cpu_used < 0)
+ if (cpi->oxcf.cpu_used < 0) {cpi->Speed = -(cpi->oxcf.cpu_used);
- else
+ } else {vp8_auto_select_speed(cpi);
+ }
}
/* Functions setup for all frame types so we can use MC in AltRef */
@@ -798,8 +810,9 @@
if (xd->segmentation_enabled) { for (i = 0; i < cpi->encoding_thread_count; ++i) {- for (j = 0; j < 4; ++j)
+ for (j = 0; j < 4; ++j) {segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
+ }
}
}
}
@@ -811,13 +824,15 @@
cpi->mb.skip_true_count += cpi->mb_row_ei[i].mb.skip_true_count;
- for (mode_count = 0; mode_count < VP8_YMODES; ++mode_count)
+ for (mode_count = 0; mode_count < VP8_YMODES; ++mode_count) {cpi->mb.ymode_count[mode_count] +=
cpi->mb_row_ei[i].mb.ymode_count[mode_count];
+ }
- for (mode_count = 0; mode_count < VP8_UV_MODES; ++mode_count)
+ for (mode_count = 0; mode_count < VP8_UV_MODES; ++mode_count) {cpi->mb.uv_mode_count[mode_count] +=
cpi->mb_row_ei[i].mb.uv_mode_count[mode_count];
+ }
for (c_idx = 0; c_idx < MVvals; ++c_idx) {cpi->mb.MVcount[0][c_idx] += cpi->mb_row_ei[i].mb.MVcount[0][c_idx];
@@ -827,12 +842,14 @@
cpi->mb.prediction_error += cpi->mb_row_ei[i].mb.prediction_error;
cpi->mb.intra_error += cpi->mb_row_ei[i].mb.intra_error;
- for (c_idx = 0; c_idx < MAX_REF_FRAMES; ++c_idx)
+ for (c_idx = 0; c_idx < MAX_REF_FRAMES; ++c_idx) {cpi->mb.count_mb_ref_frame_usage[c_idx] +=
cpi->mb_row_ei[i].mb.count_mb_ref_frame_usage[c_idx];
+ }
- for (c_idx = 0; c_idx < MAX_ERROR_BINS; ++c_idx)
+ for (c_idx = 0; c_idx < MAX_ERROR_BINS; ++c_idx) {cpi->mb.error_bins[c_idx] += cpi->mb_row_ei[i].mb.error_bins[c_idx];
+ }
/* add up counts for each thread */
sum_coef_counts(x, &cpi->mb_row_ei[i].mb);
@@ -899,8 +916,9 @@
tot_count = segment_counts[2] + segment_counts[3];
- if (tot_count > 0)
+ if (tot_count > 0) {xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) / tot_count;
+ }
/* Zero probabilities not allowed */
for (i = 0; i < MB_FEATURE_TREE_PROBS; ++i) {@@ -923,9 +941,10 @@
cpi->mb.count_mb_ref_frame_usage[GOLDEN_FRAME] +
cpi->mb.count_mb_ref_frame_usage[ALTREF_FRAME];
- if (tot_modes)
+ if (tot_modes) {cpi->this_frame_percent_intra =
cpi->mb.count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;
+ }
}
#if !CONFIG_REALTIME_ONLY
@@ -1054,10 +1073,11 @@
a = act + 4 * cpi->activity_avg;
b = 4 * act + cpi->activity_avg;
- if (act > cpi->activity_avg)
+ if (act > cpi->activity_avg) {x->act_zbin_adj = (int)(((int64_t)b + (a >> 1)) / a) - 1;
- else
+ } else {x->act_zbin_adj = 1 - (int)(((int64_t)a + (b >> 1)) / b);
+ }
#endif
}
@@ -1066,10 +1086,11 @@
MACROBLOCKD *xd = &x->e_mbd;
int rate;
- if (cpi->sf.RD && cpi->compressor_speed != 2)
+ if (cpi->sf.RD && cpi->compressor_speed != 2) {vp8_rd_pick_intra_mode(x, &rate);
- else
+ } else {vp8_pick_intra_mode(x, &rate);
+ }
if (cpi->oxcf.tuning == VP8_TUNE_SSIM) {adjust_act_zbin(cpi, x);
@@ -1076,10 +1097,11 @@
vp8_update_zbin_extra(cpi, x);
}
- if (x->e_mbd.mode_info_context->mbmi.mode == B_PRED)
+ if (x->e_mbd.mode_info_context->mbmi.mode == B_PRED) {vp8_encode_intra4x4mby(x);
- else
+ } else {vp8_encode_intra16x16mby(x);
+ }
vp8_encode_intra16x16mbuv(x);
@@ -1110,11 +1132,12 @@
x->skip = 0;
- if (xd->segmentation_enabled)
+ if (xd->segmentation_enabled) {x->encode_breakout =
cpi->segment_encode_breakout[xd->mode_info_context->mbmi.segment_id];
- else
+ } else {x->encode_breakout = cpi->oxcf.encode_breakout;
+ }
#if CONFIG_TEMPORAL_DENOISING
/* Reset the best sse mode/mv for each macroblock. */
@@ -1192,14 +1215,16 @@
if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME) { if (xd->mode_info_context->mbmi.mode == ZEROMV) {if (xd->mode_info_context->mbmi.ref_frame != LAST_FRAME &&
- cpi->oxcf.number_of_layers == 1)
+ cpi->oxcf.number_of_layers == 1) {x->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
- else
+ } else {x->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
- } else if (xd->mode_info_context->mbmi.mode == SPLITMV)
+ }
+ } else if (xd->mode_info_context->mbmi.mode == SPLITMV) {x->zbin_mode_boost = 0;
- else
+ } else {x->zbin_mode_boost = MV_ZBIN_BOOST;
+ }
}
}
@@ -1223,12 +1248,13 @@
} else {int ref_fb_idx;
- if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
+ if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME) {ref_fb_idx = cpi->common.lst_fb_idx;
- else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
+ } else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME) {ref_fb_idx = cpi->common.gld_fb_idx;
- else
+ } else {ref_fb_idx = cpi->common.alt_fb_idx;
+ }
xd->pre.y_buffer = cpi->common.yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
xd->pre.u_buffer =
@@ -1238,17 +1264,19 @@
if (!x->skip) {vp8_encode_inter16x16(x);
- } else
+ } else {vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer, xd->dst.u_buffer,
xd->dst.v_buffer, xd->dst.y_stride,
xd->dst.uv_stride);
+ }
}
if (!x->skip) {vp8_tokenize_mb(cpi, x, t);
- if (xd->mode_info_context->mbmi.mode != B_PRED)
+ if (xd->mode_info_context->mbmi.mode != B_PRED) {vp8_inverse_transform_mby(xd);
+ }
vp8_dequant_idct_add_uv_block(xd->qcoeff + 16 * 16, xd->dequant_uv,
xd->dst.u_buffer, xd->dst.v_buffer,
--- a/vp8/encoder/encodemb.c
+++ b/vp8/encoder/encodemb.c
@@ -101,8 +101,9 @@
}
/* do 2nd order transform on the dc block */
- if (x->e_mbd.mode_info_context->mbmi.mode != SPLITMV)
+ if (x->e_mbd.mode_info_context->mbmi.mode != SPLITMV) {x->short_walsh4x4(&x->block[24].src_diff[0], &x->block[24].coeff[0], 8);
+ }
}
static void transform_mby(MACROBLOCK *x) {@@ -184,8 +185,9 @@
/* Now set up a Viterbi trellis to evaluate alternative roundings. */
rdmult = mb->rdmult * err_mult;
- if (mb->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME)
+ if (mb->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) {rdmult = (rdmult * 9) >> 4;
+ }
rddiv = mb->rddiv;
best_mask[0] = best_mask[1] = 0;
@@ -242,10 +244,11 @@
rate1 = tokens[next][1].rate;
if ((abs(x) * dequant_ptr[rc] > abs(coeff_ptr[rc])) &&
- (abs(x) * dequant_ptr[rc] < abs(coeff_ptr[rc]) + dequant_ptr[rc]))
+ (abs(x) * dequant_ptr[rc] < abs(coeff_ptr[rc]) + dequant_ptr[rc])) {shortcut = 1;
- else
+ } else {shortcut = 0;
+ }
if (shortcut) {sz = -(x < 0);
--- a/vp8/encoder/encodemv.c
+++ b/vp8/encoder/encodemv.c
@@ -102,17 +102,17 @@
int i = 0;
cost = vp8_cost_one(p[mvpis_short]);
- do
+ do {cost += vp8_cost_bit(p[MVPbits + i], (x >> i) & 1);
- while (++i < 3);
+ } while (++i < 3);
i = mvlong_width - 1; /* Skip bit 3, which is sometimes implicit */
- do
+ do {cost += vp8_cost_bit(p[MVPbits + i], (x >> i) & 1);
- while (--i > 3);
+ } while (--i > 3);
if (x & 0xFFF0) cost += vp8_cost_bit(p[MVPbits + 3], (x >> 3) & 1);
}
@@ -242,10 +242,10 @@
is_short_ct[1] += c; /* Long vector */
/* bit 3 not always encoded. */
- do
+ do {bit_ct[k][(a >> k) & 1] += c;
- while (--k >= 0);
+ } while (--k >= 0);
}
} while (++j <= mv_max);
}
@@ -261,19 +261,19 @@
vp8_tree_probs_from_distribution(8, vp8_small_mvencodings, vp8_small_mvtree,
p, short_bct, short_ct, 256, 1);
- do
+ do {calc_prob(Pnew + MVPshort + j, short_bct[j]);
- while (++j < mvnum_short - 1);
+ } while (++j < mvnum_short - 1);
}
{int j = 0;
- do
+ do {calc_prob(Pnew + MVPbits + j, bit_ct[j]);
- while (++j < mvlong_width);
+ } while (++j < mvlong_width);
}
update(w, is_short_ct, Pcur + mvpis_short, Pnew[mvpis_short], *Pupdate++,
@@ -287,11 +287,10 @@
int j = 0;
- do
-
+ do {update(w, short_bct[j], cur_p + j, new_p[j], *Pupdate++, updated);
- while (++j < mvnum_short - 1);
+ } while (++j < mvnum_short - 1);
}
{@@ -300,11 +299,10 @@
int j = 0;
- do
-
+ do {update(w, bit_ct[j], cur_p + j, new_p[j], *Pupdate++, updated);
- while (++j < mvlong_width);
+ } while (++j < mvlong_width);
}
}
@@ -322,9 +320,10 @@
&vp8_mv_update_probs[1], cpi->mb.MVcount[1], 1,
&flags[1]);
- if (flags[0] || flags[1])
+ if (flags[0] || flags[1]) {vp8_build_component_cost_table(
cpi->mb.mvcost, (const MV_CONTEXT *)cpi->common.fc.mvc, flags);
+ }
#ifdef VP8_ENTROPY_STATS
active_section = 5;
--- a/vp8/encoder/ethreading.c
+++ b/vp8/encoder/ethreading.c
@@ -158,16 +158,18 @@
/* Code to set segment id in xd->mbmi.segment_id for
* current MB (with range checking)
*/
- if (cpi->segmentation_map[map_index + mb_col] <= 3)
+ if (cpi->segmentation_map[map_index + mb_col] <= 3) {xd->mode_info_context->mbmi.segment_id =
cpi->segmentation_map[map_index + mb_col];
- else
+ } else {xd->mode_info_context->mbmi.segment_id = 0;
+ }
vp8cx_mb_init_quantizer(cpi, x, 1);
- } else
+ } else {/* Set to Segment 0 by default */
xd->mode_info_context->mbmi.segment_id = 0;
+ }
x->active_ptr = cpi->active_map + map_index + mb_col;
@@ -199,16 +201,19 @@
if (xd->mode_info_context->mbmi.mode == ZEROMV &&
xd->mode_info_context->mbmi.ref_frame == LAST_FRAME) {// Increment, check for wrap-around.
- if (cpi->consec_zero_last[map_index + mb_col] < 255)
+ if (cpi->consec_zero_last[map_index + mb_col] < 255) {cpi->consec_zero_last[map_index + mb_col] += 1;
- if (cpi->consec_zero_last_mvbias[map_index + mb_col] < 255)
+ }
+ if (cpi->consec_zero_last_mvbias[map_index + mb_col] < 255) {cpi->consec_zero_last_mvbias[map_index + mb_col] += 1;
+ }
} else {cpi->consec_zero_last[map_index + mb_col] = 0;
cpi->consec_zero_last_mvbias[map_index + mb_col] = 0;
}
- if (x->zero_last_dot_suppress)
+ if (x->zero_last_dot_suppress) {cpi->consec_zero_last_mvbias[map_index + mb_col] = 0;
+ }
}
/* Special case code for cyclic refresh
@@ -232,14 +237,16 @@
* candidate for cleanup next time (marked 0) else
* mark it as dirty (1).
*/
- if (mbmi->segment_id)
+ if (mbmi->segment_id) {cpi->cyclic_refresh_map[map_index + mb_col] = -1;
- else if ((mbmi->mode == ZEROMV) &&
- (mbmi->ref_frame == LAST_FRAME)) {- if (cpi->cyclic_refresh_map[map_index + mb_col] == 1)
+ } else if ((mbmi->mode == ZEROMV) &&
+ (mbmi->ref_frame == LAST_FRAME)) {+ if (cpi->cyclic_refresh_map[map_index + mb_col] == 1) {cpi->cyclic_refresh_map[map_index + mb_col] = 0;
- } else
+ }
+ } else {cpi->cyclic_refresh_map[map_index + mb_col] = 1;
+ }
}
}
@@ -495,8 +502,9 @@
int rc = 0;
/* don't allocate more threads than cores available */
- if (cpi->oxcf.multi_threaded > cm->processor_core_count)
+ if (cpi->oxcf.multi_threaded > cm->processor_core_count) {th_count = cm->processor_core_count - 1;
+ }
/* we have th_count + 1 (main) threads processing one row each */
/* no point to have more threads than the sync range allows */
--- a/vp8/encoder/firstpass.c
+++ b/vp8/encoder/firstpass.c
@@ -237,10 +237,11 @@
double this_err = this_frame->ssim_weighted_pred_err;
double modified_err;
- if (this_err > av_err)
+ if (this_err > av_err) {modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1);
- else
+ } else {modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2);
+ }
return modified_err;
}
@@ -448,14 +449,15 @@
while (n < further_steps) {n++;
- if (num00)
+ if (num00) {num00--;
- else {+ } else {tmp_err = cpi->diamond_search_sad(x, b, d, &ref_mv_full, &tmp_mv,
step_param + n, x->sadperbit16, &num00,
&v_fn_ptr, x->mvcost, ref_mv);
- if (tmp_err < INT_MAX - new_mv_mode_penalty)
+ if (tmp_err < INT_MAX - new_mv_mode_penalty) {tmp_err += new_mv_mode_penalty;
+ }
if (tmp_err < *best_motion_err) {*best_motion_err = tmp_err;
@@ -606,8 +608,9 @@
d->bmi.mv.as_mv.row = 0;
d->bmi.mv.as_mv.col = 0;
- if (raw_motion_error < cpi->oxcf.encode_breakout)
+ if (raw_motion_error < cpi->oxcf.encode_breakout) {goto skip_motion_search;
+ }
/* Test last reference frame using the previous best mv as the
* starting point (best reference) for the search
@@ -688,28 +691,32 @@
/* Does the Row vector point inwards or outwards */
if (mb_row < cm->mb_rows / 2) {- if (d->bmi.mv.as_mv.row > 0)
+ if (d->bmi.mv.as_mv.row > 0) {sum_in_vectors--;
- else if (d->bmi.mv.as_mv.row < 0)
+ } else if (d->bmi.mv.as_mv.row < 0) {sum_in_vectors++;
+ }
} else if (mb_row > cm->mb_rows / 2) {- if (d->bmi.mv.as_mv.row > 0)
+ if (d->bmi.mv.as_mv.row > 0) {sum_in_vectors++;
- else if (d->bmi.mv.as_mv.row < 0)
+ } else if (d->bmi.mv.as_mv.row < 0) {sum_in_vectors--;
+ }
}
/* Does the Row vector point inwards or outwards */
if (mb_col < cm->mb_cols / 2) {- if (d->bmi.mv.as_mv.col > 0)
+ if (d->bmi.mv.as_mv.col > 0) {sum_in_vectors--;
- else if (d->bmi.mv.as_mv.col < 0)
+ } else if (d->bmi.mv.as_mv.col < 0) {sum_in_vectors++;
+ }
} else if (mb_col > cm->mb_cols / 2) {- if (d->bmi.mv.as_mv.col > 0)
+ if (d->bmi.mv.as_mv.col > 0) {sum_in_vectors++;
- else if (d->bmi.mv.as_mv.col < 0)
+ } else if (d->bmi.mv.as_mv.col < 0) {sum_in_vectors--;
+ }
}
}
}
@@ -824,10 +831,11 @@
FILE *recon_file;
sprintf(filename, "enc%04d.yuv", (int)cm->current_video_frame);
- if (cm->current_video_frame == 0)
+ if (cm->current_video_frame == 0) {recon_file = fopen(filename, "wb");
- else
+ } else {recon_file = fopen(filename, "ab");
+ }
(void)fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file);
fclose(recon_file);
@@ -843,10 +851,11 @@
*/
static double bitcost(double prob) {- if (prob > 0.000122)
+ if (prob > 0.000122) {return -log(prob) / log(2.0);
- else
+ } else {return 13.0;
+ }
}
static int64_t estimate_modemvcost(VP8_COMP *cpi, FIRSTPASS_STATS *fpstats) {int mv_cost;
@@ -917,8 +926,9 @@
double speed_correction = 1.0;
int overhead_bits_per_mb;
- if (section_target_bandwitdh <= 0)
+ if (section_target_bandwitdh <= 0) {return cpi->twopass.maxq_max_limit; /* Highest value allowed */
+ }
target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
? (512 * section_target_bandwitdh) / num_mbs
@@ -934,10 +944,11 @@
rolling_ratio =
(double)cpi->rolling_actual_bits / (double)cpi->rolling_target_bits;
- if (rolling_ratio < 0.95)
+ if (rolling_ratio < 0.95) {cpi->twopass.est_max_qcorrection_factor -= 0.005;
- else if (rolling_ratio > 1.05)
+ } else if (rolling_ratio > 1.05) {cpi->twopass.est_max_qcorrection_factor += 0.005;
+ }
cpi->twopass.est_max_qcorrection_factor =
(cpi->twopass.est_max_qcorrection_factor < 0.1)
@@ -951,10 +962,11 @@
* (reduced compression expected)
*/
if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {- if (cpi->oxcf.cpu_used <= 5)
+ if (cpi->oxcf.cpu_used <= 5) {speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
- else
+ } else {speed_correction = 1.25;
+ }
}
/* Estimate of overhead bits per mb */
@@ -1048,10 +1060,11 @@
* (reduced compression expected)
*/
if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {- if (cpi->oxcf.cpu_used <= 5)
+ if (cpi->oxcf.cpu_used <= 5) {speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
- else
+ } else {speed_correction = 1.25;
+ }
}
/* II ratio correction factor for clip as a whole */
@@ -1111,10 +1124,11 @@
* (reduced compression expected)
*/
if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {- if (cpi->oxcf.cpu_used <= 5)
+ if (cpi->oxcf.cpu_used <= 5) {speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
- else
+ } else {speed_correction = 1.25;
+ }
}
/* Try and pick a Q that can encode the content at the given rate. */
@@ -1164,9 +1178,9 @@
* vs target bits
* This is clamped to the range 0.1 to 10.0
*/
- if (cpi->long_rolling_target_bits <= 0)
+ if (cpi->long_rolling_target_bits <= 0) {current_spend_ratio = 10.0;
- else {+ } else {current_spend_ratio = (double)cpi->long_rolling_actual_bits /
(double)cpi->long_rolling_target_bits;
current_spend_ratio =
@@ -1188,10 +1202,11 @@
* (reduced compression expected)
*/
if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1)) {- if (cpi->oxcf.cpu_used <= 5)
+ if (cpi->oxcf.cpu_used <= 5) {speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
- else
+ } else {speed_correction = 1.25;
+ }
}
/* Combine the various factors calculated above */
@@ -1334,8 +1349,9 @@
/* High % motion -> somewhat higher decay rate */
motion_decay = (1.0 - (motion_pct / 20.0));
- if (motion_decay < prediction_decay_rate)
+ if (motion_decay < prediction_decay_rate) {prediction_decay_rate = motion_decay;
+ }
/* Adjustment to decay rate based on speed of motion */
{@@ -1350,8 +1366,9 @@
sqrt((this_mv_rabs * this_mv_rabs) + (this_mv_cabs * this_mv_cabs)) /
250.0;
distance_factor = ((distance_factor > 1.0) ? 0.0 : (1.0 - distance_factor));
- if (distance_factor < prediction_decay_rate)
+ if (distance_factor < prediction_decay_rate) {prediction_decay_rate = distance_factor;
+ }
}
return prediction_decay_rate;
@@ -1478,12 +1495,13 @@
double frame_boost;
/* Underlying boost factor is based on inter intra error ratio */
- if (this_frame->intra_error > cpi->twopass.gf_intra_err_min)
+ if (this_frame->intra_error > cpi->twopass.gf_intra_err_min) {frame_boost = (IIFACTOR * this_frame->intra_error /
DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
- else
+ } else {frame_boost = (IIFACTOR * cpi->twopass.gf_intra_err_min /
DOUBLE_DIVIDE_CHECK(this_frame->coded_error));
+ }
/* Increase boost for frames where new data coming into frame
* (eg zoom out). Slightly reduce boost if there is a net balance
@@ -1490,11 +1508,12 @@
* of motion out of the frame (zoom in).
* The range for this_frame_mv_in_out is -1.0 to +1.0
*/
- if (this_frame_mv_in_out > 0.0)
+ if (this_frame_mv_in_out > 0.0) {frame_boost += frame_boost * (this_frame_mv_in_out * 2.0);
- /* In extreme case boost is halved */
- else
+ /* In extreme case boost is halved */
+ } else {frame_boost += frame_boost * (this_frame_mv_in_out / 2.0);
+ }
/* Clip to maximum */
if (frame_boost > GF_RMAX) frame_boost = GF_RMAX;
@@ -1743,12 +1762,13 @@
int64_t df_buffer_level = cpi->oxcf.drop_frames_water_mark *
(cpi->oxcf.optimal_buffer_level / 100);
- if (cpi->buffer_level > df_buffer_level)
+ if (cpi->buffer_level > df_buffer_level) {max_boost =
((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) /
DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
- else
+ } else {max_boost = 0.0;
+ }
} else if (cpi->buffer_level > 0) {max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) /
DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
@@ -1815,8 +1835,9 @@
group_bits =
(int)((double)cpi->twopass.kf_group_bits *
(gf_group_err / (double)cpi->twopass.kf_group_error_left));
- } else
+ } else {group_bits = 0;
+ }
/* Boost for arf frame */
#if NEW_BOOST
@@ -1827,10 +1848,11 @@
Boost += (i * 50);
/* Set max and minimum boost and hence minimum allocation */
- if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
+ if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) {Boost = ((cpi->baseline_gf_interval + 1) * 200);
- else if (Boost < 125)
+ } else if (Boost < 125) {Boost = 125;
+ }
allocation_chunks = (i * 100) + Boost;
@@ -1916,8 +1938,9 @@
/* For even length filter there is one more frame backward
* than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
*/
- if (frames_bwd < half_gf_int)
+ if (frames_bwd < half_gf_int) {frames_bwd += (cpi->oxcf.arnr_max_frames + 1) & 0x1;
+ }
break;
}
@@ -1951,8 +1974,9 @@
cpi->twopass.gf_group_bits =
(int64_t)(cpi->twopass.kf_group_bits *
(gf_group_err / cpi->twopass.kf_group_error_left));
- } else
+ } else {cpi->twopass.gf_group_bits = 0;
+ }
cpi->twopass.gf_group_bits =
(cpi->twopass.gf_group_bits < 0)
@@ -1965,8 +1989,9 @@
* variability limit (cpi->oxcf.two_pass_vbrmax_section)
*/
if (cpi->twopass.gf_group_bits >
- (int64_t)max_bits * cpi->baseline_gf_interval)
+ (int64_t)max_bits * cpi->baseline_gf_interval) {cpi->twopass.gf_group_bits = (int64_t)max_bits * cpi->baseline_gf_interval;
+ }
/* Reset the file position */
reset_fpf_position(cpi, start_pos);
@@ -1994,10 +2019,11 @@
Boost += (cpi->baseline_gf_interval * 50);
/* Set max and minimum boost and hence minimum allocation */
- if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
+ if (Boost > ((cpi->baseline_gf_interval + 1) * 200)) {Boost = ((cpi->baseline_gf_interval + 1) * 200);
- else if (Boost < 125)
+ } else if (Boost < 125) {Boost = 125;
+ }
allocation_chunks = ((cpi->baseline_gf_interval + 1) * 100) + Boost;
}
@@ -2007,10 +2033,11 @@
Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
/* Set max and minimum boost and hence minimum allocation */
- if (Boost > (cpi->baseline_gf_interval * 150))
+ if (Boost > (cpi->baseline_gf_interval * 150)) {Boost = (cpi->baseline_gf_interval * 150);
- else if (Boost < 125)
+ } else if (Boost < 125) {Boost = 125;
+ }
allocation_chunks = (cpi->baseline_gf_interval * 100) + (Boost - 100);
}
@@ -2063,8 +2090,9 @@
/* Apply an additional limit for CBR */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {- if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1))
+ if (cpi->twopass.gf_bits > (int)(cpi->buffer_level >> 1)) {cpi->twopass.gf_bits = (int)(cpi->buffer_level >> 1);
+ }
}
/* Dont allow a negative value for gf_bits */
@@ -2095,11 +2123,12 @@
* frame of the group (except in Key frame case where this has
* already happened)
*/
- if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
+ if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME) {cpi->twopass.gf_group_error_left =
(int)(gf_group_err - gf_first_frame_err);
- else
+ } else {cpi->twopass.gf_group_error_left = (int)gf_group_err;
+ }
cpi->twopass.gf_group_bits -=
cpi->twopass.gf_bits - cpi->min_frame_bandwidth;
@@ -2126,10 +2155,12 @@
(int)(cpi->twopass.gf_group_bits * pct_extra) / 100;
cpi->twopass.gf_group_bits -= cpi->twopass.alt_extra_bits;
cpi->twopass.alt_extra_bits /= ((cpi->baseline_gf_interval - 1) >> 1);
- } else
+ } else {cpi->twopass.alt_extra_bits = 0;
- } else
+ }
+ } else {cpi->twopass.alt_extra_bits = 0;
+ }
}
/* Adjustments based on a measure of complexity of the section */
@@ -2155,8 +2186,9 @@
DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
- if (cpi->twopass.section_max_qfactor < 0.80)
+ if (cpi->twopass.section_max_qfactor < 0.80) {cpi->twopass.section_max_qfactor = 0.80;
+ }
reset_fpf_position(cpi, start_pos);
}
@@ -2176,10 +2208,11 @@
modified_err = calculate_modified_err(cpi, this_frame);
/* What portion of the remaining GF group error is used by this frame */
- if (cpi->twopass.gf_group_error_left > 0)
+ if (cpi->twopass.gf_group_error_left > 0) {err_fraction = modified_err / cpi->twopass.gf_group_error_left;
- else
+ } else {err_fraction = 0.0;
+ }
/* How many of those bits available for allocation should we give it? */
target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);
@@ -2187,13 +2220,14 @@
/* Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits)
* at the top end.
*/
- if (target_frame_size < 0)
+ if (target_frame_size < 0) {target_frame_size = 0;
- else {+ } else {if (target_frame_size > max_bits) target_frame_size = max_bits;
- if (target_frame_size > cpi->twopass.gf_group_bits)
+ if (target_frame_size > cpi->twopass.gf_group_bits) {target_frame_size = (int)cpi->twopass.gf_group_bits;
+ }
}
/* Adjust error and bits remaining */
@@ -2387,10 +2421,11 @@
overhead_bits);
/* Move active_worst_quality but in a damped way */
- if (tmp_q > cpi->active_worst_quality)
+ if (tmp_q > cpi->active_worst_quality) {cpi->active_worst_quality++;
- else if (tmp_q < cpi->active_worst_quality)
+ } else if (tmp_q < cpi->active_worst_quality) {cpi->active_worst_quality--;
+ }
cpi->active_worst_quality =
((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
@@ -2447,11 +2482,12 @@
if (next_iiratio > RMAX) next_iiratio = RMAX;
/* Cumulative effect of decay in prediction quality */
- if (local_next_frame.pcnt_inter > 0.85)
+ if (local_next_frame.pcnt_inter > 0.85) {decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
- else
+ } else {decay_accumulator =
decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
+ }
/* Keep a running total */
boost_score += (decay_accumulator * next_iiratio);
@@ -2475,9 +2511,9 @@
/* If there is tolerable prediction for at least the next 3 frames
* then break out else discard this pottential key frame and move on
*/
- if (boost_score > 5.0 && (i > 3))
+ if (boost_score > 5.0 && (i > 3)) {is_viable_kf = 1;
- else {+ } else {/* Reset the file position */
reset_fpf_position(cpi, start_pos);
@@ -2588,10 +2624,12 @@
/* If we don't have a real key frame within the next two
* forcekeyframeevery intervals then break out of the loop.
*/
- if (cpi->twopass.frames_to_key >= 2 * (int)cpi->key_frame_frequency)
+ if (cpi->twopass.frames_to_key >= 2 * (int)cpi->key_frame_frequency) {break;
- } else
+ }
+ } else {cpi->twopass.frames_to_key++;
+ }
i++;
}
@@ -2633,8 +2671,9 @@
reset_fpf_position(cpi, current_pos);
cpi->next_key_frame_forced = 1;
- } else
+ } else {cpi->next_key_frame_forced = 0;
+ }
/* Special case for the last frame of the file */
if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end) {@@ -2668,8 +2707,9 @@
/* Clip based on maximum per frame rate defined by the user. */
max_grp_bits = (int64_t)max_bits * (int64_t)cpi->twopass.frames_to_key;
- if (cpi->twopass.kf_group_bits > max_grp_bits)
+ if (cpi->twopass.kf_group_bits > max_grp_bits) {cpi->twopass.kf_group_bits = max_grp_bits;
+ }
/* Additional special case for CBR if buffer is getting full. */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {@@ -2696,8 +2736,9 @@
min_group_bits =
av_group_bits + (int64_t)(buffer_lvl - high_water_mark);
- if (cpi->twopass.kf_group_bits < min_group_bits)
+ if (cpi->twopass.kf_group_bits < min_group_bits) {cpi->twopass.kf_group_bits = min_group_bits;
+ }
}
/* We are above optimal but below the maximum */
else if (cpi->twopass.kf_group_bits < av_group_bits) {@@ -2709,8 +2750,9 @@
}
}
}
- } else
+ } else {cpi->twopass.kf_group_bits = 0;
+ }
/* Reset the first pass file position */
reset_fpf_position(cpi, start_position);
@@ -2726,12 +2768,13 @@
if (EOF == input_stats(cpi, &next_frame)) break;
- if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
+ if (next_frame.intra_error > cpi->twopass.kf_intra_err_min) {r = (IIKFACTOR2 * next_frame.intra_error /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
- else
+ } else {r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
+ }
if (r > RMAX) r = RMAX;
@@ -2772,8 +2815,9 @@
DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
- if (cpi->twopass.section_max_qfactor < 0.80)
+ if (cpi->twopass.section_max_qfactor < 0.80) {cpi->twopass.section_max_qfactor = 0.80;
+ }
}
/* When using CBR apply additional buffer fullness related upper limits */
@@ -2784,12 +2828,13 @@
int df_buffer_level = (int)(cpi->oxcf.drop_frames_water_mark *
(cpi->oxcf.optimal_buffer_level / 100));
- if (cpi->buffer_level > df_buffer_level)
+ if (cpi->buffer_level > df_buffer_level) {max_boost =
((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) /
DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
- else
+ } else {max_boost = 0.0;
+ }
} else if (cpi->buffer_level > 0) {max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) /
DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
@@ -2830,10 +2875,11 @@
/* bigger frame sizes need larger kf boosts, smaller frames smaller
* boosts...
*/
- if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
+ if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240)) {kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
- else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
+ } else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240)) {kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
+ }
/* Min KF boost */
kf_boost = (int)((double)kf_boost * 100.0) >> 4; /* Scale 16 to 100 */
@@ -2875,8 +2921,9 @@
/* Apply an additional limit for CBR */
if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) {- if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2))
+ if (cpi->twopass.kf_bits > (int)((3 * cpi->buffer_level) >> 2)) {cpi->twopass.kf_bits = (int)((3 * cpi->buffer_level) >> 2);
+ }
}
/* If the key frame is actually easier than the average for the
@@ -2951,8 +2998,9 @@
double effective_size_ratio;
if ((cpi->common.Width != cpi->oxcf.Width) ||
- (cpi->common.Height != cpi->oxcf.Height))
+ (cpi->common.Height != cpi->oxcf.Height)) {last_kf_resampled = 1;
+ }
/* Set back to unscaled by defaults */
cpi->common.horiz_scale = NORMAL;
@@ -2979,15 +3027,17 @@
/* Dont turn to resampling in easy sections just because they
* have been assigned a small number of bits
*/
- if (bits_per_frame < av_bits_per_frame)
+ if (bits_per_frame < av_bits_per_frame) {bits_per_frame = av_bits_per_frame;
+ }
}
/* bits_per_frame should comply with our minimum */
- if (bits_per_frame <
- (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
+ if (bits_per_frame < (cpi->oxcf.target_bandwidth *
+ cpi->oxcf.two_pass_vbrmin_section / 100)) {bits_per_frame = (cpi->oxcf.target_bandwidth *
cpi->oxcf.two_pass_vbrmin_section / 100);
+ }
/* Work out if spatial resampling is necessary */
kf_q = estimate_kf_group_q(cpi, err_per_frame, (int)bits_per_frame,
@@ -3032,10 +3082,11 @@
cpi->oxcf.optimal_buffer_level / 100)) ||
(last_kf_resampled &&
(projected_buffer_level < (cpi->oxcf.resample_up_water_mark *
- cpi->oxcf.optimal_buffer_level / 100))))
+ cpi->oxcf.optimal_buffer_level / 100)))) {resample_trigger = 1;
- else
+ } else {resample_trigger = 0;
+ }
} else {int64_t clip_bits = (int64_t)(
cpi->twopass.total_stats.count * cpi->oxcf.target_bandwidth /
@@ -3049,10 +3100,11 @@
* bits
*/
if ((last_kf_resampled && (kf_q > cpi->worst_quality)) ||
- ((kf_q > cpi->worst_quality) && (over_spend > clip_bits / 20)))
+ ((kf_q > cpi->worst_quality) && (over_spend > clip_bits / 20))) {resample_trigger = 1;
- else
+ } else {resample_trigger = 0;
+ }
}
if (resample_trigger) {--- a/vp8/encoder/lookahead.c
+++ b/vp8/encoder/lookahead.c
@@ -40,8 +40,9 @@
if (ctx->buf) {unsigned int i;
- for (i = 0; i < ctx->max_sz; ++i)
+ for (i = 0; i < ctx->max_sz; ++i) {vp8_yv12_de_alloc_frame_buffer(&ctx->buf[i].img);
+ }
free(ctx->buf);
}
free(ctx);
@@ -55,10 +56,11 @@
unsigned int i;
/* Clamp the lookahead queue depth */
- if (depth < 1)
+ if (depth < 1) {depth = 1;
- else if (depth > MAX_LAG_BUFFERS)
+ } else if (depth > MAX_LAG_BUFFERS) {depth = MAX_LAG_BUFFERS;
+ }
/* Keep last frame in lookahead buffer by increasing depth by 1.*/
depth += 1;
@@ -73,10 +75,12 @@
ctx->max_sz = depth;
ctx->buf = calloc(depth, sizeof(*ctx->buf));
if (!ctx->buf) goto bail;
- for (i = 0; i < depth; ++i)
+ for (i = 0; i < depth; ++i) {if (vp8_yv12_alloc_frame_buffer(&ctx->buf[i].img, width, height,
- VP8BORDERINPIXELS))
+ VP8BORDERINPIXELS)) {goto bail;
+ }
+ }
}
return ctx;
bail:
@@ -166,10 +170,11 @@
} else if (direction == PEEK_BACKWARD) {assert(index == 1);
- if (ctx->read_idx == 0)
+ if (ctx->read_idx == 0) {index = ctx->max_sz - 1;
- else
+ } else {index = ctx->read_idx - index;
+ }
buf = ctx->buf + index;
}
--- a/vp8/encoder/mcomp.c
+++ b/vp8/encoder/mcomp.c
@@ -43,12 +43,13 @@
static int mv_err_cost(int_mv *mv, int_mv *ref, int *mvcost[2],
int error_per_bit) {/* Ignore mv costing if mvcost is NULL */
- if (mvcost)
+ if (mvcost) {return ((mvcost[0][(mv->as_mv.row - ref->as_mv.row) >> 1] +
mvcost[1][(mv->as_mv.col - ref->as_mv.col) >> 1]) *
error_per_bit +
128) >>
8;
+ }
return 0;
}
@@ -56,12 +57,13 @@
int error_per_bit) {/* Calculate sad error cost on full pixel basis. */
/* Ignore mv costing if mvsadcost is NULL */
- if (mvsadcost)
+ if (mvsadcost) {return ((mvsadcost[0][(mv->as_mv.row - ref->as_mv.row)] +
mvsadcost[1][(mv->as_mv.col - ref->as_mv.col)]) *
error_per_bit +
128) >>
8;
+ }
return 0;
}
@@ -346,8 +348,9 @@
bestmv->as_mv.col = bc * 2;
if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL << 3)) ||
- (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3)))
+ (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL << 3))) {return INT_MAX;
+ }
return besterr;
}
@@ -910,9 +913,9 @@
}
}
- if (best_site == -1)
+ if (best_site == -1) {goto cal_neighbors;
- else {+ } else {br += hex[best_site].row;
bc += hex[best_site].col;
k = best_site;
@@ -943,16 +946,17 @@
}
}
- if (best_site == -1)
+ if (best_site == -1) {break;
- else {+ } else {br += next_chkpts[k][best_site].row;
bc += next_chkpts[k][best_site].col;
k += 5 + best_site;
- if (k >= 12)
+ if (k >= 12) {k -= 12;
- else if (k >= 6)
+ } else if (k >= 6) {k -= 6;
+ }
}
}
@@ -983,9 +987,9 @@
}
}
- if (best_site == -1)
+ if (best_site == -1) {break;
- else {+ } else {br += neighbors[best_site].row;
bc += neighbors[best_site].col;
}
@@ -1100,8 +1104,9 @@
best_mv->as_mv.col += ss[best_site].mv.col;
best_address += ss[best_site].offset;
last_site = best_site;
- } else if (best_address == in_what)
+ } else if (best_address == in_what) {(*num00)++;
+ }
}
this_mv.as_mv.row = best_mv->as_mv.row << 3;
@@ -1193,8 +1198,9 @@
for (j = 0; j < x->searches_per_step; j += 4) {const unsigned char *block_offset[4];
- for (t = 0; t < 4; ++t)
+ for (t = 0; t < 4; ++t) {block_offset[t] = ss[i + t].offset + best_address;
+ }
fn_ptr->sdx4df(what, what_stride, block_offset, in_what_stride,
sad_array);
@@ -1247,8 +1253,9 @@
best_mv->as_mv.col += ss[best_site].mv.col;
best_address += ss[best_site].offset;
last_site = best_site;
- } else if (best_address == in_what)
+ } else if (best_address == in_what) {(*num00)++;
+ }
}
this_mv.as_mv.row = best_mv->as_mv.row * 8;
@@ -1670,9 +1677,9 @@
}
}
- if (best_site == -1)
+ if (best_site == -1) {break;
- else {+ } else {ref_mv->as_mv.row += neighbors[best_site].row;
ref_mv->as_mv.col += neighbors[best_site].col;
best_address += (neighbors[best_site].row) * in_what_stride +
@@ -1780,9 +1787,9 @@
}
}
- if (best_site == -1)
+ if (best_site == -1) {break;
- else {+ } else {ref_mv->as_mv.row += neighbors[best_site].row;
ref_mv->as_mv.col += neighbors[best_site].col;
best_address += (neighbors[best_site].row) * in_what_stride +
--- a/vp8/encoder/onyx_if.c
+++ b/vp8/encoder/onyx_if.c
@@ -283,24 +283,27 @@
lc->starting_buffer_level =
rescale((int)(oxcf->starting_buffer_level), lc->target_bandwidth, 1000);
- if (oxcf->optimal_buffer_level == 0)
+ if (oxcf->optimal_buffer_level == 0) {lc->optimal_buffer_level = lc->target_bandwidth / 8;
- else
+ } else {lc->optimal_buffer_level =
rescale((int)(oxcf->optimal_buffer_level), lc->target_bandwidth, 1000);
+ }
- if (oxcf->maximum_buffer_size == 0)
+ if (oxcf->maximum_buffer_size == 0) {lc->maximum_buffer_size = lc->target_bandwidth / 8;
- else
+ } else {lc->maximum_buffer_size =
rescale((int)(oxcf->maximum_buffer_size), lc->target_bandwidth, 1000);
+ }
/* Work out the average size of a frame within this layer */
- if (layer > 0)
+ if (layer > 0) {lc->avg_frame_size_for_layer =
(int)((cpi->oxcf.target_bitrate[layer] -
cpi->oxcf.target_bitrate[layer - 1]) *
1000 / (lc->framerate - prev_layer_framerate));
+ }
lc->active_worst_quality = cpi->oxcf.worst_allowed_q;
lc->active_best_quality = cpi->oxcf.best_allowed_q;
@@ -553,8 +556,9 @@
if (cpi->cyclic_refresh_map[i] == 0) {seg_map[i] = 1;
block_count--;
- } else if (cpi->cyclic_refresh_map[i] < 0)
+ } else if (cpi->cyclic_refresh_map[i] < 0) {cpi->cyclic_refresh_map[i]++;
+ }
i++;
if (i == mbs_in_frame) i = 0;
@@ -625,10 +629,11 @@
cpi->mb.e_mbd.mode_lf_deltas[0] = 4; /* BPRED */
- if (cpi->oxcf.Mode == MODE_REALTIME)
+ if (cpi->oxcf.Mode == MODE_REALTIME) {cpi->mb.e_mbd.mode_lf_deltas[1] = -12; /* Zero */
- else
+ } else {cpi->mb.e_mbd.mode_lf_deltas[1] = -2; /* Zero */
+ }
cpi->mb.e_mbd.mode_lf_deltas[2] = 2; /* New mv */
cpi->mb.e_mbd.mode_lf_deltas[3] = 4; /* Split mv */
@@ -762,11 +767,11 @@
if (cpi->ref_frame_flags & VP8_ALTR_FRAME) ref_frames++;
/* Convert speed to continuous range, with clamping */
- if (Mode == 0)
+ if (Mode == 0) {Speed = 0;
- else if (Mode == 2)
+ } else if (Mode == 2) {Speed = RT(Speed);
- else {+ } else {if (Speed > 5) Speed = 5;
Speed = GOOD(Speed);
}
@@ -922,8 +927,9 @@
sum += cpi->mb.error_bins[i];
if (10 * sum >=
- (unsigned int)(cpi->Speed - 6) * (total_mbs - total_skip))
+ (unsigned int)(cpi->Speed - 6) * (total_mbs - total_skip)) {break;
+ }
}
i--;
@@ -1014,13 +1020,15 @@
cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
}
- if (cpi->sf.optimize_coefficients == 1 && cpi->pass != 1)
+ if (cpi->sf.optimize_coefficients == 1 && cpi->pass != 1) {cpi->mb.optimize = 1;
- else
+ } else {cpi->mb.optimize = 0;
+ }
- if (cpi->common.full_pixel)
+ if (cpi->common.full_pixel) {cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
+ }
#ifdef SPEEDSTATS
frames_at_speed[cpi->Speed]++;
@@ -1037,16 +1045,18 @@
cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
cpi->oxcf.lag_in_frames);
- if (!cpi->lookahead)
+ if (!cpi->lookahead) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate lag buffers");
+ }
#if VP8_TEMPORAL_ALT_REF
if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer, width, height,
- VP8BORDERINPIXELS))
+ VP8BORDERINPIXELS)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate altref buffer");
+ }
#endif
}
@@ -1080,13 +1090,15 @@
int prev_mb_rows = cm->mb_rows;
#endif
- if (vp8_alloc_frame_buffers(cm, width, height))
+ if (vp8_alloc_frame_buffers(cm, width, height)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate frame buffers");
+ }
- if (vp8_alloc_partition_data(cpi))
+ if (vp8_alloc_partition_data(cpi)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate partition data");
+ }
if ((width & 0xf) != 0) width += 16 - (width & 0xf);
@@ -1093,14 +1105,16 @@
if ((height & 0xf) != 0) height += 16 - (height & 0xf);
if (vp8_yv12_alloc_frame_buffer(&cpi->pick_lf_lvl_frame, width, height,
- VP8BORDERINPIXELS))
+ VP8BORDERINPIXELS)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate last frame buffer");
+ }
if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source, width, height,
- VP8BORDERINPIXELS))
+ VP8BORDERINPIXELS)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate scaled source buffer");
+ }
vpx_free(cpi->tok);
@@ -1153,14 +1167,15 @@
memset(cpi->active_map, 1, (cm->mb_rows * cm->mb_cols));
#if CONFIG_MULTITHREAD
- if (width < 640)
+ if (width < 640) {cpi->mt_sync_range = 1;
- else if (width <= 1280)
+ } else if (width <= 1280) {cpi->mt_sync_range = 4;
- else if (width <= 2560)
+ } else if (width <= 2560) {cpi->mt_sync_range = 8;
- else
+ } else {cpi->mt_sync_range = 16;
+ }
if (cpi->oxcf.multi_threaded > 1) {int i;
@@ -1196,9 +1211,10 @@
if (cpi->oxcf.noise_sensitivity > 0) {vp8_denoiser_free(&cpi->denoiser);
if (vp8_denoiser_allocate(&cpi->denoiser, width, height, cm->mb_rows,
- cm->mb_cols, cpi->oxcf.noise_sensitivity))
+ cm->mb_cols, cpi->oxcf.noise_sensitivity)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate denoiser");
+ }
}
#endif
}
@@ -1214,8 +1230,9 @@
int vp8_reverse_trans(int x) {int i;
- for (i = 0; i < 64; ++i)
+ for (i = 0; i < 64; ++i) {if (q_trans[i] >= x) return i;
+ }
return 63;
}
@@ -1240,15 +1257,19 @@
/* Special conditions when altr ref frame enabled in lagged compress mode */
if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames) {- if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
+ if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1) {cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
+ }
- if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
+ if (cpi->twopass.static_scene_max_gf_interval >
+ cpi->oxcf.lag_in_frames - 1) {cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
+ }
}
- if (cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval)
+ if (cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval) {cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
+ }
}
static void init_config(VP8_COMP *cpi, VP8_CONFIG *oxcf) {@@ -1347,23 +1368,26 @@
lc->starting_buffer_level = rescale(
(int)oxcf->starting_buffer_level_in_ms, lc->target_bandwidth, 1000);
- if (oxcf->optimal_buffer_level == 0)
+ if (oxcf->optimal_buffer_level == 0) {lc->optimal_buffer_level = lc->target_bandwidth / 8;
- else
+ } else {lc->optimal_buffer_level = rescale(
(int)oxcf->optimal_buffer_level_in_ms, lc->target_bandwidth, 1000);
+ }
- if (oxcf->maximum_buffer_size == 0)
+ if (oxcf->maximum_buffer_size == 0) {lc->maximum_buffer_size = lc->target_bandwidth / 8;
- else
+ } else {lc->maximum_buffer_size = rescale((int)oxcf->maximum_buffer_size_in_ms,
lc->target_bandwidth, 1000);
+ }
/* Work out the average size of a frame within this layer */
- if (i > 0)
+ if (i > 0) {lc->avg_frame_size_for_layer =
(int)((oxcf->target_bitrate[i] - oxcf->target_bitrate[i - 1]) *
1000 / (lc->framerate - prev_layer_framerate));
+ }
prev_layer_framerate = lc->framerate;
}
@@ -1448,25 +1472,29 @@
cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
if (oxcf->fixed_q >= 0) {- if (oxcf->worst_allowed_q < 0)
+ if (oxcf->worst_allowed_q < 0) {cpi->oxcf.fixed_q = q_trans[0];
- else
+ } else {cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
+ }
- if (oxcf->alt_q < 0)
+ if (oxcf->alt_q < 0) {cpi->oxcf.alt_q = q_trans[0];
- else
+ } else {cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
+ }
- if (oxcf->key_q < 0)
+ if (oxcf->key_q < 0) {cpi->oxcf.key_q = q_trans[0];
- else
+ } else {cpi->oxcf.key_q = q_trans[oxcf->key_q];
+ }
- if (oxcf->gold_q < 0)
+ if (oxcf->gold_q < 0) {cpi->oxcf.gold_q = q_trans[0];
- else
+ } else {cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
+ }
}
cpi->baseline_gf_interval =
@@ -1476,8 +1504,9 @@
cpi->oxcf.token_partitions = 3;
#endif
- if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
+ if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3) {cm->multi_token_partition = (TOKEN_PARTITION)cpi->oxcf.token_partitions;
+ }
setup_features(cpi);
@@ -1484,8 +1513,9 @@
{int i;
- for (i = 0; i < MAX_MB_SEGMENTS; ++i)
+ for (i = 0; i < MAX_MB_SEGMENTS; ++i) {cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
+ }
}
/* At the moment the first order values may not be > MAXQ */
@@ -1508,17 +1538,19 @@
(int)cpi->oxcf.starting_buffer_level, cpi->oxcf.target_bandwidth, 1000);
/* Set or reset optimal and maximum buffer levels. */
- if (cpi->oxcf.optimal_buffer_level == 0)
+ if (cpi->oxcf.optimal_buffer_level == 0) {cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
- else
+ } else {cpi->oxcf.optimal_buffer_level = rescale(
(int)cpi->oxcf.optimal_buffer_level, cpi->oxcf.target_bandwidth, 1000);
+ }
- if (cpi->oxcf.maximum_buffer_size == 0)
+ if (cpi->oxcf.maximum_buffer_size == 0) {cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
- else
+ } else {cpi->oxcf.maximum_buffer_size = rescale((int)cpi->oxcf.maximum_buffer_size,
cpi->oxcf.target_bandwidth, 1000);
+ }
// Under a configuration change, where maximum_buffer_size may change,
// keep buffer level clipped to the maximum allowed buffer size.
if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {@@ -1605,8 +1637,9 @@
cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
}
- if (last_w != cpi->oxcf.Width || last_h != cpi->oxcf.Height)
+ if (last_w != cpi->oxcf.Width || last_h != cpi->oxcf.Height) {cpi->force_next_frame_intra = 1;
+ }
if (((cm->Width + 15) & ~15) != cm->yv12_fb[cm->lst_fb_idx].y_width ||
((cm->Height + 15) & ~15) != cm->yv12_fb[cm->lst_fb_idx].y_height ||
@@ -1628,8 +1661,9 @@
cpi->oxcf.allow_lag = 0;
}
/* Limit on lag buffers as these are not currently dynamically allocated */
- else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
+ else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS) {cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
+ }
/* YX Temp */
cpi->alt_ref_source = NULL;
@@ -1641,9 +1675,10 @@
int width = (cpi->oxcf.Width + 15) & ~15;
int height = (cpi->oxcf.Height + 15) & ~15;
if (vp8_denoiser_allocate(&cpi->denoiser, width, height, cm->mb_rows,
- cm->mb_cols, cpi->oxcf.noise_sensitivity))
+ cm->mb_cols, cpi->oxcf.noise_sensitivity)) {vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
"Failed to allocate denoiser");
+ }
}
}
#endif
@@ -1782,8 +1817,9 @@
if (cpi->cyclic_refresh_mode_enabled) {CHECK_MEM_ERROR(cpi->cyclic_refresh_map,
vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
- } else
+ } else {cpi->cyclic_refresh_map = (signed char *)NULL;
+ }
CHECK_MEM_ERROR(cpi->consec_zero_last,
vpx_calloc(cm->mb_rows * cm->mb_cols, 1));
@@ -2347,9 +2383,10 @@
pkt.data.psnr.samples[0] += width * height;
pkt.data.psnr.samples[3] = width * height;
- for (i = 0; i < 4; ++i)
+ for (i = 0; i < 4; ++i) {pkt.data.psnr.psnr[i] = vpx_sse_to_psnr(pkt.data.psnr.samples[i], 255.0,
(double)(pkt.data.psnr.sse[i]));
+ }
vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
}
@@ -2381,14 +2418,15 @@
VP8_COMMON *cm = &cpi->common;
int ref_fb_idx;
- if (ref_frame_flag == VP8_LAST_FRAME)
+ if (ref_frame_flag == VP8_LAST_FRAME) {ref_fb_idx = cm->lst_fb_idx;
- else if (ref_frame_flag == VP8_GOLD_FRAME)
+ } else if (ref_frame_flag == VP8_GOLD_FRAME) {ref_fb_idx = cm->gld_fb_idx;
- else if (ref_frame_flag == VP8_ALTR_FRAME)
+ } else if (ref_frame_flag == VP8_ALTR_FRAME) {ref_fb_idx = cm->alt_fb_idx;
- else
+ } else {return -1;
+ }
vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd);
@@ -2400,14 +2438,15 @@
int ref_fb_idx;
- if (ref_frame_flag == VP8_LAST_FRAME)
+ if (ref_frame_flag == VP8_LAST_FRAME) {ref_fb_idx = cm->lst_fb_idx;
- else if (ref_frame_flag == VP8_GOLD_FRAME)
+ } else if (ref_frame_flag == VP8_GOLD_FRAME) {ref_fb_idx = cm->gld_fb_idx;
- else if (ref_frame_flag == VP8_ALTR_FRAME)
+ } else if (ref_frame_flag == VP8_ALTR_FRAME) {ref_fb_idx = cm->alt_fb_idx;
- else
+ } else {return -1;
+ }
vp8_yv12_copy_frame(sd, &cm->yv12_fb[ref_fb_idx]);
@@ -2458,10 +2497,11 @@
int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
int tmp_height;
- if (cm->vert_scale == 3)
+ if (cm->vert_scale == 3) {tmp_height = 9;
- else
+ } else {tmp_height = 11;
+ }
Scale2Ratio(cm->horiz_scale, &hr, &hs);
Scale2Ratio(cm->vert_scale, &vr, &vs);
@@ -2472,8 +2512,9 @@
vp8_yv12_extend_frame_borders(&cpi->scaled_source);
cpi->Source = &cpi->scaled_source;
#endif
- } else
+ } else {cpi->Source = sd;
+ }
}
static int resize_key_frame(VP8_COMP *cpi) {@@ -3179,8 +3220,9 @@
}
#if CONFIG_MULTITHREAD
- if (cpi->b_multi_threaded)
+ if (cpi->b_multi_threaded) {sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
+ }
#endif
// No need to apply loop-filter if the encoded frame does not update
@@ -3269,10 +3311,11 @@
}
/* Current default encoder behaviour for the altref sign bias */
- if (cpi->source_alt_ref_active)
+ if (cpi->source_alt_ref_active) {cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
- else
+ } else {cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
+ }
/* Check to see if a key frame is signaled
* For two pass with auto key frame enabled cm->frame_type may already
@@ -3432,14 +3475,15 @@
/* The reset to decimation 0 is only done here for one pass.
* Once it is set two pass leaves decimation on till the next kf.
*/
- if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
+ if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0)) {cpi->decimation_factor--;
+ }
- if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
+ if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0) {cpi->decimation_factor = 1;
- else if (cpi->buffer_level < drop_mark25 &&
- (cpi->decimation_factor == 2 || cpi->decimation_factor == 3)) {+ } else if (cpi->buffer_level < drop_mark25 &&
+ (cpi->decimation_factor == 2 || cpi->decimation_factor == 3)) {cpi->decimation_factor = 3;
} else if (cpi->buffer_level < drop_mark50 &&
(cpi->decimation_factor == 1 || cpi->decimation_factor == 2)) {@@ -3481,8 +3525,9 @@
cpi->decimation_count--;
cpi->bits_off_target += cpi->av_per_frame_bandwidth;
- if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
+ if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
+ }
#if CONFIG_MULTI_RES_ENCODING
vp8_store_drop_frame_info(cpi);
@@ -3508,17 +3553,20 @@
for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {LAYER_CONTEXT *lc = &cpi->layer_context[i];
lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate);
- if (lc->bits_off_target > lc->maximum_buffer_size)
+ if (lc->bits_off_target > lc->maximum_buffer_size) {lc->bits_off_target = lc->maximum_buffer_size;
+ }
lc->buffer_level = lc->bits_off_target;
}
}
return;
- } else
+ } else {cpi->decimation_count = cpi->decimation_factor;
- } else
+ }
+ } else {cpi->decimation_count = 0;
+ }
/* Decide how big to make the frame */
if (!vp8_pick_frame_size(cpi)) {@@ -3553,18 +3601,20 @@
cpi->oxcf.optimal_buffer_level) /
Adjustment);
- if (buff_lvl_step)
+ if (buff_lvl_step) {Adjustment =
(int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) /
buff_lvl_step);
- else
+ } else {Adjustment = 0;
+ }
}
cpi->active_worst_quality -= Adjustment;
- if (cpi->active_worst_quality < cpi->active_best_quality)
+ if (cpi->active_worst_quality < cpi->active_best_quality) {cpi->active_worst_quality = cpi->active_best_quality;
+ }
}
}
@@ -3578,10 +3628,11 @@
if (cm->frame_type == KEY_FRAME) { if (cpi->pass == 2) {- if (cpi->gfu_boost > 600)
+ if (cpi->gfu_boost > 600) {cpi->active_best_quality = kf_low_motion_minq[Q];
- else
+ } else {cpi->active_best_quality = kf_high_motion_minq[Q];
+ }
/* Special case for key frames forced because we have reached
* the maximum key frame interval. Here force the Q to a range
@@ -3588,15 +3639,17 @@
* based on the ambient Q to reduce the risk of popping
*/
if (cpi->this_key_frame_forced) {- if (cpi->active_best_quality > cpi->avg_frame_qindex * 7 / 8)
+ if (cpi->active_best_quality > cpi->avg_frame_qindex * 7 / 8) {cpi->active_best_quality = cpi->avg_frame_qindex * 7 / 8;
- else if (cpi->active_best_quality<cpi->avg_frame_qindex>> 2)
+ } else if (cpi->active_best_quality<cpi->avg_frame_qindex>> 2) {cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
+ }
}
}
/* One pass more conservative */
- else
+ else {cpi->active_best_quality = kf_high_motion_minq[Q];
+ }
}
else if (cpi->oxcf.number_of_layers == 1 &&
@@ -3617,12 +3670,13 @@
}
if (cpi->pass == 2) {- if (cpi->gfu_boost > 1000)
+ if (cpi->gfu_boost > 1000) {cpi->active_best_quality = gf_low_motion_minq[Q];
- else if (cpi->gfu_boost < 400)
+ } else if (cpi->gfu_boost < 400) {cpi->active_best_quality = gf_high_motion_minq[Q];
- else
+ } else {cpi->active_best_quality = gf_mid_motion_minq[Q];
+ }
/* Constrained quality use slightly lower active best. */
if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {@@ -3630,8 +3684,9 @@
}
}
/* One pass more conservative */
- else
+ else {cpi->active_best_quality = gf_high_motion_minq[Q];
+ }
} else {cpi->active_best_quality = inter_minq[Q];
@@ -3644,10 +3699,11 @@
* frames then use the user passed in cq value not the auto
* cq value.
*/
- if (cpi->rolling_actual_bits < cpi->min_frame_bandwidth)
+ if (cpi->rolling_actual_bits < cpi->min_frame_bandwidth) {cpi->active_best_quality = cpi->oxcf.cq_level;
- else
+ } else {cpi->active_best_quality = cpi->cq_target_quality;
+ }
}
}
@@ -3658,10 +3714,10 @@
/* Note that the use of >= here elliminates the risk of a devide
* by 0 error in the else if clause
*/
- if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
+ if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size) {cpi->active_best_quality = cpi->best_quality;
- else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level) {+ } else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level) {int Fraction =
(int)(((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) /
(cpi->oxcf.maximum_buffer_size -
@@ -3686,14 +3742,17 @@
}
/* Clip the active best and worst quality values to limits */
- if (cpi->active_worst_quality > cpi->worst_quality)
+ if (cpi->active_worst_quality > cpi->worst_quality) {cpi->active_worst_quality = cpi->worst_quality;
+ }
- if (cpi->active_best_quality < cpi->best_quality)
+ if (cpi->active_best_quality < cpi->best_quality) {cpi->active_best_quality = cpi->best_quality;
+ }
- if (cpi->active_worst_quality < cpi->active_best_quality)
+ if (cpi->active_worst_quality < cpi->active_best_quality) {cpi->active_worst_quality = cpi->active_best_quality;
+ }
/* Determine initial Q to try */
Q = vp8_regulate_q(cpi, cpi->this_frame_target);
@@ -3701,14 +3760,15 @@
#if !CONFIG_REALTIME_ONLY
/* Set highest allowed value for Zbin over quant */
- if (cm->frame_type == KEY_FRAME)
+ if (cm->frame_type == KEY_FRAME) {zbin_oq_high = 0;
- else if ((cpi->oxcf.number_of_layers == 1) &&
- ((cm->refresh_alt_ref_frame ||
- (cm->refresh_golden_frame && !cpi->source_alt_ref_active)))) {+ } else if ((cpi->oxcf.number_of_layers == 1) &&
+ ((cm->refresh_alt_ref_frame ||
+ (cm->refresh_golden_frame && !cpi->source_alt_ref_active)))) {zbin_oq_high = 16;
- } else
+ } else {zbin_oq_high = ZBIN_OQ_MAX;
+ }
#endif
/* Setup background Q adjustment for error resilient mode.
@@ -3718,10 +3778,11 @@
// Special case for screen_content_mode with golden frame updates.
int disable_cr_gf =
(cpi->oxcf.screen_content_mode == 2 && cm->refresh_golden_frame);
- if (cpi->current_layer == 0 && cpi->force_maxqp == 0 && !disable_cr_gf)
+ if (cpi->current_layer == 0 && cpi->force_maxqp == 0 && !disable_cr_gf) {cyclic_background_refresh(cpi, Q, 0);
- else
+ } else {disable_segmentation(cpi);
+ }
}
vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit,
@@ -3797,8 +3858,9 @@
if (cm->frame_type != KEY_FRAME) { if (cpi->common.refresh_alt_ref_frame) {- if (cpi->last_skip_false_probs[2] != 0)
+ if (cpi->last_skip_false_probs[2] != 0) {cpi->prob_skip_false = cpi->last_skip_false_probs[2];
+ }
/*
if(cpi->last_skip_false_probs[2]!=0 && abs(Q-
@@ -3809,8 +3871,9 @@
cpi->prob_skip_false ) / 2;
*/
} else if (cpi->common.refresh_golden_frame) {- if (cpi->last_skip_false_probs[1] != 0)
+ if (cpi->last_skip_false_probs[1] != 0) {cpi->prob_skip_false = cpi->last_skip_false_probs[1];
+ }
/*
if(cpi->last_skip_false_probs[1]!=0 && abs(Q-
@@ -3821,8 +3884,9 @@
cpi->prob_skip_false ) / 2;
*/
} else {- if (cpi->last_skip_false_probs[0] != 0)
+ if (cpi->last_skip_false_probs[0] != 0) {cpi->prob_skip_false = cpi->last_skip_false_probs[0];
+ }
/*
if(cpi->last_skip_false_probs[0]!=0 && abs(Q-
@@ -3841,8 +3905,9 @@
if (cpi->prob_skip_false > 250) cpi->prob_skip_false = 250;
- if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref)
+ if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref) {cpi->prob_skip_false = 1;
+ }
}
#if 0
@@ -3864,10 +3929,11 @@
*/
Q = vp8_regulate_q(cpi, cpi->this_frame_target);
if (cpi->cyclic_refresh_mode_enabled) {- if (cpi->current_layer == 0)
+ if (cpi->current_layer == 0) {cyclic_background_refresh(cpi, Q, 0);
- else
+ } else {disable_segmentation(cpi);
+ }
}
// Reset the zero_last counter to 0 on key frame.
memset(cpi->consec_zero_last, 0, cm->mb_rows * cm->mb_cols);
@@ -3987,8 +4053,9 @@
* vp8_update_rate_correction_factors() this loop.
*/
active_worst_qchanged = 1;
- } else
+ } else {active_worst_qchanged = 0;
+ }
#if !CONFIG_REALTIME_ONLY
/* Special case handling for forced key frames */
@@ -4014,10 +4081,11 @@
}
/* Clamp Q to upper and lower limits: */
- if (Q > q_high)
+ if (Q > q_high) {Q = q_high;
- else if (Q < q_low)
+ } else if (Q < q_low) {Q = q_low;
+ }
Loop = Q != last_q;
}
@@ -4041,17 +4109,19 @@
q_low = (Q < q_high) ? (Q + 1) : q_high;
/* If we are using over quant do the same for zbin_oq_low */
- if (cpi->mb.zbin_over_quant > 0)
+ if (cpi->mb.zbin_over_quant > 0) {zbin_oq_low = (cpi->mb.zbin_over_quant < zbin_oq_high)
? (cpi->mb.zbin_over_quant + 1)
: zbin_oq_high;
+ }
if (undershoot_seen) {/* Update rate_correction_factor unless
* cpi->active_worst_quality has changed.
*/
- if (!active_worst_qchanged)
+ if (!active_worst_qchanged) {vp8_update_rate_correction_factors(cpi, 1);
+ }
Q = (q_high + q_low + 1) / 2;
@@ -4058,9 +4128,9 @@
/* Adjust cpi->zbin_over_quant (only allowed when Q
* is max)
*/
- if (Q < MAXQ)
+ if (Q < MAXQ) {cpi->mb.zbin_over_quant = 0;
- else {+ } else {zbin_oq_low = (cpi->mb.zbin_over_quant < zbin_oq_high)
? (cpi->mb.zbin_over_quant + 1)
: zbin_oq_high;
@@ -4070,8 +4140,9 @@
/* Update rate_correction_factor unless
* cpi->active_worst_quality has changed.
*/
- if (!active_worst_qchanged)
+ if (!active_worst_qchanged) {vp8_update_rate_correction_factors(cpi, 0);
+ }
Q = vp8_regulate_q(cpi, cpi->this_frame_target);
@@ -4087,21 +4158,23 @@
}
/* Frame is too small */
else {- if (cpi->mb.zbin_over_quant == 0)
+ if (cpi->mb.zbin_over_quant == 0) {/* Lower q_high if not using over quant */
q_high = (Q > q_low) ? (Q - 1) : q_low;
- else
+ } else {/* else lower zbin_oq_high */
zbin_oq_high = (cpi->mb.zbin_over_quant > zbin_oq_low)
? (cpi->mb.zbin_over_quant - 1)
: zbin_oq_low;
+ }
if (overshoot_seen) {/* Update rate_correction_factor unless
* cpi->active_worst_quality has changed.
*/
- if (!active_worst_qchanged)
+ if (!active_worst_qchanged) {vp8_update_rate_correction_factors(cpi, 1);
+ }
Q = (q_high + q_low) / 2;
@@ -4108,16 +4181,18 @@
/* Adjust cpi->zbin_over_quant (only allowed when Q
* is max)
*/
- if (Q < MAXQ)
+ if (Q < MAXQ) {cpi->mb.zbin_over_quant = 0;
- else
+ } else {cpi->mb.zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
+ }
} else {/* Update rate_correction_factor unless
* cpi->active_worst_quality has changed.
*/
- if (!active_worst_qchanged)
+ if (!active_worst_qchanged) {vp8_update_rate_correction_factors(cpi, 0);
+ }
Q = vp8_regulate_q(cpi, cpi->this_frame_target);
@@ -4143,10 +4218,11 @@
}
/* Clamp Q to upper and lower limits: */
- if (Q > q_high)
+ if (Q > q_high) {Q = q_high;
- else if (Q < q_low)
+ } else if (Q < q_low) {Q = q_low;
+ }
/* Clamp cpi->zbin_over_quant */
cpi->mb.zbin_over_quant = (cpi->mb.zbin_over_quant < zbin_oq_low)
@@ -4209,9 +4285,10 @@
if (cm->frame_type != KEY_FRAME) { for (mb_row = 0; mb_row < cm->mb_rows + 1; ++mb_row) { for (mb_col = 0; mb_col < cm->mb_cols + 1; ++mb_col) {- if (tmp->mbmi.ref_frame != INTRA_FRAME)
+ if (tmp->mbmi.ref_frame != INTRA_FRAME) {cpi->lfmv[mb_col + mb_row * (cm->mode_info_stride + 1)].as_int =
tmp->mbmi.mv.as_int;
+ }
cpi->lf_ref_frame_sign_bias[mb_col +
mb_row * (cm->mode_info_stride + 1)] =
@@ -4236,8 +4313,9 @@
if (cm->frame_type != KEY_FRAME) { for (mb_row = 0; mb_row < cm->mb_rows; ++mb_row) { for (mb_col = 0; mb_col < cm->mb_cols; ++mb_col) {- if (tmp->mbmi.mode == ZEROMV && tmp->mbmi.ref_frame == LAST_FRAME)
+ if (tmp->mbmi.mode == ZEROMV && tmp->mbmi.ref_frame == LAST_FRAME) {cpi->zeromv_count++;
+ }
tmp++;
}
tmp++;
@@ -4253,8 +4331,9 @@
* This is done after completing the compression of a frame when all
* modes etc. are finalized but before loop filter
*/
- if (cpi->oxcf.number_of_layers == 1)
+ if (cpi->oxcf.number_of_layers == 1) {vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
+ }
if (cm->frame_type == KEY_FRAME) cm->refresh_last_frame = 1;
@@ -4270,10 +4349,11 @@
* cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
* This is purely an encoder decision at present.
*/
- if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
+ if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame) {cm->copy_buffer_to_arf = 2;
- else
+ } else {cm->copy_buffer_to_arf = 0;
+ }
cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
@@ -4357,8 +4437,9 @@
if (cpi->oxcf.number_of_layers > 1) {unsigned int i;
- for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i)
+ for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {cpi->layer_context[i].total_byte_count += (*size);
+ }
}
if (!active_worst_qchanged) vp8_update_rate_correction_factors(cpi, 2);
@@ -4370,9 +4451,10 @@
}
/* Keep a record of ambient average Q. */
- if (cm->frame_type != KEY_FRAME)
+ if (cm->frame_type != KEY_FRAME) {cpi->avg_frame_qindex =
(2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
+ }
/* Keep a record from which we can calculate the average Q excluding
* GF updates and key frames
@@ -4417,22 +4499,25 @@
/* Update the buffer level variable. */
/* Non-viewable frames are a special case and are treated as pure overhead. */
- if (!cm->show_frame)
+ if (!cm->show_frame) {cpi->bits_off_target -= cpi->projected_frame_size;
- else
+ } else {cpi->bits_off_target +=
cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
+ }
/* Clip the buffer level to the maximum specified buffer size */
- if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
+ if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
+ }
// If the frame dropper is not enabled, don't let the buffer level go below
// some threshold, given here by -|maximum_buffer_size|. For now we only do
// this for screen content input.
if (cpi->drop_frames_allowed == 0 && cpi->oxcf.screen_content_mode &&
- cpi->bits_off_target < -cpi->oxcf.maximum_buffer_size)
+ cpi->bits_off_target < -cpi->oxcf.maximum_buffer_size) {cpi->bits_off_target = -cpi->oxcf.maximum_buffer_size;
+ }
/* Rolling monitors of whether we are over or underspending used to
* help regulate min and Max Q in two pass.
@@ -4468,8 +4553,9 @@
lc->bits_off_target += bits_off_for_this_layer;
/* Clip buffer level to maximum buffer size for the layer */
- if (lc->bits_off_target > lc->maximum_buffer_size)
+ if (lc->bits_off_target > lc->maximum_buffer_size) {lc->bits_off_target = lc->maximum_buffer_size;
+ }
lc->total_actual_bits += cpi->projected_frame_size;
lc->total_target_vs_actual += bits_off_for_this_layer;
@@ -4573,33 +4659,39 @@
#endif
- if (cm->refresh_golden_frame == 1)
+ if (cm->refresh_golden_frame == 1) {cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
- else
+ } else {cm->frame_flags = cm->frame_flags & ~FRAMEFLAGS_GOLDEN;
+ }
- if (cm->refresh_alt_ref_frame == 1)
+ if (cm->refresh_alt_ref_frame == 1) {cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
- else
+ } else {cm->frame_flags = cm->frame_flags & ~FRAMEFLAGS_ALTREF;
+ }
- if (cm->refresh_last_frame & cm->refresh_golden_frame) /* both refreshed */
+ if (cm->refresh_last_frame & cm->refresh_golden_frame) { /* both refreshed */cpi->gold_is_last = 1;
- else if (cm->refresh_last_frame ^ cm->refresh_golden_frame)
+ } else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) {/* 1 refreshed but not the other */
cpi->gold_is_last = 0;
+ }
- if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) /* both refreshed */
+ if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) { /* both refreshed */cpi->alt_is_last = 1;
- else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame)
+ } else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) {/* 1 refreshed but not the other */
cpi->alt_is_last = 0;
+ }
- if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) /* both refreshed */
+ if (cm->refresh_alt_ref_frame &
+ cm->refresh_golden_frame) { /* both refreshed */cpi->gold_is_alt = 1;
- else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame)
+ } else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) {/* 1 refreshed but not the other */
cpi->gold_is_alt = 0;
+ }
cpi->ref_frame_flags = VP8_ALTR_FRAME | VP8_GOLD_FRAME | VP8_LAST_FRAME;
@@ -4611,12 +4703,13 @@
if (!cpi->oxcf.error_resilient_mode) {if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame &&
- (cm->frame_type != KEY_FRAME))
+ (cm->frame_type != KEY_FRAME)) {/* Update the alternate reference frame stats as appropriate. */
update_alt_ref_frame_stats(cpi);
- else
+ } else {/* Update the Golden frame stats as appropriate. */
update_golden_frame_stats(cpi);
+ }
}
if (cm->frame_type == KEY_FRAME) {@@ -4699,8 +4792,9 @@
}
if (vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, frame_flags,
- cpi->active_map_enabled ? cpi->active_map : NULL))
+ cpi->active_map_enabled ? cpi->active_map : NULL)) {res = -1;
+ }
vpx_usec_timer_mark(&timer);
cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
@@ -4771,8 +4865,9 @@
/* Read last frame source if we are encoding first pass. */
if (cpi->pass == 1 && cm->current_video_frame > 0) {if ((cpi->last_source =
- vp8_lookahead_peek(cpi->lookahead, 1, PEEK_BACKWARD)) == NULL)
+ vp8_lookahead_peek(cpi->lookahead, 1, PEEK_BACKWARD)) == NULL) {return -1;
+ }
}
if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush))) {@@ -4828,14 +4923,15 @@
this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
last_duration = cpi->last_end_time_stamp_seen - cpi->last_time_stamp_seen;
/* do a step update if the duration changes by 10% */
- if (last_duration)
+ if (last_duration) {step = (int)(((this_duration - last_duration) * 10 / last_duration));
+ }
}
if (this_duration) {- if (step)
+ if (step) {cpi->ref_framerate = 10000000.0 / this_duration;
- else {+ } else {double avg_duration, interval;
/* Average this frame's rate into the last second's average
@@ -4880,8 +4976,9 @@
LAYER_CONTEXT *lc = &cpi->layer_context[i];
lc->framerate = cpi->ref_framerate / cpi->oxcf.rate_decimator[i];
}
- } else
+ } else {vp8_new_framerate(cpi, cpi->ref_framerate);
+ }
}
cpi->last_time_stamp_seen = cpi->source->ts_start;
@@ -4988,19 +5085,21 @@
duration2 = (unsigned int)((double)duration / 2);
if (cm->frame_type != KEY_FRAME) {- if (cpi->avg_encode_time == 0)
+ if (cpi->avg_encode_time == 0) {cpi->avg_encode_time = duration;
- else
+ } else {cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
+ }
}
if (duration2) { {- if (cpi->avg_pick_mode_time == 0)
+ if (cpi->avg_pick_mode_time == 0) {cpi->avg_pick_mode_time = duration2;
- else
+ } else {cpi->avg_pick_mode_time =
(7 * cpi->avg_pick_mode_time + duration2) >> 3;
+ }
}
}
}
@@ -5169,9 +5268,9 @@
int vp8_get_preview_raw_frame(VP8_COMP *cpi, YV12_BUFFER_CONFIG *dest,
vp8_ppflags_t *flags) {- if (cpi->common.refresh_alt_ref_frame)
+ if (cpi->common.refresh_alt_ref_frame) {return -1;
- else {+ } else {int ret;
#if CONFIG_POSTPROC
@@ -5208,19 +5307,22 @@
if (cpi->cyclic_refresh_mode_enabled) return -1;
// Check number of rows and columns match
- if (cpi->common.mb_rows != (int)rows || cpi->common.mb_cols != (int)cols)
+ if (cpi->common.mb_rows != (int)rows || cpi->common.mb_cols != (int)cols) {return -1;
+ }
// Range check the delta Q values and convert the external Q range values
// to internal ones.
if ((abs(delta_q[0]) > range) || (abs(delta_q[1]) > range) ||
- (abs(delta_q[2]) > range) || (abs(delta_q[3]) > range))
+ (abs(delta_q[2]) > range) || (abs(delta_q[3]) > range)) {return -1;
+ }
// Range check the delta lf values
if ((abs(delta_lf[0]) > range) || (abs(delta_lf[1]) > range) ||
- (abs(delta_lf[2]) > range) || (abs(delta_lf[3]) > range))
+ (abs(delta_lf[2]) > range) || (abs(delta_lf[3]) > range)) {return -1;
+ }
if (!map) {disable_segmentation(cpi);
@@ -5228,9 +5330,10 @@
}
// Translate the external delta q values to internal values.
- for (i = 0; i < MAX_MB_SEGMENTS; ++i)
+ for (i = 0; i < MAX_MB_SEGMENTS; ++i) {internal_delta_q[i] =
(delta_q[i] >= 0) ? q_trans[delta_q[i]] : -q_trans[-delta_q[i]];
+ }
/* Set the segmentation Map */
set_segmentation_map(cpi, map);
@@ -5267,8 +5370,9 @@
if (map) {memcpy(cpi->active_map, map, rows * cols);
cpi->active_map_enabled = 1;
- } else
+ } else {cpi->active_map_enabled = 0;
+ }
return 0;
} else {@@ -5278,15 +5382,17 @@
int vp8_set_internal_size(VP8_COMP *cpi, VPX_SCALING horiz_mode,
VPX_SCALING vert_mode) {- if (horiz_mode <= ONETWO)
+ if (horiz_mode <= ONETWO) {cpi->common.horiz_scale = horiz_mode;
- else
+ } else {return -1;
+ }
- if (vert_mode <= ONETWO)
+ if (vert_mode <= ONETWO) {cpi->common.vert_scale = vert_mode;
- else
+ } else {return -1;
+ }
return 0;
}
--- a/vp8/encoder/pickinter.c
+++ b/vp8/encoder/pickinter.c
@@ -92,13 +92,14 @@
for (; i < 5; ++i) {int skin_color_diff = evaluate_skin_color_difference(cb, cr, i);
if (skin_color_diff < skin_threshold[i + 1]) {- if (y < 60 && skin_color_diff > 3 * (skin_threshold[i + 1] >> 2))
+ if (y < 60 && skin_color_diff > 3 * (skin_threshold[i + 1] >> 2)) {return 0;
- else if (consec_zeromv > 25 &&
- skin_color_diff > (skin_threshold[i + 1] >> 1))
+ } else if (consec_zeromv > 25 &&
+ skin_color_diff > (skin_threshold[i + 1] >> 1)) {return 0;
- else
+ } else {return 1;
+ }
}
// Exit if difference is much large than the threshold.
if (skin_color_diff > (skin_threshold[i + 1] << 3)) {@@ -523,10 +524,11 @@
sse2 = VP8_UVSSE(x);
- if (sse2 * 2 < x->encode_breakout)
+ if (sse2 * 2 < x->encode_breakout) {x->skip = 1;
- else
+ } else {x->skip = 0;
+ }
}
}
@@ -546,9 +548,10 @@
}
if ((this_mode != NEWMV) || !(cpi->sf.half_pixel_search) ||
- cpi->common.full_pixel == 1)
+ cpi->common.full_pixel == 1) {*distortion2 =
vp8_get_inter_mbpred_error(x, &cpi->fn_ptr[BLOCK_16X16], sse, mv);
+ }
this_rd = RDCOST(x->rdmult, x->rddiv, rate2, *distortion2);
@@ -585,32 +588,39 @@
mic -= 1;
mv_l = mic->mbmi.mv;
- if (mic->mbmi.ref_frame != INTRA_FRAME)
- if (abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8)
+ if (mic->mbmi.ref_frame != INTRA_FRAME) {+ if (abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8) {local_motion_check++;
+ }
+ }
/* above-left mb */
mic -= x->e_mbd.mode_info_stride;
mv_al = mic->mbmi.mv;
- if (mic->mbmi.ref_frame != INTRA_FRAME)
- if (abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8)
+ if (mic->mbmi.ref_frame != INTRA_FRAME) {+ if (abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8) {local_motion_check++;
+ }
+ }
/* above mb */
mic += 1;
mv_a = mic->mbmi.mv;
- if (mic->mbmi.ref_frame != INTRA_FRAME)
- if (abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8)
+ if (mic->mbmi.ref_frame != INTRA_FRAME) {+ if (abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8) {local_motion_check++;
+ }
+ }
if (((!x->e_mbd.mb_to_top_edge || !x->e_mbd.mb_to_left_edge) &&
local_motion_check > 0) ||
- local_motion_check > 2)
+ local_motion_check > 2) {*rd_adjustment = 80;
- else if (local_motion_check > 0)
+ } else if (local_motion_check > 0) {*rd_adjustment = 90;
+ }
}
}
@@ -892,8 +902,9 @@
* likely to be chosen */
x->rd_thresh_mult[mode_index] += 4;
- if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
+ if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
+ }
x->rd_threshes[mode_index] =
(cpi->rd_baseline_thresh[mode_index] >> 7) *
@@ -924,8 +935,9 @@
* an unfiltered alternative */
if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {if (this_mode != ZEROMV ||
- x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
+ x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) {continue;
+ }
}
switch (this_mode) {@@ -1105,9 +1117,9 @@
while (n < further_steps) {n++;
- if (num00)
+ if (num00) {num00--;
- else {+ } else {thissme = cpi->diamond_search_sad(
x, b, d, &mvp_full, &d->bmi.mv, step_param + n, sadpb,
&num00, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
@@ -1126,10 +1138,11 @@
x->mv_row_min = tmp_row_min;
x->mv_row_max = tmp_row_max;
- if (bestsme < INT_MAX)
+ if (bestsme < INT_MAX) {cpi->find_fractional_mv_step(
x, b, d, &d->bmi.mv, &best_ref_mv, x->errorperbit,
&cpi->fn_ptr[BLOCK_16X16], cpi->mb.mvcost, &distortion2, &sse);
+ }
}
mode_mv[NEWMV].as_int = d->bmi.mv.as_int;
@@ -1156,8 +1169,9 @@
if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
- ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
+ ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) {continue;
+ }
rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
x->e_mbd.mode_info_context->mbmi.mv.as_int = mode_mv[this_mode].as_int;
@@ -1226,8 +1240,9 @@
else {x->rd_thresh_mult[mode_index] += 4;
- if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
+ if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
+ }
x->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) *
x->rd_thresh_mult[mode_index];
@@ -1281,8 +1296,9 @@
// labeling on there being significant denoising in the scene
if (cpi->oxcf.noise_sensitivity == 4) {if (cpi->denoiser.nmse_source_diff >
- 70 * cpi->denoiser.threshold_aggressive_mode / 100)
+ 70 * cpi->denoiser.threshold_aggressive_mode / 100) {is_noisy = 1;
+ }
} else {if (cpi->mse_source_denoised > 1000) is_noisy = 1;
}
@@ -1353,9 +1369,10 @@
/* set to the best mb mode, this copy can be skip if x->skip since it
* already has the right content */
- if (!x->skip)
+ if (!x->skip) {memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode,
sizeof(MB_MODE_INFO));
+ }
if (best_mbmode.mode <= B_PRED) {/* set mode_info_context->mbmi.uv_mode */
@@ -1363,8 +1380,9 @@
}
if (sign_bias !=
- cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame])
+ cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) {best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
+ }
update_mvcount(x, &best_ref_mv);
}
--- a/vp8/encoder/picklpf.c
+++ b/vp8/encoder/picklpf.c
@@ -95,15 +95,16 @@
int min_filter_level;
if (cpi->source_alt_ref_active && cpi->common.refresh_golden_frame &&
- !cpi->common.refresh_alt_ref_frame)
+ !cpi->common.refresh_alt_ref_frame) {min_filter_level = 0;
- else {- if (base_qindex <= 6)
+ } else {+ if (base_qindex <= 6) {min_filter_level = 0;
- else if (base_qindex <= 16)
+ } else if (base_qindex <= 16) {min_filter_level = 1;
- else
+ } else {min_filter_level = (base_qindex / 8);
+ }
}
return min_filter_level;
@@ -119,8 +120,9 @@
int max_filter_level = MAX_LOOP_FILTER;
(void)base_qindex;
- if (cpi->twopass.section_intra_rating > 8)
+ if (cpi->twopass.section_intra_rating > 8) {max_filter_level = MAX_LOOP_FILTER * 3 / 4;
+ }
return max_filter_level;
}
@@ -139,10 +141,11 @@
/* Replace unfiltered frame buffer with a new one */
cm->frame_to_show = &cpi->pick_lf_lvl_frame;
- if (cm->frame_type == KEY_FRAME)
+ if (cm->frame_type == KEY_FRAME) {cm->sharpness_level = 0;
- else
+ } else {cm->sharpness_level = cpi->oxcf.Sharpness;
+ }
if (cm->sharpness_level != cm->last_sharpness_level) {vp8_loop_filter_update_sharpness(&cm->lf_info, cm->sharpness_level);
@@ -152,10 +155,11 @@
/* Start the search at the previous frame filter level unless it is
* now out of range.
*/
- if (cm->filter_level < min_filter_level)
+ if (cm->filter_level < min_filter_level) {cm->filter_level = min_filter_level;
- else if (cm->filter_level > max_filter_level)
+ } else if (cm->filter_level > max_filter_level) {cm->filter_level = max_filter_level;
+ }
filt_val = cm->filter_level;
best_filt_val = filt_val;
@@ -183,8 +187,9 @@
if (filt_err < best_err) {best_err = filt_err;
best_filt_val = filt_val;
- } else
+ } else {break;
+ }
/* Adjust filter level */
filt_val -= 1 + (filt_val > 10);
@@ -214,8 +219,9 @@
best_err = filt_err - (filt_err >> 10);
best_filt_val = filt_val;
- } else
+ } else {break;
+ }
/* Adjust filter level */
filt_val += 1 + (filt_val > 10);
@@ -274,10 +280,11 @@
/* Replace unfiltered frame buffer with a new one */
cm->frame_to_show = &cpi->pick_lf_lvl_frame;
- if (cm->frame_type == KEY_FRAME)
+ if (cm->frame_type == KEY_FRAME) {cm->sharpness_level = 0;
- else
+ } else {cm->sharpness_level = cpi->oxcf.Sharpness;
+ }
/* Start the search at the previous frame filter level unless it is
* now out of range.
@@ -284,10 +291,11 @@
*/
filt_mid = cm->filter_level;
- if (filt_mid < min_filter_level)
+ if (filt_mid < min_filter_level) {filt_mid = min_filter_level;
- else if (filt_mid > max_filter_level)
+ } else if (filt_mid > max_filter_level) {filt_mid = max_filter_level;
+ }
/* Define the initial step size */
filter_step = (filt_mid < 16) ? 4 : filt_mid / 4;
@@ -309,8 +317,9 @@
while (filter_step > 0) {Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;
- if (cpi->twopass.section_intra_rating < 20)
+ if (cpi->twopass.section_intra_rating < 20) {Bias = Bias * cpi->twopass.section_intra_rating / 20;
+ }
filt_high = ((filt_mid + filter_step) > max_filter_level)
? max_filter_level
@@ -328,8 +337,9 @@
filt_err = vp8_calc_ss_err(sd, cm->frame_to_show);
ss_err[filt_low] = filt_err;
- } else
+ } else {filt_err = ss_err[filt_low];
+ }
/* If value is close to the best so far then bias towards a
* lower loop filter value.
@@ -351,8 +361,9 @@
filt_err = vp8_calc_ss_err(sd, cm->frame_to_show);
ss_err[filt_high] = filt_err;
- } else
+ } else {filt_err = ss_err[filt_high];
+ }
/* Was it better than the previous best? */
if (filt_err < (best_err - Bias)) {--- a/vp8/encoder/ratectrl.c
+++ b/vp8/encoder/ratectrl.c
@@ -263,10 +263,11 @@
cpi->common.filter_level = cpi->common.base_qindex * 3 / 8;
/* Provisional interval before next GF */
- if (cpi->auto_gold)
+ if (cpi->auto_gold) {cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
- else
+ } else {cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL;
+ }
cpi->common.refresh_golden_frame = 1;
cpi->common.refresh_alt_ref_frame = 1;
@@ -280,10 +281,11 @@
* chosen such that the maximum product of Bpm and MBs fits 31 bits. The
* largest Bpm takes 20 bits.
*/
- if (MBs > (1 << 11))
+ if (MBs > (1 << 11)) {return (Bpm >> BPER_MB_NORMBITS) * MBs;
- else
+ } else {return (Bpm * MBs) >> BPER_MB_NORMBITS;
+ }
}
static void calc_iframe_target_size(VP8_COMP *cpi) {@@ -311,8 +313,9 @@
*/
target = cpi->oxcf.starting_buffer_level / 2;
- if (target > cpi->oxcf.target_bandwidth * 3 / 2)
+ if (target > cpi->oxcf.target_bandwidth * 3 / 2) {target = cpi->oxcf.target_bandwidth * 3 / 2;
+ }
} else {/* if this keyframe was forced, use a more recent Q estimate */
int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY) ? cpi->avg_frame_qindex
@@ -331,9 +334,10 @@
kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100;
/* frame separation adjustment ( down) */
- if (cpi->frames_since_key < cpi->output_framerate / 2)
+ if (cpi->frames_since_key < cpi->output_framerate / 2) {kf_boost =
(int)(kf_boost * cpi->frames_since_key / (cpi->output_framerate / 2));
+ }
/* Minimal target size is |2* per_frame_bandwidth|. */
if (kf_boost < 16) kf_boost = 16;
@@ -385,10 +389,11 @@
int pct_gf_active = (100 * cpi->gf_active_count) /
(cpi->common.mb_rows * cpi->common.mb_cols);
- if (tot_mbs)
+ if (tot_mbs) {gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
100 / tot_mbs;
+ }
if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
@@ -474,12 +479,13 @@
}
/* Apply an upper limit based on Q for 1 pass encodes */
- if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0))
+ if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0)) {Boost = kf_gf_boost_qlimits[Q];
- /* Apply lower limits to boost. */
- else if (Boost < 110)
+ /* Apply lower limits to boost. */
+ } else if (Boost < 110) {Boost = 110;
+ }
/* Note the boost used */
cpi->last_boost = Boost;
@@ -504,14 +510,17 @@
if (cpi->last_boost >= 1500) cpi->frames_till_gf_update_due++;
- if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due)
+ if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due) {cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage];
+ }
- if (cpi->frames_till_gf_update_due > cpi->max_gf_interval)
+ if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) {cpi->frames_till_gf_update_due = cpi->max_gf_interval;
+ }
}
- } else
+ } else {cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
+ }
/* ARF on or off */
if (cpi->pass != 2) {@@ -533,9 +542,10 @@
int min_frame_target;
int old_per_frame_bandwidth = cpi->per_frame_bandwidth;
- if (cpi->current_layer > 0)
+ if (cpi->current_layer > 0) {cpi->per_frame_bandwidth =
cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer;
+ }
min_frame_target = 0;
@@ -542,10 +552,12 @@
if (cpi->pass == 2) {min_frame_target = cpi->min_frame_bandwidth;
- if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5))
+ if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) {min_frame_target = cpi->av_per_frame_bandwidth >> 5;
- } else if (min_frame_target < cpi->per_frame_bandwidth / 4)
+ }
+ } else if (min_frame_target < cpi->per_frame_bandwidth / 4) {min_frame_target = cpi->per_frame_bandwidth / 4;
+ }
/* Special alt reference frame case */
if ((cpi->common.refresh_alt_ref_frame) &&
@@ -577,8 +589,9 @@
? cpi->kf_bitrate_adjustment
: cpi->kf_overspend_bits;
- if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target))
+ if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) {Adjustment = (cpi->per_frame_bandwidth - min_frame_target);
+ }
cpi->kf_overspend_bits -= Adjustment;
@@ -588,10 +601,12 @@
*/
cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment;
- if (cpi->this_frame_target < min_frame_target)
+ if (cpi->this_frame_target < min_frame_target) {cpi->this_frame_target = min_frame_target;
- } else
+ }
+ } else {cpi->this_frame_target = cpi->per_frame_bandwidth;
+ }
/* If appropriate make an adjustment to recover bits spent on a
* recent GF
@@ -602,8 +617,9 @@
? cpi->non_gf_bitrate_adjustment
: cpi->gf_overspend_bits;
- if (Adjustment > (cpi->this_frame_target - min_frame_target))
+ if (Adjustment > (cpi->this_frame_target - min_frame_target)) {Adjustment = (cpi->this_frame_target - min_frame_target);
+ }
cpi->gf_overspend_bits -= Adjustment;
cpi->this_frame_target -= Adjustment;
@@ -615,25 +631,29 @@
/* % Adjustment limited to the range 1% to 10% */
Adjustment = (cpi->last_boost - 100) >> 5;
- if (Adjustment < 1)
+ if (Adjustment < 1) {Adjustment = 1;
- else if (Adjustment > 10)
+ } else if (Adjustment > 10) {Adjustment = 10;
+ }
/* Convert to bits */
Adjustment = (cpi->this_frame_target * Adjustment) / 100;
- if (Adjustment > (cpi->this_frame_target - min_frame_target))
+ if (Adjustment > (cpi->this_frame_target - min_frame_target)) {Adjustment = (cpi->this_frame_target - min_frame_target);
+ }
if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) {Adjustment = (cpi->current_gf_interval - 1) * Adjustment;
// Limit adjustment to 10% of current target.
- if (Adjustment > (10 * cpi->this_frame_target) / 100)
+ if (Adjustment > (10 * cpi->this_frame_target) / 100) {Adjustment = (10 * cpi->this_frame_target) / 100;
+ }
cpi->this_frame_target += Adjustment;
- } else
+ } else {cpi->this_frame_target -= Adjustment;
+ }
}
}
}
@@ -646,12 +666,14 @@
* be recovered over a longer time span via other buffer / rate control
* mechanisms.
*/
- if (cpi->this_frame_target < min_frame_target)
+ if (cpi->this_frame_target < min_frame_target) {cpi->this_frame_target = min_frame_target;
+ }
- if (!cpi->common.refresh_alt_ref_frame)
+ if (!cpi->common.refresh_alt_ref_frame) {/* Note the baseline target data rate for this inter frame. */
cpi->inter_frame_target = cpi->this_frame_target;
+ }
/* One Pass specific code */
if (cpi->pass == 0) {@@ -683,10 +705,11 @@
(int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8));
}
- if (percent_low > cpi->oxcf.under_shoot_pct)
+ if (percent_low > cpi->oxcf.under_shoot_pct) {percent_low = cpi->oxcf.under_shoot_pct;
- else if (percent_low < 0)
+ } else if (percent_low < 0) {percent_low = 0;
+ }
/* lower the target bandwidth for this frame. */
cpi->this_frame_target -= (cpi->this_frame_target * percent_low) / 200;
@@ -763,10 +786,11 @@
(int)((100 * cpi->bits_off_target) / (cpi->total_byte_count * 8));
}
- if (percent_high > cpi->oxcf.over_shoot_pct)
+ if (percent_high > cpi->oxcf.over_shoot_pct) {percent_high = cpi->oxcf.over_shoot_pct;
- else if (percent_high < 0)
+ } else if (percent_high < 0) {percent_high = 0;
+ }
cpi->this_frame_target += (cpi->this_frame_target * percent_high) / 200;
@@ -787,8 +811,9 @@
cpi->active_best_quality = cpi->best_quality;
/* Worst quality obviously must not be better than best quality */
- if (cpi->active_worst_quality <= cpi->active_best_quality)
+ if (cpi->active_worst_quality <= cpi->active_best_quality) {cpi->active_worst_quality = cpi->active_best_quality + 1;
+ }
if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127;
}
@@ -833,8 +858,9 @@
/* Update the buffer level variable. */
cpi->bits_off_target += cpi->av_per_frame_bandwidth;
- if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
+ if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) {cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size;
+ }
cpi->buffer_level = cpi->bits_off_target;
if (cpi->oxcf.number_of_layers > 1) {@@ -844,8 +870,9 @@
for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) {LAYER_CONTEXT *lc = &cpi->layer_context[i];
lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate);
- if (lc->bits_off_target > lc->maximum_buffer_size)
+ if (lc->bits_off_target > lc->maximum_buffer_size) {lc->bits_off_target = lc->maximum_buffer_size;
+ }
lc->buffer_level = lc->bits_off_target;
}
}
@@ -867,10 +894,11 @@
int pct_gf_active = (100 * cpi->gf_active_count) /
(cpi->common.mb_rows * cpi->common.mb_cols);
- if (tot_mbs)
+ if (tot_mbs) {gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] +
cpi->recent_ref_frame_usage[ALTREF_FRAME]) *
100 / tot_mbs;
+ }
if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active;
@@ -880,12 +908,13 @@
* low or the GF useage is high
*/
if ((cpi->pass == 0) &&
- (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5))
+ (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5)) {cpi->common.refresh_golden_frame = 1;
- /* Two pass GF descision */
- else if (cpi->pass == 2)
+ /* Two pass GF descision */
+ } else if (cpi->pass == 2) {cpi->common.refresh_golden_frame = 1;
+ }
}
#if 0
@@ -947,18 +976,20 @@
}
/* Avoid loss of precision but avoid overflow */
- if ((bits_in_section >> 7) > allocation_chunks)
+ if ((bits_in_section >> 7) > allocation_chunks) {cpi->this_frame_target =
Boost * (bits_in_section / allocation_chunks);
- else
+ } else {cpi->this_frame_target =
(Boost * bits_in_section) / allocation_chunks;
+ }
}
- } else
+ } else {cpi->this_frame_target =
(estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) *
cpi->last_boost) /
100;
+ }
}
/* If there is an active ARF at this location use the minimum
@@ -991,11 +1022,12 @@
if (cpi->common.frame_type == KEY_FRAME) {rate_correction_factor = cpi->key_frame_rate_correction_factor;
} else {- if (cpi->oxcf.number_of_layers == 1 &&
- (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame))
+ if (cpi->oxcf.number_of_layers == 1 && (cpi->common.refresh_alt_ref_frame ||
+ cpi->common.refresh_golden_frame)) {rate_correction_factor = cpi->gf_rate_correction_factor;
- else
+ } else {rate_correction_factor = cpi->rate_correction_factor;
+ }
}
/* Work out how big we would have expected the frame to be at this Q
@@ -1025,9 +1057,10 @@
}
/* Work out a size correction factor. */
- if (projected_size_based_on_q > 0)
+ if (projected_size_based_on_q > 0) {correction_factor =
(100 * cpi->projected_frame_size) / projected_size_based_on_q;
+ }
/* More heavily damped adjustment used if we have been oscillating
* either side of target
@@ -1047,8 +1080,9 @@
((rate_correction_factor * correction_factor) / 100);
/* Keep rate_correction_factor within limits */
- if (rate_correction_factor > MAX_BPB_FACTOR)
+ if (rate_correction_factor > MAX_BPB_FACTOR) {rate_correction_factor = MAX_BPB_FACTOR;
+ }
} else if (correction_factor < 99) {/* We are not already at the best allowable quality */
correction_factor =
@@ -1057,18 +1091,20 @@
((rate_correction_factor * correction_factor) / 100);
/* Keep rate_correction_factor within limits */
- if (rate_correction_factor < MIN_BPB_FACTOR)
+ if (rate_correction_factor < MIN_BPB_FACTOR) {rate_correction_factor = MIN_BPB_FACTOR;
+ }
}
- if (cpi->common.frame_type == KEY_FRAME)
+ if (cpi->common.frame_type == KEY_FRAME) {cpi->key_frame_rate_correction_factor = rate_correction_factor;
- else {- if (cpi->oxcf.number_of_layers == 1 &&
- (cpi->common.refresh_alt_ref_frame || cpi->common.refresh_golden_frame))
+ } else {+ if (cpi->oxcf.number_of_layers == 1 && (cpi->common.refresh_alt_ref_frame ||
+ cpi->common.refresh_golden_frame)) {cpi->gf_rate_correction_factor = rate_correction_factor;
- else
+ } else {cpi->rate_correction_factor = rate_correction_factor;
+ }
}
}
@@ -1103,27 +1139,29 @@
double correction_factor;
/* Select the appropriate correction factor based upon type of frame. */
- if (cpi->common.frame_type == KEY_FRAME)
+ if (cpi->common.frame_type == KEY_FRAME) {correction_factor = cpi->key_frame_rate_correction_factor;
- else {+ } else {if (cpi->oxcf.number_of_layers == 1 &&
(cpi->common.refresh_alt_ref_frame ||
- cpi->common.refresh_golden_frame))
+ cpi->common.refresh_golden_frame)) {correction_factor = cpi->gf_rate_correction_factor;
- else
+ } else {correction_factor = cpi->rate_correction_factor;
+ }
}
/* Calculate required scaling factor based on target frame size and
* size of frame produced using previous Q
*/
- if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS))
+ if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) {/* Case where we would overflow int */
target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs)
<< BPER_MB_NORMBITS;
- else
+ } else {target_bits_per_mb =
(target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
+ }
i = cpi->active_best_quality;
@@ -1133,14 +1171,16 @@
correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]);
if (bits_per_mb_at_this_q <= target_bits_per_mb) {- if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error)
+ if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) {Q = i;
- else
+ } else {Q = i - 1;
+ }
break;
- } else
+ } else {last_error = bits_per_mb_at_this_q - target_bits_per_mb;
+ }
} while (++i <= cpi->active_worst_quality);
/* If we are at MAXQ then enable Q over-run which seeks to claw
@@ -1153,15 +1193,16 @@
double Factor = 0.99;
double factor_adjustment = 0.01 / 256.0;
- if (cpi->common.frame_type == KEY_FRAME)
+ if (cpi->common.frame_type == KEY_FRAME) {zbin_oqmax = 0;
- else if (cpi->oxcf.number_of_layers == 1 &&
- (cpi->common.refresh_alt_ref_frame ||
- (cpi->common.refresh_golden_frame &&
- !cpi->source_alt_ref_active)))
+ } else if (cpi->oxcf.number_of_layers == 1 &&
+ (cpi->common.refresh_alt_ref_frame ||
+ (cpi->common.refresh_golden_frame &&
+ !cpi->source_alt_ref_active))) {zbin_oqmax = 16;
- else
+ } else {zbin_oqmax = ZBIN_OQ_MAX;
+ }
/*{double Factor =
@@ -1188,8 +1229,9 @@
while (cpi->mb.zbin_over_quant < zbin_oqmax) {cpi->mb.zbin_over_quant++;
- if (cpi->mb.zbin_over_quant > zbin_oqmax)
+ if (cpi->mb.zbin_over_quant > zbin_oqmax) {cpi->mb.zbin_over_quant = zbin_oqmax;
+ }
/* Adjust bits_per_mb_at_this_q estimate */
bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q);
@@ -1222,8 +1264,9 @@
int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1;
av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2;
- if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
+ if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) {av_key_frame_frequency = key_freq;
+ }
cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] =
av_key_frame_frequency;
@@ -1236,10 +1279,11 @@
* KEY_FRAME_CONTEXT keyframes
*/
for (i = 0; i < KEY_FRAME_CONTEXT; ++i) {- if (i < KEY_FRAME_CONTEXT - 1)
+ if (i < KEY_FRAME_CONTEXT - 1) {cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i + 1];
- else
+ } else {cpi->prior_key_frame_distance[i] = last_kf_interval;
+ }
av_key_frame_frequency +=
prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i];
@@ -1272,9 +1316,9 @@
*/
overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth);
- if (cpi->oxcf.number_of_layers > 1)
+ if (cpi->oxcf.number_of_layers > 1) {cpi->kf_overspend_bits += overspend;
- else {+ } else {cpi->kf_overspend_bits += overspend * 7 / 8;
cpi->gf_overspend_bits += overspend * 1 / 8;
}
@@ -1360,9 +1404,9 @@
int vp8_pick_frame_size(VP8_COMP *cpi) {VP8_COMMON *cm = &cpi->common;
- if (cm->frame_type == KEY_FRAME)
+ if (cm->frame_type == KEY_FRAME) {calc_iframe_target_size(cpi);
- else {+ } else {calc_pframe_target_size(cpi);
/* Check if we're dropping the frame: */
@@ -1415,21 +1459,24 @@
// undershoots significantly, and then we end up dropping every other
// frame because the QP/rate_correction_factor may have been too low
// before the drop and then takes too long to come up.
- if (target_size >= (INT_MAX >> BPER_MB_NORMBITS))
+ if (target_size >= (INT_MAX >> BPER_MB_NORMBITS)) {target_bits_per_mb = (target_size / cpi->common.MBs)
<< BPER_MB_NORMBITS;
- else
+ } else {target_bits_per_mb =
(target_size << BPER_MB_NORMBITS) / cpi->common.MBs;
+ }
// Rate correction factor based on target_size_per_mb and max_QP.
new_correction_factor =
(double)target_bits_per_mb /
(double)vp8_bits_per_mb[INTER_FRAME][cpi->worst_quality];
- if (new_correction_factor > cpi->rate_correction_factor)
+ if (new_correction_factor > cpi->rate_correction_factor) {cpi->rate_correction_factor =
VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor);
- if (cpi->rate_correction_factor > MAX_BPB_FACTOR)
+ }
+ if (cpi->rate_correction_factor > MAX_BPB_FACTOR) {cpi->rate_correction_factor = MAX_BPB_FACTOR;
+ }
return 1;
} else {cpi->force_maxqp = 0;
--- a/vp8/encoder/rdopt.c
+++ b/vp8/encoder/rdopt.c
@@ -111,17 +111,20 @@
p[BLOCK_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES]) {int i, j, k;
- for (i = 0; i < BLOCK_TYPES; ++i)
- for (j = 0; j < COEF_BANDS; ++j)
- for (k = 0; k < PREV_COEF_CONTEXTS; ++k)
-
+ for (i = 0; i < BLOCK_TYPES; ++i) {+ for (j = 0; j < COEF_BANDS; ++j) {+ for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {/* check for pt=0 and band > 1 if block type 0
* and 0 if blocktype 1
*/
- if (k == 0 && j > (i == 0))
+ if (k == 0 && j > (i == 0)) {vp8_cost_tokens2(c[i][j][k], p[i][j][k], vp8_coef_tree, 2);
- else
+ } else {vp8_cost_tokens(c[i][j][k], p[i][j][k], vp8_coef_tree);
+ }
+ }
+ }
+ }
}
static const int rd_iifactor[32] = { 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0,@@ -180,11 +183,12 @@
}
if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {- if (cpi->twopass.next_iiratio > 31)
+ if (cpi->twopass.next_iiratio > 31) {cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
- else
+ } else {cpi->RDMULT +=
(cpi->RDMULT * rd_iifactor[cpi->twopass.next_iiratio]) >> 4;
+ }
}
cpi->mb.errorperbit = (cpi->RDMULT / 110);
@@ -231,10 +235,11 @@
/* build token cost array for the type of frame we have now */
FRAME_CONTEXT *l = &cpi->lfc_n;
- if (cpi->common.refresh_alt_ref_frame)
+ if (cpi->common.refresh_alt_ref_frame) {l = &cpi->lfc_a;
- else if (cpi->common.refresh_golden_frame)
+ } else if (cpi->common.refresh_golden_frame) {l = &cpi->lfc_g;
+ }
fill_token_costs(cpi->mb.token_costs,
(const vp8_prob(*)[8][3][11])l->coef_probs);
@@ -372,15 +377,17 @@
int offset;
int pre_stride = x->e_mbd.pre.uv_stride;
- if (mv_row < 0)
+ if (mv_row < 0) {mv_row -= 1;
- else
+ } else {mv_row += 1;
+ }
- if (mv_col < 0)
+ if (mv_col < 0) {mv_col -= 1;
- else
+ } else {mv_col += 1;
+ }
mv_row /= 2;
mv_col /= 2;
@@ -422,8 +429,9 @@
pt = vp8_prev_token_class[t];
}
- if (c < 16)
+ if (c < 16) {cost += mb->token_costs[type][vp8_coef_bands[c]][pt][DCT_EOB_TOKEN];
+ }
pt = (c != !type); /* is eob first coefficient; */
*a = *l = pt;
@@ -445,9 +453,10 @@
ta = (ENTROPY_CONTEXT *)&t_above;
tl = (ENTROPY_CONTEXT *)&t_left;
- for (b = 0; b < 16; ++b)
+ for (b = 0; b < 16; ++b) {cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_NO_DC,
ta + vp8_block2above[b], tl + vp8_block2left[b]);
+ }
cost += cost_coeffs(mb, x->block + 24, PLANE_TYPE_Y2,
ta + vp8_block2above[24], tl + vp8_block2left[24]);
@@ -681,9 +690,10 @@
ta = (ENTROPY_CONTEXT *)&t_above;
tl = (ENTROPY_CONTEXT *)&t_left;
- for (b = 16; b < 24; ++b)
+ for (b = 16; b < 24; ++b) {cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_UV,
ta + vp8_block2above[b], tl + vp8_block2left[b]);
+ }
return cost;
}
@@ -815,11 +825,11 @@
if (labelings[i] != which_label) continue;
- if (col && labelings[i] == labelings[i - 1])
+ if (col && labelings[i] == labelings[i - 1]) {m = LEFT4X4;
- else if (row && labelings[i] == labelings[i - 4])
+ } else if (row && labelings[i] == labelings[i - 4]) {m = ABOVE4X4;
- else {+ } else {/* the only time we should do costing for new motion vector
* or mode is when we are on a new label (jbb May 08, 2007)
*/
@@ -868,10 +878,12 @@
int b;
MACROBLOCKD *x = &mb->e_mbd;
- for (b = 0; b < 16; ++b)
- if (labels[b] == which_label)
+ for (b = 0; b < 16; ++b) {+ if (labels[b] == which_label) {cost += cost_coeffs(mb, x->block + b, PLANE_TYPE_Y_WITH_DC,
ta + vp8_block2above[b], tl + vp8_block2left[b]);
+ }
+ }
return cost;
}
@@ -1018,8 +1030,9 @@
if (cpi->compressor_speed) { if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8) {bsi->mvp.as_int = bsi->sv_mvp[i].as_int;
- if (i == 1 && segmentation == BLOCK_16X8)
+ if (i == 1 && segmentation == BLOCK_16X8) {bsi->mvp.as_int = bsi->sv_mvp[2].as_int;
+ }
step_param = bsi->sv_istep[i];
}
@@ -1029,8 +1042,9 @@
*/
if (segmentation == BLOCK_4X4 && i > 0) {bsi->mvp.as_int = x->e_mbd.block[i - 1].bmi.mv.as_int;
- if (i == 4 || i == 8 || i == 12)
+ if (i == 4 || i == 8 || i == 12) {bsi->mvp.as_int = x->e_mbd.block[i - 4].bmi.mv.as_int;
+ }
step_param = 2;
}
}
@@ -1061,9 +1075,9 @@
while (n < further_steps) {n++;
- if (num00)
+ if (num00) {num00--;
- else {+ } else {thissme = cpi->diamond_search_sad(
x, c, e, &mvp_full, &temp_mv, step_param + n, sadpb, &num00,
v_fn_ptr, x->mvcost, bsi->ref_mv);
@@ -1172,10 +1186,11 @@
static void vp8_cal_step_param(int sr, int *sp) {int step = 0;
- if (sr > MAX_FIRST_STEP)
+ if (sr > MAX_FIRST_STEP) {sr = MAX_FIRST_STEP;
- else if (sr < 1)
+ } else if (sr < 1) {sr = 1;
+ }
while (sr >>= 1) step++;
@@ -1436,10 +1451,11 @@
if (here->mbmi.ref_frame == near_ref[near_sadidx[i]]) {mv.as_int = near_mvs[near_sadidx[i]].as_int;
find = 1;
- if (i < 3)
+ if (i < 3) {*sr = 3;
- else
+ } else {*sr = 2;
+ }
break;
}
}
@@ -1514,22 +1530,26 @@
if (xd->mb_to_right_edge == 0) near_sad[6] = INT_MAX;
if (xd->mb_to_bottom_edge == 0) near_sad[7] = INT_MAX;
- if (near_sad[4] != INT_MAX)
+ if (near_sad[4] != INT_MAX) {near_sad[4] = cpi->fn_ptr[BLOCK_16X16].sdf(
src_y_ptr, b->src_stride, pre_y_buffer - pre_y_stride * 16,
pre_y_stride);
- if (near_sad[5] != INT_MAX)
+ }
+ if (near_sad[5] != INT_MAX) {near_sad[5] = cpi->fn_ptr[BLOCK_16X16].sdf(
src_y_ptr, b->src_stride, pre_y_buffer - 16, pre_y_stride);
+ }
near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(src_y_ptr, b->src_stride,
pre_y_buffer, pre_y_stride);
- if (near_sad[6] != INT_MAX)
+ if (near_sad[6] != INT_MAX) {near_sad[6] = cpi->fn_ptr[BLOCK_16X16].sdf(
src_y_ptr, b->src_stride, pre_y_buffer + 16, pre_y_stride);
- if (near_sad[7] != INT_MAX)
+ }
+ if (near_sad[7] != INT_MAX) {near_sad[7] = cpi->fn_ptr[BLOCK_16X16].sdf(
src_y_ptr, b->src_stride, pre_y_buffer + pre_y_stride * 16,
pre_y_stride);
+ }
}
if (cpi->common.last_frame_type != KEY_FRAME) {@@ -1661,8 +1681,9 @@
if (x->e_mbd.mode_info_context->mbmi.ref_frame) {for (i = 16; i < 24; ++i) tteob += x->e_mbd.eobs[i];
- } else
+ } else {tteob += uv_intra_tteob;
+ }
if (tteob == 0) {rd->rate2 -= (rd->rate_y + rd->rate_uv);
@@ -1683,8 +1704,9 @@
/* Calculate the final RD estimate for this mode */
this_rd = RDCOST(x->rdmult, x->rddiv, rd->rate2, rd->distortion2);
if (this_rd < INT_MAX &&
- x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME)
+ x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME) {this_rd += intra_rd_penalty;
+ }
}
return this_rd;
}
@@ -1818,8 +1840,9 @@
*/
if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) {if (this_mode != ZEROMV ||
- x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
+ x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) {continue;
+ }
}
/* everything but intra */
@@ -1848,8 +1871,9 @@
*/
x->rd_thresh_mult[mode_index] += 4;
- if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
+ if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
+ }
x->rd_threshes[mode_index] =
(cpi->rd_baseline_thresh[mode_index] >> 7) *
@@ -1869,18 +1893,20 @@
* Increase zbin size to supress noise
*/
if (x->zbin_mode_boost_enabled) {- if (this_ref_frame == INTRA_FRAME)
+ if (this_ref_frame == INTRA_FRAME) {x->zbin_mode_boost = 0;
- else {+ } else { if (vp8_mode_order[mode_index] == ZEROMV) {- if (this_ref_frame != LAST_FRAME)
+ if (this_ref_frame != LAST_FRAME) {x->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
- else
+ } else {x->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
- } else if (vp8_mode_order[mode_index] == SPLITMV)
+ }
+ } else if (vp8_mode_order[mode_index] == SPLITMV) {x->zbin_mode_boost = 0;
- else
+ } else {x->zbin_mode_boost = MV_ZBIN_BOOST;
+ }
}
vp8_update_zbin_extra(cpi, x);
@@ -2047,9 +2073,9 @@
while (n < further_steps) {n++;
- if (num00)
+ if (num00) {num00--;
- else {+ } else {thissme = cpi->diamond_search_sad(
x, b, d, &mvp_full, &d->bmi.mv, step_param + n, sadpb, &num00,
&cpi->fn_ptr[BLOCK_16X16], x->mvcost, &best_ref_mv);
@@ -2117,8 +2143,9 @@
* mode.
*/
if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) &&
- (mode_mv[this_mode].as_int == 0))
+ (mode_mv[this_mode].as_int == 0)) {continue;
+ }
case ZEROMV:
@@ -2130,8 +2157,9 @@
if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) ||
((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) ||
((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) ||
- ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max))
+ ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) {continue;
+ }
vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);
this_rd = evaluate_inter_mode_rd(mdcounts, &rd, &disable_skip, cpi, x);
@@ -2207,8 +2235,9 @@
else {x->rd_thresh_mult[mode_index] += 4;
- if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
+ if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) {x->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
+ }
}
x->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) *
x->rd_thresh_mult[mode_index];
@@ -2298,13 +2327,15 @@
sizeof(MB_MODE_INFO));
if (best_mode.mbmode.mode == B_PRED) {- for (i = 0; i < 16; ++i)
+ for (i = 0; i < 16; ++i) {xd->mode_info_context->bmi[i].as_mode = best_mode.bmodes[i].as_mode;
+ }
}
if (best_mode.mbmode.mode == SPLITMV) {- for (i = 0; i < 16; ++i)
+ for (i = 0; i < 16; ++i) {xd->mode_info_context->bmi[i].mv.as_int = best_mode.bmodes[i].mv.as_int;
+ }
memcpy(x->partition_info, &best_mode.partition, sizeof(PARTITION_INFO));
@@ -2313,8 +2344,9 @@
}
if (sign_bias !=
- cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame])
+ cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) {best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int;
+ }
rd_update_mvcount(x, &best_ref_mv);
}
--- a/vp8/encoder/rdopt.h
+++ b/vp8/encoder/rdopt.h
@@ -80,17 +80,20 @@
unsigned char *plane[4][3],
unsigned int recon_yoffset,
unsigned int recon_uvoffset) {- if (cpi->ref_frame_flags & VP8_LAST_FRAME)
+ if (cpi->ref_frame_flags & VP8_LAST_FRAME) {get_plane_pointers(&cpi->common.yv12_fb[cpi->common.lst_fb_idx],
plane[LAST_FRAME], recon_yoffset, recon_uvoffset);
+ }
- if (cpi->ref_frame_flags & VP8_GOLD_FRAME)
+ if (cpi->ref_frame_flags & VP8_GOLD_FRAME) {get_plane_pointers(&cpi->common.yv12_fb[cpi->common.gld_fb_idx],
plane[GOLDEN_FRAME], recon_yoffset, recon_uvoffset);
+ }
- if (cpi->ref_frame_flags & VP8_ALTR_FRAME)
+ if (cpi->ref_frame_flags & VP8_ALTR_FRAME) {get_plane_pointers(&cpi->common.yv12_fb[cpi->common.alt_fb_idx],
plane[ALTREF_FRAME], recon_yoffset, recon_uvoffset);
+ }
}
static INLINE void get_reference_search_order(const VP8_COMP *cpi,
--- a/vp8/encoder/temporal_filter.c
+++ b/vp8/encoder/temporal_filter.c
@@ -369,8 +369,9 @@
frames_to_blur_backward = num_frames_backward;
- if (frames_to_blur_backward >= max_frames)
+ if (frames_to_blur_backward >= max_frames) {frames_to_blur_backward = max_frames - 1;
+ }
frames_to_blur = frames_to_blur_backward + 1;
break;
@@ -380,8 +381,9 @@
frames_to_blur_forward = num_frames_forward;
- if (frames_to_blur_forward >= max_frames)
+ if (frames_to_blur_forward >= max_frames) {frames_to_blur_forward = max_frames - 1;
+ }
frames_to_blur = frames_to_blur_forward + 1;
break;
@@ -392,18 +394,22 @@
frames_to_blur_forward = num_frames_forward;
frames_to_blur_backward = num_frames_backward;
- if (frames_to_blur_forward > frames_to_blur_backward)
+ if (frames_to_blur_forward > frames_to_blur_backward) {frames_to_blur_forward = frames_to_blur_backward;
+ }
- if (frames_to_blur_backward > frames_to_blur_forward)
+ if (frames_to_blur_backward > frames_to_blur_forward) {frames_to_blur_backward = frames_to_blur_forward;
+ }
/* When max_frames is even we have 1 more frame backward than forward */
- if (frames_to_blur_forward > (max_frames - 1) / 2)
+ if (frames_to_blur_forward > (max_frames - 1) / 2) {frames_to_blur_forward = ((max_frames - 1) / 2);
+ }
- if (frames_to_blur_backward > (max_frames / 2))
+ if (frames_to_blur_backward > (max_frames / 2)) {frames_to_blur_backward = (max_frames / 2);
+ }
frames_to_blur = frames_to_blur_backward + frames_to_blur_forward + 1;
break;
--- a/vp8/encoder/tokenize.c
+++ b/vp8/encoder/tokenize.c
@@ -515,13 +515,15 @@
plane_type = 0;
}
- for (b = 0; b < 16; ++b)
+ for (b = 0; b < 16; ++b) {stuff1st_order_b(t, A + vp8_block2above[b], L + vp8_block2left[b],
plane_type, cpi, x);
+ }
- for (b = 16; b < 24; ++b)
+ for (b = 16; b < 24; ++b) {stuff1st_order_buv(t, A + vp8_block2above[b], L + vp8_block2left[b], cpi,
x);
+ }
}
void vp8_fix_contexts(MACROBLOCKD *x) {/* Clear entropy contexts for Y2 blocks */
--- a/vp8/encoder/treewriter.c
+++ b/vp8/encoder/treewriter.c
@@ -18,10 +18,11 @@
const vp8_tree_index j = T[i];
const int d = c + vp8_cost_bit(p, i & 1);
- if (j <= 0)
+ if (j <= 0) {C[-j] = d;
- else
+ } else {cost(C, T, P, j, d);
+ }
} while (++i & 1);
}
void vp8_cost_tokens(int *c, const vp8_prob *p, vp8_tree t) {--- a/vp8/encoder/vp8_quantize.c
+++ b/vp8/encoder/vp8_quantize.c
@@ -108,8 +108,9 @@
int has_2nd_order = (x->e_mbd.mode_info_context->mbmi.mode != B_PRED &&
x->e_mbd.mode_info_context->mbmi.mode != SPLITMV);
- for (i = 0; i < 24 + has_2nd_order; ++i)
+ for (i = 0; i < 24 + has_2nd_order; ++i) {x->quantize_b(&x->block[i], &x->e_mbd.block[i]);
+ }
}
void vp8_quantize_mbuv(MACROBLOCK *x) {@@ -296,11 +297,11 @@
/* Select the baseline MB Q index. */
if (xd->segmentation_enabled) {/* Abs Value */
- if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
+ if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA) {QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context
->mbmi.segment_id];
- /* Delta Value */
- else {+ /* Delta Value */
+ } else {QIndex = cpi->common.base_qindex +
xd->segment_feature_data[MB_LVL_ALT_Q][xd->mode_info_context
->mbmi.segment_id];
@@ -307,8 +308,9 @@
/* Clamp to valid range */
QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;
}
- } else
+ } else {QIndex = cpi->common.base_qindex;
+ }
/* This initialization should be called at least once. Use ok_to_skip to
* decide if it is ok to skip.
@@ -452,8 +454,9 @@
if (Q < 4) {new_delta_q = 4 - Q;
- } else
+ } else {new_delta_q = 0;
+ }
update |= cm->y2dc_delta_q != new_delta_q;
cm->y2dc_delta_q = new_delta_q;
--- a/vp8/vp8_cx_iface.c
+++ b/vp8/vp8_cx_iface.c
@@ -89,8 +89,9 @@
vpx_codec_alg_priv_t *ctx, const struct vpx_internal_error_info *error) {vpx_codec_err_t res;
- if ((res = error->error_code))
+ if ((res = error->error_code)) {ctx->base.err_detail = error->has_detail ? error->detail : NULL;
+ }
return res;
}
@@ -228,15 +229,17 @@
unsigned int i;
RANGE_CHECK_HI(cfg, ts_periodicity, 16);
- for (i = 1; i < cfg->ts_number_layers; ++i)
+ for (i = 1; i < cfg->ts_number_layers; ++i) {if (cfg->ts_target_bitrate[i] <= cfg->ts_target_bitrate[i - 1] &&
cfg->rc_target_bitrate > 0)
ERROR("ts_target_bitrate entries are not strictly increasing");+ }
RANGE_CHECK(cfg, ts_rate_decimator[cfg->ts_number_layers - 1], 1, 1);
- for (i = cfg->ts_number_layers - 2; i > 0; i--)
+ for (i = cfg->ts_number_layers - 2; i > 0; i--) {if (cfg->ts_rate_decimator[i - 1] != 2 * cfg->ts_rate_decimator[i])
ERROR("ts_rate_decimator factors are not powers of 2");+ }
RANGE_CHECK_HI(cfg, ts_layer_id[i], cfg->ts_number_layers - 1);
}
@@ -631,10 +634,11 @@
return VPX_CODEC_MEM_ERROR;
}
- if (mr_cfg)
+ if (mr_cfg) {ctx->priv->enc.total_encoders = mr_cfg->mr_total_resolutions;
- else
+ } else {ctx->priv->enc.total_encoders = 1;
+ }
once(vp8_initialize_enc);
@@ -723,13 +727,14 @@
new_qc = MODE_REALTIME;
#endif
- if (deadline == VPX_DL_REALTIME)
+ if (deadline == VPX_DL_REALTIME) {new_qc = MODE_REALTIME;
- else if (ctx->cfg.g_pass == VPX_RC_FIRST_PASS)
+ } else if (ctx->cfg.g_pass == VPX_RC_FIRST_PASS) {new_qc = MODE_FIRSTPASS;
- else if (ctx->cfg.g_pass == VPX_RC_LAST_PASS)
+ } else if (ctx->cfg.g_pass == VPX_RC_LAST_PASS) {new_qc =
(new_qc == MODE_BESTQUALITY) ? MODE_SECONDPASS_BEST : MODE_SECONDPASS;
+ }
if (ctx->oxcf.Mode != new_qc) {ctx->oxcf.Mode = new_qc;
@@ -825,11 +830,13 @@
int comp_data_state = 0;
/* Set up internal flags */
- if (ctx->base.init_flags & VPX_CODEC_USE_PSNR)
+ if (ctx->base.init_flags & VPX_CODEC_USE_PSNR) {((VP8_COMP *)ctx->cpi)->b_calculate_psnr = 1;
+ }
- if (ctx->base.init_flags & VPX_CODEC_USE_OUTPUT_PARTITION)
+ if (ctx->base.init_flags & VPX_CODEC_USE_OUTPUT_PARTITION) {((VP8_COMP *)ctx->cpi)->output_partition = 1;
+ }
/* Convert API flags to internal codec lib flags */
lib_flags = (flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
@@ -863,10 +870,11 @@
ctx->cpi, &lib_flags, &size, cx_data, cx_data_end, &dst_time_stamp,
&dst_end_time_stamp, !img);
- if (comp_data_state == VPX_CODEC_CORRUPT_FRAME)
+ if (comp_data_state == VPX_CODEC_CORRUPT_FRAME) {return VPX_CODEC_CORRUPT_FRAME;
- else if (comp_data_state == -1)
+ } else if (comp_data_state == -1) {break;
+ }
if (size) {vpx_codec_pts_t round, delta;
@@ -885,8 +893,9 @@
ctx->cfg.g_timebase.num / 10000000);
pkt.data.frame.flags = lib_flags << 16;
- if (lib_flags & FRAMEFLAGS_KEY)
+ if (lib_flags & FRAMEFLAGS_KEY) {pkt.data.frame.flags |= VPX_FRAME_IS_KEY;
+ }
if (!cpi->common.show_frame) {pkt.data.frame.flags |= VPX_FRAME_IS_INVISIBLE;
@@ -923,8 +932,9 @@
pkt.data.frame.sz = cpi->partition_sz[i];
pkt.data.frame.partition_id = i;
/* don't set the fragment bit for the last partition */
- if (i == (num_partitions - 1))
+ if (i == (num_partitions - 1)) {pkt.data.frame.flags &= ~VPX_FRAME_IS_FRAGMENT;
+ }
vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
}
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
@@ -966,8 +976,9 @@
image2yuvconfig(&frame->img, &sd);
vp8_set_reference(ctx->cpi, frame->frame_type, &sd);
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8e_get_reference(vpx_codec_alg_priv_t *ctx,
@@ -981,8 +992,9 @@
image2yuvconfig(&frame->img, &sd);
vp8_get_reference(ctx->cpi, frame->frame_type, &sd);
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8e_set_previewpp(vpx_codec_alg_priv_t *ctx,
@@ -993,8 +1005,9 @@
if (data) {ctx->preview_ppcfg = *((vp8_postproc_cfg_t *)data);
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
#else
(void)ctx;
(void)args;
@@ -1043,8 +1056,9 @@
ctx->preview_img.h = sd.y_height;
return &ctx->preview_img;
- } else
+ } else {return NULL;
+ }
}
static vpx_codec_err_t vp8e_set_frame_flags(vpx_codec_alg_priv_t *ctx,
@@ -1072,12 +1086,14 @@
vpx_roi_map_t *roi = (vpx_roi_map_t *)data;
if (!vp8_set_roimap(ctx->cpi, roi->roi_map, roi->rows, roi->cols,
- roi->delta_q, roi->delta_lf, roi->static_threshold))
+ roi->delta_q, roi->delta_lf, roi->static_threshold)) {return VPX_CODEC_OK;
- else
+ } else {return VPX_CODEC_INVALID_PARAM;
- } else
+ }
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8e_set_activemap(vpx_codec_alg_priv_t *ctx,
@@ -1087,12 +1103,14 @@
if (data) {vpx_active_map_t *map = (vpx_active_map_t *)data;
- if (!vp8_set_active_map(ctx->cpi, map->active_map, map->rows, map->cols))
+ if (!vp8_set_active_map(ctx->cpi, map->active_map, map->rows, map->cols)) {return VPX_CODEC_OK;
- else
+ } else {return VPX_CODEC_INVALID_PARAM;
- } else
+ }
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8e_set_scalemode(vpx_codec_alg_priv_t *ctx,
@@ -1109,10 +1127,12 @@
/*force next frame a key frame to effect scaling mode */
ctx->next_frame_flag |= FRAMEFLAGS_KEY;
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
- } else
+ }
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] = {--- a/vp8/vp8_dx_iface.c
+++ b/vp8/vp8_dx_iface.c
@@ -169,8 +169,9 @@
si->is_kf = 1;
/* vet via sync code */
- if (clear[3] != 0x9d || clear[4] != 0x01 || clear[5] != 0x2a)
+ if (clear[3] != 0x9d || clear[4] != 0x01 || clear[5] != 0x2a) {return VPX_CODEC_UNSUP_BITSTREAM;
+ }
si->w = (clear[6] | (clear[7] << 8)) & 0x3fff;
si->h = (clear[8] | (clear[9] << 8)) & 0x3fff;
@@ -194,10 +195,11 @@
vpx_codec_stream_info_t *si) {unsigned int sz;
- if (si->sz >= sizeof(vp8_stream_info_t))
+ if (si->sz >= sizeof(vp8_stream_info_t)) {sz = sizeof(vp8_stream_info_t);
- else
+ } else {sz = sizeof(vpx_codec_stream_info_t);
+ }
memcpy(si, &ctx->si, sz);
si->sz = sz;
@@ -209,8 +211,9 @@
vpx_codec_alg_priv_t *ctx, const struct vpx_internal_error_info *error) {vpx_codec_err_t res;
- if ((res = error->error_code))
+ if ((res = error->error_code)) {ctx->base.err_detail = error->has_detail ? error->detail : NULL;
+ }
return res;
}
@@ -384,9 +387,10 @@
"Invalid frame height");
}
- if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
+ if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height)) {vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
"Failed to allocate frame buffers");
+ }
xd->pre = pc->yv12_fb[pc->lst_fb_idx];
xd->dst = pc->yv12_fb[pc->new_fb_idx];
@@ -426,8 +430,9 @@
#endif
#if CONFIG_MULTITHREAD
- if (pbi->b_multithreaded_rd)
+ if (pbi->b_multithreaded_rd) {vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
+ }
#else
(void)prev_mb_rows;
#endif
@@ -540,8 +545,9 @@
return vp8dx_set_reference(ctx->yv12_frame_buffers.pbi[0],
frame->frame_type, &sd);
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8_get_reference(vpx_codec_alg_priv_t *ctx,
@@ -556,8 +562,9 @@
return vp8dx_get_reference(ctx->yv12_frame_buffers.pbi[0],
frame->frame_type, &sd);
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8_set_postproc(vpx_codec_alg_priv_t *ctx,
@@ -569,8 +576,9 @@
ctx->postproc_cfg_set = 1;
ctx->postproc_cfg = *((vp8_postproc_cfg_t *)data);
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
#else
(void)ctx;
@@ -639,8 +647,9 @@
pbi->common.refresh_last_frame * (int)VP8_LAST_FRAME;
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
extern int vp8dx_references_buffer(VP8_COMMON *oci, int ref_frame);
@@ -657,8 +666,9 @@
(vp8dx_references_buffer(oci, LAST_FRAME) ? VP8_LAST_FRAME : 0);
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8_get_frame_corrupted(vpx_codec_alg_priv_t *ctx,
@@ -671,8 +681,9 @@
if (frame == NULL) return VPX_CODEC_ERROR;
*corrupted = frame->corrupted;
return VPX_CODEC_OK;
- } else
+ } else {return VPX_CODEC_INVALID_PARAM;
+ }
}
static vpx_codec_err_t vp8_set_decryptor(vpx_codec_alg_priv_t *ctx,