LineageOS/android_external_libvpx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vp9/encoder: apply clang-format

Browse Source 
Change-Id: I45d9fb4013f50766b24363a86365e8063e8954c2
This commit is contained in:
clang-format
2016-07-26 20:43:23 -07:00
committed by James Zern
parent 3a04c9c9c4
commit e0cc52db3f
81 changed files with 6382 additions and 8308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
vp9/encoder/vp9_denoiser.c
View File

@@ -48,8 +48,7 @@ static unsigned int sse_thresh(BLOCK_SIZE bs, int increase_denoising) {
static int sse_diff_thresh(BLOCK_SIZE bs, int increase_denoising,
int motion_magnitude) {
if (motion_magnitude >
noise_motion_thresh(bs, increase_denoising)) {
if (motion_magnitude > noise_motion_thresh(bs, increase_denoising)) {
if (increase_denoising)
return (1 << num_pels_log2_lookup[bs]) << 2;
else
@@ -67,18 +66,15 @@ static int total_adj_weak_thresh(BLOCK_SIZE bs, int increase_denoising) {
// we might need to update the code for calculating 'total_adj' in
// case the C code is not bit-exact with corresponding sse2 code.
int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride,
const uint8_t *mc_avg,
int mc_avg_stride,
uint8_t *avg, int avg_stride,
int increase_denoising,
BLOCK_SIZE bs,
int motion_magnitude) {
const uint8_t *mc_avg, int mc_avg_stride,
uint8_t *avg, int avg_stride, int increase_denoising,
BLOCK_SIZE bs, int motion_magnitude) {
int r, c;
const uint8_t *sig_start = sig;
const uint8_t *mc_avg_start = mc_avg;
uint8_t *avg_start = avg;
int diff, adj, absdiff, delta;
int adj_val[] = {3, 4, 6};
int adj_val[] = { 3, 4, 6 };
int total_adj = 0;
int shift_inc = 1;
@@ -105,15 +101,19 @@ int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride,
total_adj += diff;
} else {
switch (absdiff) {
case 4: case 5: case 6: case 7:
adj = adj_val[0];
break;
case 8: case 9: case 10: case 11:
case 12: case 13: case 14: case 15:
adj = adj_val[1];
break;
default:
adj = adj_val[2];
case 4:
case 5:
case 6:
case 7: adj = adj_val[0]; break;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15: adj = adj_val[1]; break;
default: adj = adj_val[2];
}
if (diff > 0) {
avg[c] = VPXMIN(UINT8_MAX, sig[c] + adj);
@@ -135,14 +135,15 @@ int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride,
}
// Otherwise, we try to dampen the filter if the delta is not too high.
delta = ((abs(total_adj) - total_adj_strong_thresh(bs, increase_denoising))
>> num_pels_log2_lookup[bs]) + 1;
delta = ((abs(total_adj) - total_adj_strong_thresh(bs, increase_denoising)) >>
num_pels_log2_lookup[bs]) +
1;
if (delta >= delta_thresh(bs, increase_denoising)) {
return COPY_BLOCK;
}
mc_avg = mc_avg_start;
mc_avg = mc_avg_start;
avg = avg_start;
sig = sig_start;
for (r = 0; r < (4 << b_height_log2_lookup[bs]); ++r) {
@@ -178,22 +179,15 @@ int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride,
return COPY_BLOCK;
}
static uint8_t *block_start(uint8_t *framebuf, int stride,
int mi_row, int mi_col) {
return framebuf + (stride * mi_row << 3) + (mi_col << 3);
static uint8_t *block_start(uint8_t *framebuf, int stride, int mi_row,
int mi_col) {
return framebuf + (stride * mi_row << 3) + (mi_col << 3);
}
static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
MACROBLOCK *mb,
BLOCK_SIZE bs,
int increase_denoising,
int mi_row,
int mi_col,
PICK_MODE_CONTEXT *ctx,
int motion_magnitude,
int is_skin,
int *zeromv_filter,
int consec_zeromv) {
static VP9_DENOISER_DECISION perform_motion_compensation(
VP9_DENOISER *denoiser, MACROBLOCK *mb, BLOCK_SIZE bs,
int increase_denoising, int mi_row, int mi_col, PICK_MODE_CONTEXT *ctx,
int motion_magnitude, int is_skin, int *zeromv_filter, int consec_zeromv) {
int sse_diff = ctx->zeromv_sse - ctx->newmv_sse;
MV_REFERENCE_FRAME frame;
MACROBLOCKD *filter_mbd = &mb->e_mbd;
@@ -206,20 +200,18 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
frame = ctx->best_reference_frame;
saved_mi = *mi;
if (is_skin && (motion_magnitude > 0 || consec_zeromv < 4))
return COPY_BLOCK;
if (is_skin && (motion_magnitude > 0 || consec_zeromv < 4)) return COPY_BLOCK;
// Avoid denoising for small block (unless motion is small).
// Small blocks are selected in variance partition (before encoding) and
// will typically lie on moving areas.
if (denoiser->denoising_level < kDenHigh &&
motion_magnitude > 16 && bs <= BLOCK_8X8)
if (denoiser->denoising_level < kDenHigh && motion_magnitude > 16 &&
bs <= BLOCK_8X8)
return COPY_BLOCK;
// If the best reference frame uses inter-prediction and there is enough of a
// difference in sum-squared-error, use it.
if (frame != INTRA_FRAME &&
ctx->newmv_sse != UINT_MAX &&
if (frame != INTRA_FRAME && ctx->newmv_sse != UINT_MAX &&
sse_diff > sse_diff_thresh(bs, increase_denoising, motion_magnitude)) {
mi->ref_frame[0] = ctx->best_reference_frame;
mi->mode = ctx->best_sse_inter_mode;
@@ -230,7 +222,7 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
ctx->newmv_sse = ctx->zeromv_sse;
// Bias to last reference.
if (frame != LAST_FRAME &&
((ctx->zeromv_lastref_sse < (5 * ctx->zeromv_sse) >> 2) ||
((ctx->zeromv_lastref_sse<(5 * ctx->zeromv_sse)>> 2) ||
denoiser->denoising_level >= kDenHigh)) {
frame = LAST_FRAME;
ctx->newmv_sse = ctx->zeromv_lastref_sse;
@@ -251,8 +243,7 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
*mi = saved_mi;
return COPY_BLOCK;
}
if (motion_magnitude >
(noise_motion_thresh(bs, increase_denoising) << 3)) {
if (motion_magnitude > (noise_motion_thresh(bs, increase_denoising) << 3)) {
// Restore everything to its original state
*mi = saved_mi;
return COPY_BLOCK;
@@ -268,37 +259,28 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
// struct.
filter_mbd->plane[0].pre[0].buf =
block_start(denoiser->running_avg_y[frame].y_buffer,
denoiser->running_avg_y[frame].y_stride,
mi_row, mi_col);
filter_mbd->plane[0].pre[0].stride =
denoiser->running_avg_y[frame].y_stride;
denoiser->running_avg_y[frame].y_stride, mi_row, mi_col);
filter_mbd->plane[0].pre[0].stride = denoiser->running_avg_y[frame].y_stride;
filter_mbd->plane[1].pre[0].buf =
block_start(denoiser->running_avg_y[frame].u_buffer,
denoiser->running_avg_y[frame].uv_stride,
mi_row, mi_col);
filter_mbd->plane[1].pre[0].stride =
denoiser->running_avg_y[frame].uv_stride;
block_start(denoiser->running_avg_y[frame].u_buffer,
denoiser->running_avg_y[frame].uv_stride, mi_row, mi_col);
filter_mbd->plane[1].pre[0].stride = denoiser->running_avg_y[frame].uv_stride;
filter_mbd->plane[2].pre[0].buf =
block_start(denoiser->running_avg_y[frame].v_buffer,
denoiser->running_avg_y[frame].uv_stride,
mi_row, mi_col);
filter_mbd->plane[2].pre[0].stride =
denoiser->running_avg_y[frame].uv_stride;
denoiser->running_avg_y[frame].uv_stride, mi_row, mi_col);
filter_mbd->plane[2].pre[0].stride = denoiser->running_avg_y[frame].uv_stride;
filter_mbd->plane[0].dst.buf =
block_start(denoiser->mc_running_avg_y.y_buffer,
denoiser->mc_running_avg_y.y_stride,
mi_row, mi_col);
denoiser->mc_running_avg_y.y_stride, mi_row, mi_col);
filter_mbd->plane[0].dst.stride = denoiser->mc_running_avg_y.y_stride;
filter_mbd->plane[1].dst.buf =
block_start(denoiser->mc_running_avg_y.u_buffer,
denoiser->mc_running_avg_y.uv_stride,
mi_row, mi_col);
denoiser->mc_running_avg_y.uv_stride, mi_row, mi_col);
filter_mbd->plane[1].dst.stride = denoiser->mc_running_avg_y.uv_stride;
filter_mbd->plane[2].dst.buf =
block_start(denoiser->mc_running_avg_y.v_buffer,
denoiser->mc_running_avg_y.uv_stride,
mi_row, mi_col);
denoiser->mc_running_avg_y.uv_stride, mi_row, mi_col);
filter_mbd->plane[2].dst.stride = denoiser->mc_running_avg_y.uv_stride;
vp9_build_inter_predictors_sby(filter_mbd, mi_row, mi_col, bs);
@@ -313,9 +295,8 @@ static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
return FILTER_BLOCK;
}
void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
int mi_row, int mi_col, BLOCK_SIZE bs,
PICK_MODE_CONTEXT *ctx,
void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb, int mi_row, int mi_col,
BLOCK_SIZE bs, PICK_MODE_CONTEXT *ctx,
VP9_DENOISER_DECISION *denoiser_decision) {
int mv_col, mv_row;
int motion_magnitude = 0;
@@ -325,8 +306,8 @@ void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
YV12_BUFFER_CONFIG avg = denoiser->running_avg_y[INTRA_FRAME];
YV12_BUFFER_CONFIG mc_avg = denoiser->mc_running_avg_y;
uint8_t *avg_start = block_start(avg.y_buffer, avg.y_stride, mi_row, mi_col);
uint8_t *mc_avg_start = block_start(mc_avg.y_buffer, mc_avg.y_stride,
mi_row, mi_col);
uint8_t *mc_avg_start =
block_start(mc_avg.y_buffer, mc_avg.y_stride, mi_row, mi_col);
struct buf_2d src = mb->plane[0].src;
int is_skin = 0;
int consec_zeromv = 0;
@@ -334,8 +315,7 @@ void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
mv_row = ctx->best_sse_mv.as_mv.row;
motion_magnitude = mv_row * mv_row + mv_col * mv_col;
if (cpi->use_skin_detection &&
bs <= BLOCK_32X32 &&
if (cpi->use_skin_detection && bs <= BLOCK_32X32 &&
denoiser->denoising_level < kDenHigh) {
int motion_level = (motion_magnitude < 16) ? 0 : 1;
// If motion for current block is small/zero, compute consec_zeromv for
@@ -343,7 +323,7 @@ void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
// consec_zeromv when current block has small/zero motion).
consec_zeromv = 0;
if (motion_level == 0) {
VP9_COMMON * const cm = &cpi->common;
VP9_COMMON *const cm = &cpi->common;
int j, i;
// Loop through the 8x8 sub-blocks.
const int bw = num_8x8_blocks_wide_lookup[BLOCK_64X64];
@@ -367,48 +347,35 @@ void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
}
}
// TODO(marpan): Compute skin detection over sub-blocks.
is_skin = vp9_compute_skin_block(mb->plane[0].src.buf,
mb->plane[1].src.buf,
mb->plane[2].src.buf,
mb->plane[0].src.stride,
mb->plane[1].src.stride,
bs,
consec_zeromv,
motion_level);
is_skin = vp9_compute_skin_block(
mb->plane[0].src.buf, mb->plane[1].src.buf, mb->plane[2].src.buf,
mb->plane[0].src.stride, mb->plane[1].src.stride, bs, consec_zeromv,
motion_level);
}
if (!is_skin &&
denoiser->denoising_level == kDenHigh) {
if (!is_skin && denoiser->denoising_level == kDenHigh) {
denoiser->increase_denoising = 1;
} else {
denoiser->increase_denoising = 0;
}
if (denoiser->denoising_level >= kDenLow)
decision = perform_motion_compensation(denoiser, mb, bs,
denoiser->increase_denoising,
mi_row, mi_col, ctx,
motion_magnitude,
is_skin,
&zeromv_filter,
consec_zeromv);
decision = perform_motion_compensation(
denoiser, mb, bs, denoiser->increase_denoising, mi_row, mi_col, ctx,
motion_magnitude, is_skin, &zeromv_filter, consec_zeromv);
if (decision == FILTER_BLOCK) {
decision = vp9_denoiser_filter(src.buf, src.stride,
mc_avg_start, mc_avg.y_stride,
avg_start, avg.y_stride,
denoiser->increase_denoising,
bs, motion_magnitude);
decision = vp9_denoiser_filter(
src.buf, src.stride, mc_avg_start, mc_avg.y_stride, avg_start,
avg.y_stride, denoiser->increase_denoising, bs, motion_magnitude);
}
if (decision == FILTER_BLOCK) {
vpx_convolve_copy(avg_start, avg.y_stride, src.buf, src.stride,
NULL, 0, NULL, 0,
num_4x4_blocks_wide_lookup[bs] << 2,
vpx_convolve_copy(avg_start, avg.y_stride, src.buf, src.stride, NULL, 0,
NULL, 0, num_4x4_blocks_wide_lookup[bs] << 2,
num_4x4_blocks_high_lookup[bs] << 2);
} else { // COPY_BLOCK
vpx_convolve_copy(src.buf, src.stride, avg_start, avg.y_stride,
NULL, 0, NULL, 0,
num_4x4_blocks_wide_lookup[bs] << 2,
vpx_convolve_copy(src.buf, src.stride, avg_start, avg.y_stride, NULL, 0,
NULL, 0, num_4x4_blocks_wide_lookup[bs] << 2,
num_4x4_blocks_high_lookup[bs] << 2);
}
*denoiser_decision = decision;
@@ -416,8 +383,8 @@ void vp9_denoiser_denoise(VP9_COMP *cpi, MACROBLOCK *mb,
*denoiser_decision = FILTER_ZEROMV_BLOCK;
}
static void copy_frame(YV12_BUFFER_CONFIG * const dest,
const YV12_BUFFER_CONFIG * const src) {
static void copy_frame(YV12_BUFFER_CONFIG *const dest,
const YV12_BUFFER_CONFIG *const src) {
int r;
const uint8_t *srcbuf = src->y_buffer;
uint8_t *destbuf = dest->y_buffer;
@@ -432,8 +399,8 @@ static void copy_frame(YV12_BUFFER_CONFIG * const dest,
}
}
static void swap_frame_buffer(YV12_BUFFER_CONFIG * const dest,
YV12_BUFFER_CONFIG * const src) {
static void swap_frame_buffer(YV12_BUFFER_CONFIG *const dest,
YV12_BUFFER_CONFIG *const src) {
uint8_t *tmp_buf = dest->y_buffer;
assert(dest->y_width == src->y_width);
assert(dest->y_height == src->y_height);
@@ -446,8 +413,7 @@ void vp9_denoiser_update_frame_info(VP9_DENOISER *denoiser,
FRAME_TYPE frame_type,
int refresh_alt_ref_frame,
int refresh_golden_frame,
int refresh_last_frame,
int resized) {
int refresh_last_frame, int resized) {
// Copy source into denoised reference buffers on KEY_FRAME or
// if the just encoded frame was resized.
if (frame_type == KEY_FRAME || resized != 0 || denoiser->reset) {
@@ -460,8 +426,7 @@ void vp9_denoiser_update_frame_info(VP9_DENOISER *denoiser,
}
// If more than one refresh occurs, must copy frame buffer.
if ((refresh_alt_ref_frame + refresh_golden_frame + refresh_last_frame)
> 1) {
if ((refresh_alt_ref_frame + refresh_golden_frame + refresh_last_frame) > 1) {
if (refresh_alt_ref_frame) {
copy_frame(&denoiser->running_avg_y[ALTREF_FRAME],
&denoiser->running_avg_y[INTRA_FRAME]);
@@ -503,8 +468,7 @@ void vp9_denoiser_update_frame_stats(MODE_INFO *mi, unsigned int sse,
if (mi->mv[0].as_int == 0 && sse < ctx->zeromv_sse) {
ctx->zeromv_sse = sse;
ctx->best_zeromv_reference_frame = mi->ref_frame[0];
if (mi->ref_frame[0] == LAST_FRAME)
ctx->zeromv_lastref_sse = sse;
if (mi->ref_frame[0] == LAST_FRAME) ctx->zeromv_lastref_sse = sse;
}
if (mi->mv[0].as_int != 0 && sse < ctx->newmv_sse) {
@@ -515,8 +479,8 @@ void vp9_denoiser_update_frame_stats(MODE_INFO *mi, unsigned int sse,
}
}
int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height,
int ssx, int ssy,
int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height, int ssx,
int ssy,
#if CONFIG_VP9_HIGHBITDEPTH
int use_highbitdepth,
#endif
@@ -541,8 +505,8 @@ int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height,
#endif
}
fail = vpx_alloc_frame_buffer(&denoiser->mc_running_avg_y, width, height,
ssx, ssy,
fail = vpx_alloc_frame_buffer(&denoiser->mc_running_avg_y, width, height, ssx,
ssy,
#if CONFIG_VP9_HIGHBITDEPTH
use_highbitdepth,
#endif
@@ -552,8 +516,7 @@ int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height,
return 1;
}
fail = vpx_alloc_frame_buffer(&denoiser->last_source, width, height,
ssx, ssy,
fail = vpx_alloc_frame_buffer(&denoiser->last_source, width, height, ssx, ssy,
#if CONFIG_VP9_HIGHBITDEPTH
use_highbitdepth,
#endif
@@ -586,8 +549,7 @@ void vp9_denoiser_free(VP9_DENOISER *denoiser) {
vpx_free_frame_buffer(&denoiser->last_source);
}
void vp9_denoiser_set_noise_level(VP9_DENOISER *denoiser,
int noise_level) {
void vp9_denoiser_set_noise_level(VP9_DENOISER *denoiser, int noise_level) {
denoiser->denoising_level = noise_level;
if (denoiser->denoising_level > kDenLowLow &&
denoiser->prev_denoising_level == kDenLowLow)