/* * Copyright (c) 2012 The WebM project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "denoising.h" #include "vp8/common/reconinter.h" #include "vpx/vpx_integer.h" #include "vpx_mem/vpx_mem.h" #include "vpx_rtcd.h" static const unsigned int NOISE_MOTION_THRESHOLD = 25 * 25; /* SSE_DIFF_THRESHOLD is selected as ~95% confidence assuming * var(noise) ~= 100. */ static const unsigned int SSE_DIFF_THRESHOLD = 16 * 16 * 20; static const unsigned int SSE_THRESHOLD = 16 * 16 * 40; /* * The filtering coefficients used for denoizing are adjusted for static * blocks, or blocks with very small motion vectors. This is done through * the motion magnitude parameter. * * There are currently 2048 possible mapping from absolute difference to * filter coefficient depending on the motion magnitude. Each mapping is * in a LUT table. All these tables are staticly allocated but they are only * filled on their first use. * * Each entry is a pair of 16b values, the coefficient and its complement * to 256. Each of these value should only be 8b but they are 16b wide to * avoid slow partial register manipulations. */ enum {num_motion_magnitude_adjustments = 2048}; static union coeff_pair filter_coeff_LUT[num_motion_magnitude_adjustments][256]; static uint8_t filter_coeff_LUT_initialized[num_motion_magnitude_adjustments] = { 0 }; union coeff_pair *vp8_get_filter_coeff_LUT(unsigned int motion_magnitude) { union coeff_pair *LUT; unsigned int motion_magnitude_adjustment = motion_magnitude >> 3; if (motion_magnitude_adjustment >= num_motion_magnitude_adjustments) { motion_magnitude_adjustment = num_motion_magnitude_adjustments - 1; } LUT = filter_coeff_LUT[motion_magnitude_adjustment]; if (!filter_coeff_LUT_initialized[motion_magnitude_adjustment]) { int absdiff; for (absdiff = 0; absdiff < 256; ++absdiff) { unsigned int filter_coefficient; filter_coefficient = (255 << 8) / (256 + ((absdiff * 330) >> 3)); filter_coefficient += filter_coefficient / (3 + motion_magnitude_adjustment); if (filter_coefficient > 255) { filter_coefficient = 255; } LUT[absdiff].as_short[0] = filter_coefficient ; LUT[absdiff].as_short[1] = 256 - filter_coefficient; } filter_coeff_LUT_initialized[motion_magnitude_adjustment] = 1; } return LUT; } int vp8_denoiser_filter_c(YV12_BUFFER_CONFIG *mc_running_avg, YV12_BUFFER_CONFIG *running_avg, MACROBLOCK *signal, unsigned int motion_magnitude, int y_offset, int uv_offset) { unsigned char filtered_buf[16*16]; unsigned char *filtered = filtered_buf; unsigned char *sig = signal->thismb; int sig_stride = 16; unsigned char *mc_running_avg_y = mc_running_avg->y_buffer + y_offset; int mc_avg_y_stride = mc_running_avg->y_stride; unsigned char *running_avg_y = running_avg->y_buffer + y_offset; int avg_y_stride = running_avg->y_stride; const union coeff_pair *LUT = vp8_get_filter_coeff_LUT(motion_magnitude); int r, c; int sum_diff = 0; for (r = 0; r < 16; ++r) { /* Calculate absolute differences */ unsigned char abs_diff[16]; union coeff_pair filter_coefficient[16]; for (c = 0; c < 16; ++c) { int absdiff = sig[c] - mc_running_avg_y[c]; absdiff = absdiff > 0 ? absdiff : -absdiff; abs_diff[c] = absdiff; } /* Use LUT to get filter coefficients (two 16b value; f and 256-f) */ for (c = 0; c < 16; ++c) { filter_coefficient[c] = LUT[abs_diff[c]]; } /* Filtering... */ for (c = 0; c < 16; ++c) { const uint16_t state = (uint16_t)(mc_running_avg_y[c]); const uint16_t sample = (uint16_t)(sig[c]); running_avg_y[c] = (filter_coefficient[c].as_short[0] * state + filter_coefficient[c].as_short[1] * sample + 128) >> 8; } /* Depending on the magnitude of the difference between the signal and * filtered version, either replace the signal by the filtered one or * update the filter state with the signal when the change in a pixel * isn't classified as noise. */ for (c = 0; c < 16; ++c) { const int diff = sig[c] - running_avg_y[c]; sum_diff += diff; if (diff * diff < NOISE_DIFF2_THRESHOLD) { filtered[c] = running_avg_y[c]; } else { filtered[c] = sig[c]; running_avg_y[c] = sig[c]; } } /* Update pointers for next iteration. */ sig += sig_stride; filtered += 16; mc_running_avg_y += mc_avg_y_stride; running_avg_y += avg_y_stride; } if (abs(sum_diff) > SUM_DIFF_THRESHOLD) { return COPY_BLOCK; } vp8_copy_mem16x16(filtered_buf, 16, signal->thismb, sig_stride); return FILTER_BLOCK; } int vp8_denoiser_allocate(VP8_DENOISER *denoiser, int width, int height) { int i; assert(denoiser); /* don't need one for intra start at 1 */ for (i = 1; i < MAX_REF_FRAMES; i++) { denoiser->yv12_running_avg[i].flags = 0; if (vp8_yv12_alloc_frame_buffer(&(denoiser->yv12_running_avg[i]), width, height, VP8BORDERINPIXELS) < 0) { vp8_denoiser_free(denoiser); return 1; } vpx_memset(denoiser->yv12_running_avg[i].buffer_alloc, 0, denoiser->yv12_running_avg[i].frame_size); } denoiser->yv12_mc_running_avg.flags = 0; if (vp8_yv12_alloc_frame_buffer(&(denoiser->yv12_mc_running_avg), width, height, VP8BORDERINPIXELS) < 0) { vp8_denoiser_free(denoiser); return 1; } vpx_memset(denoiser->yv12_mc_running_avg.buffer_alloc, 0, denoiser->yv12_mc_running_avg.frame_size); return 0; } void vp8_denoiser_free(VP8_DENOISER *denoiser) { int i; assert(denoiser); /* we don't have one for intra ref frame */ for (i = 1; i < MAX_REF_FRAMES ; i++) { vp8_yv12_de_alloc_frame_buffer(&denoiser->yv12_running_avg[i]); } vp8_yv12_de_alloc_frame_buffer(&denoiser->yv12_mc_running_avg); } void vp8_denoiser_denoise_mb(VP8_DENOISER *denoiser, MACROBLOCK *x, unsigned int best_sse, unsigned int zero_mv_sse, int recon_yoffset, int recon_uvoffset) { int mv_row; int mv_col; unsigned int motion_magnitude2; MV_REFERENCE_FRAME frame = x->best_reference_frame; MV_REFERENCE_FRAME zero_frame = x->best_zeromv_reference_frame; enum vp8_denoiser_decision decision = FILTER_BLOCK; if (zero_frame) { YV12_BUFFER_CONFIG *src = &denoiser->yv12_running_avg[frame]; YV12_BUFFER_CONFIG *dst = &denoiser->yv12_mc_running_avg; YV12_BUFFER_CONFIG saved_pre,saved_dst; MB_MODE_INFO saved_mbmi; MACROBLOCKD *filter_xd = &x->e_mbd; MB_MODE_INFO *mbmi = &filter_xd->mode_info_context->mbmi; int mv_col; int mv_row; int sse_diff = zero_mv_sse - best_sse; saved_mbmi = *mbmi; /* Use the best MV for the compensation. */ mbmi->ref_frame = x->best_reference_frame; mbmi->mode = x->best_sse_inter_mode; mbmi->mv = x->best_sse_mv; mbmi->need_to_clamp_mvs = x->need_to_clamp_best_mvs; mv_col = x->best_sse_mv.as_mv.col; mv_row = x->best_sse_mv.as_mv.row; if (frame == INTRA_FRAME || (mv_row *mv_row + mv_col *mv_col <= NOISE_MOTION_THRESHOLD && sse_diff < SSE_DIFF_THRESHOLD)) { /* * Handle intra blocks as referring to last frame with zero motion * and let the absolute pixel difference affect the filter factor. * Also consider small amount of motion as being random walk due * to noise, if it doesn't mean that we get a much bigger error. * Note that any changes to the mode info only affects the * denoising. */ mbmi->ref_frame = x->best_zeromv_reference_frame; src = &denoiser->yv12_running_avg[zero_frame]; mbmi->mode = ZEROMV; mbmi->mv.as_int = 0; x->best_sse_inter_mode = ZEROMV; x->best_sse_mv.as_int = 0; best_sse = zero_mv_sse; } saved_pre = filter_xd->pre; saved_dst = filter_xd->dst; /* Compensate the running average. */ filter_xd->pre.y_buffer = src->y_buffer + recon_yoffset; filter_xd->pre.u_buffer = src->u_buffer + recon_uvoffset; filter_xd->pre.v_buffer = src->v_buffer + recon_uvoffset; /* Write the compensated running average to the destination buffer. */ filter_xd->dst.y_buffer = dst->y_buffer + recon_yoffset; filter_xd->dst.u_buffer = dst->u_buffer + recon_uvoffset; filter_xd->dst.v_buffer = dst->v_buffer + recon_uvoffset; if (!x->skip) { vp8_build_inter_predictors_mb(filter_xd); } else { vp8_build_inter16x16_predictors_mb(filter_xd, filter_xd->dst.y_buffer, filter_xd->dst.u_buffer, filter_xd->dst.v_buffer, filter_xd->dst.y_stride, filter_xd->dst.uv_stride); } filter_xd->pre = saved_pre; filter_xd->dst = saved_dst; *mbmi = saved_mbmi; } mv_row = x->best_sse_mv.as_mv.row; mv_col = x->best_sse_mv.as_mv.col; motion_magnitude2 = mv_row * mv_row + mv_col * mv_col; if (best_sse > SSE_THRESHOLD || motion_magnitude2 > 8 * NOISE_MOTION_THRESHOLD) { decision = COPY_BLOCK; } if (decision == FILTER_BLOCK) { /* Filter. */ decision = vp8_denoiser_filter(&denoiser->yv12_mc_running_avg, &denoiser->yv12_running_avg[LAST_FRAME], x, motion_magnitude2, recon_yoffset, recon_uvoffset); } if (decision == COPY_BLOCK) { /* No filtering of this block; it differs too much from the predictor, * or the motion vector magnitude is considered too big. */ vp8_copy_mem16x16( x->thismb, 16, denoiser->yv12_running_avg[LAST_FRAME].y_buffer + recon_yoffset, denoiser->yv12_running_avg[LAST_FRAME].y_stride); } }