libvpx: Pull from upstream

source/libvpx/vp8/encoder/denoising.c

 /*
  *  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.
  */
 
@@ skipping 378 matching lines @@
 
 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,
                              loop_filter_info_n *lfi_n,
                              int mb_row,
                              int mb_col,
-                             int block_index)
+                             int block_index,
+                             int uv_denoise)
 {
     int mv_row;
     int mv_col;
     unsigned int motion_magnitude2;
     unsigned int sse_thresh;
     int sse_diff_thresh = 0;
-    // Denoise the UV channel.
-    int apply_color_denoise = 0;
     // Spatial loop filter: only applied selectively based on
     // temporal filter state of block relative to top/left neighbors.
     int apply_spatial_loop_filter = 1;
     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;
     enum vp8_denoiser_decision decision_u = FILTER_BLOCK;
     enum vp8_denoiser_decision decision_v = FILTER_BLOCK;
 
@@ skipping 104 matching lines @@
         int avg_y_stride = denoiser->yv12_running_avg[INTRA_FRAME].y_stride;
 
         /* Filter. */
         decision = vp8_denoiser_filter(mc_running_avg_y, mc_avg_y_stride,
                                        running_avg_y, avg_y_stride,
                                        x->thismb, 16, motion_magnitude2,
                                        x->increase_denoising);
         denoiser->denoise_state[block_index] = motion_magnitude2 > 0 ?
             kFilterNonZeroMV : kFilterZeroMV;
         // Only denoise UV for zero motion, and if y channel was denoised.
-        if (apply_color_denoise &&
+        if (uv_denoise &&
             motion_magnitude2 == 0 &&
             decision == FILTER_BLOCK) {
           unsigned char *mc_running_avg_u =
               denoiser->yv12_mc_running_avg.u_buffer + recon_uvoffset;
           unsigned char *running_avg_u =
               denoiser->yv12_running_avg[INTRA_FRAME].u_buffer + recon_uvoffset;
           unsigned char *mc_running_avg_v =
               denoiser->yv12_mc_running_avg.v_buffer + recon_uvoffset;
           unsigned char *running_avg_v =
               denoiser->yv12_running_avg[INTRA_FRAME].v_buffer + recon_uvoffset;
@@ skipping 16 matching lines @@
     {
         /* 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[INTRA_FRAME].y_buffer + recon_yoffset,
                 denoiser->yv12_running_avg[INTRA_FRAME].y_stride);
         denoiser->denoise_state[block_index] = kNoFilter;
     }
-    if (apply_color_denoise) {
+    if (uv_denoise) {
       if (decision_u == COPY_BLOCK) {
         vp8_copy_mem8x8(
             x->block[16].src + *x->block[16].base_src, x->block[16].src_stride,
             denoiser->yv12_running_avg[INTRA_FRAME].u_buffer + recon_uvoffset,
             denoiser->yv12_running_avg[INTRA_FRAME].uv_stride);
       }
       if (decision_v == COPY_BLOCK) {
         vp8_copy_mem8x8(
             x->block[20].src + *x->block[20].base_src, x->block[16].src_stride,
             denoiser->yv12_running_avg[INTRA_FRAME].v_buffer + recon_uvoffset,
@@ skipping 47 matching lines @@
       }
       if (apply_filter) {
         // Update the signal block |x|. Pixel changes are only to top and/or
         // left boundary pixels: can we avoid full block copy here.
         vp8_copy_mem16x16(
             denoiser->yv12_running_avg[INTRA_FRAME].y_buffer + recon_yoffset,
             y_stride, x->thismb, 16);
       }
     }
 }