libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_denoiser.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.
  */
 
 #include <assert.h>
 #include <limits.h>
 #include "vpx_scale/yv12config.h"
 #include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_reconinter.h"
+#include "vp9/encoder/vp9_context_tree.h"
 #include "vp9/encoder/vp9_denoiser.h"
 
 /* The VP9 denoiser is a work-in-progress. It currently is only designed to work
  * with speed 6, though it (inexplicably) seems to also work with speed 5 (one
  * would need to modify the source code in vp9_pickmode.c and vp9_encoder.c to
  * make the calls to the vp9_denoiser_* functions when in speed 5).
  *
  * The implementation is very similar to that of the VP8 denoiser. While
  * choosing the motion vectors / reference frames, the denoiser is run, and if
  * it did not modify the signal to much, the denoised block is copied to the
@@ skipping 150 matching lines @@
     dest += dest_stride;
     src += src_stride;
   }
 }
 
 static VP9_DENOISER_DECISION perform_motion_compensation(VP9_DENOISER *denoiser,
                                                          MACROBLOCK *mb,
                                                          BLOCK_SIZE bs,
                                                          int increase_denoising,
                                                          int mi_row,
-                                                         int mi_col) {
+                                                         int mi_col,
+                                                         PICK_MODE_CONTEXT *ctx
+                                                         ) {
   int mv_col, mv_row;
-  int sse_diff = denoiser->zero_mv_sse - denoiser->best_sse;
+  int sse_diff = ctx->zeromv_sse - ctx->newmv_sse;
   MV_REFERENCE_FRAME frame;
   MACROBLOCKD *filter_mbd = &mb->e_mbd;
   MB_MODE_INFO *mbmi = &filter_mbd->mi[0]->mbmi;
 
   MB_MODE_INFO saved_mbmi;
   int i, j;
   struct buf_2d saved_dst[MAX_MB_PLANE];
   struct buf_2d saved_pre[MAX_MB_PLANE][2];  // 2 pre buffers
 
   // We will restore these after motion compensation.
   saved_mbmi = *mbmi;
   for (i = 0; i < MAX_MB_PLANE; ++i) {
     for (j = 0; j < 2; ++j) {
       saved_pre[i][j] = filter_mbd->plane[i].pre[j];
     }
     saved_dst[i] = filter_mbd->plane[i].dst;
   }
 
-  mv_col = denoiser->best_sse_mv.as_mv.col;
-  mv_row = denoiser->best_sse_mv.as_mv.row;
+  mv_col = ctx->best_sse_mv.as_mv.col;
+  mv_row = ctx->best_sse_mv.as_mv.row;
 
-  frame = denoiser->best_reference_frame;
+  frame = ctx->best_reference_frame;
 
   // 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 &&
       sse_diff > sse_diff_thresh(bs, increase_denoising, mv_row, mv_col)) {
-    mbmi->ref_frame[0] = denoiser->best_reference_frame;
-    mbmi->mode = denoiser->best_sse_inter_mode;
-    mbmi->mv[0] = denoiser->best_sse_mv;
+    mbmi->ref_frame[0] = ctx->best_reference_frame;
+    mbmi->mode = ctx->best_sse_inter_mode;
+    mbmi->mv[0] = ctx->best_sse_mv;
   } else {
     // Otherwise, use the zero reference frame.
-    frame = denoiser->best_zeromv_reference_frame;
+    frame = ctx->best_zeromv_reference_frame;
 
-    mbmi->ref_frame[0] = denoiser->best_zeromv_reference_frame;
+    mbmi->ref_frame[0] = ctx->best_zeromv_reference_frame;
     mbmi->mode = ZEROMV;
     mbmi->mv[0].as_int = 0;
 
-    denoiser->best_sse_inter_mode = ZEROMV;
-    denoiser->best_sse_mv.as_int = 0;
-    denoiser->best_sse = denoiser->zero_mv_sse;
+    ctx->best_sse_inter_mode = ZEROMV;
+    ctx->best_sse_mv.as_int = 0;
+    ctx->newmv_sse = ctx->zeromv_sse;
   }
 
   // Set the pointers in the MACROBLOCKD to point to the buffers in the denoiser
   // struct.
   for (j = 0; j < 2; ++j) {
     filter_mbd->plane[0].pre[j].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[j].stride =
@@ skipping 31 matching lines @@
 
   // Restore everything to its original state
   *mbmi = saved_mbmi;
   for (i = 0; i < MAX_MB_PLANE; ++i) {
     for (j = 0; j < 2; ++j) {
       filter_mbd->plane[i].pre[j] = saved_pre[i][j];
     }
     filter_mbd->plane[i].dst = saved_dst[i];
   }
 
-  mv_row = denoiser->best_sse_mv.as_mv.row;
-  mv_col = denoiser->best_sse_mv.as_mv.col;
+  mv_row = ctx->best_sse_mv.as_mv.row;
+  mv_col = ctx->best_sse_mv.as_mv.col;
 
-  if (denoiser->best_sse > sse_thresh(bs, increase_denoising)) {
+  if (ctx->newmv_sse > sse_thresh(bs, increase_denoising)) {
     return COPY_BLOCK;
   }
   if (mv_row * mv_row + mv_col * mv_col >
       8 * noise_motion_thresh(bs, increase_denoising)) {
     return COPY_BLOCK;
   }
   return FILTER_BLOCK;
 }
 
 void vp9_denoiser_denoise(VP9_DENOISER *denoiser, MACROBLOCK *mb,
-                          int mi_row, int mi_col, BLOCK_SIZE bs) {
+                          int mi_row, int mi_col, BLOCK_SIZE bs,
+                          PICK_MODE_CONTEXT *ctx) {
   VP9_DENOISER_DECISION decision = FILTER_BLOCK;
   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);
   struct buf_2d src = mb->plane[0].src;
 
   decision = perform_motion_compensation(denoiser, mb, bs,
                                          denoiser->increase_denoising,
-                                         mi_row, mi_col);
+                                         mi_row, mi_col, ctx);
 
   if (decision == FILTER_BLOCK) {
     decision = denoiser_filter(src.buf, src.stride,
                                mc_avg_start, mc_avg.y_stride,
                                avg_start, avg.y_stride,
                                0, bs);
   }
 
   if (decision == FILTER_BLOCK) {
     copy_block(src.buf, src.stride, avg_start, avg.y_stride, bs);
@@ skipping 17 matching lines @@
 }
 
 void vp9_denoiser_update_frame_info(VP9_DENOISER *denoiser,
                                     YV12_BUFFER_CONFIG src,
                                     FRAME_TYPE frame_type,
                                     int refresh_alt_ref_frame,
                                     int refresh_golden_frame,
                                     int refresh_last_frame) {
   if (frame_type == KEY_FRAME) {
     int i;
-    copy_frame(denoiser->running_avg_y[LAST_FRAME], src);
-    for (i = 2; i < MAX_REF_FRAMES - 1; i++) {
-      copy_frame(denoiser->running_avg_y[i],
-                 denoiser->running_avg_y[LAST_FRAME]);
+    // Start at 1 so as not to overwrite the INTRA_FRAME
+    for (i = 1; i < MAX_REF_FRAMES; ++i) {
+      copy_frame(denoiser->running_avg_y[i], src);
     }
   } else {  /* For non key frames */
     if (refresh_alt_ref_frame) {
       copy_frame(denoiser->running_avg_y[ALTREF_FRAME],
                  denoiser->running_avg_y[INTRA_FRAME]);
     }
     if (refresh_golden_frame) {
       copy_frame(denoiser->running_avg_y[GOLDEN_FRAME],
                  denoiser->running_avg_y[INTRA_FRAME]);
     }
     if (refresh_last_frame) {
       copy_frame(denoiser->running_avg_y[LAST_FRAME],
                  denoiser->running_avg_y[INTRA_FRAME]);
     }
   }
 }
 
-void vp9_denoiser_reset_frame_stats(VP9_DENOISER *denoiser) {
-  denoiser->zero_mv_sse = UINT_MAX;
-  denoiser->best_sse = UINT_MAX;
+void vp9_denoiser_reset_frame_stats(PICK_MODE_CONTEXT *ctx) {
+  ctx->zeromv_sse = UINT_MAX;
+  ctx->newmv_sse = UINT_MAX;
 }
 
 void vp9_denoiser_update_frame_stats(VP9_DENOISER *denoiser, MB_MODE_INFO *mbmi,
-                                     unsigned int sse, PREDICTION_MODE mode) {
+                                     unsigned int sse, PREDICTION_MODE mode,
+                                     PICK_MODE_CONTEXT *ctx) {
   // TODO(tkopp): Use both MVs if possible
-  if (mbmi->mv[0].as_int == 0 && sse < denoiser->zero_mv_sse) {
-    denoiser->zero_mv_sse = sse;
-    denoiser->best_zeromv_reference_frame = mbmi->ref_frame[0];
+  if (mbmi->mv[0].as_int == 0 && sse < ctx->zeromv_sse) {
+    ctx->zeromv_sse = sse;
+    ctx->best_zeromv_reference_frame = mbmi->ref_frame[0];
   }
 
-  if (mbmi->mv[0].as_int != 0 && sse < denoiser->best_sse) {
-    denoiser->best_sse = sse;
-    denoiser->best_sse_inter_mode = mode;
-    denoiser->best_sse_mv = mbmi->mv[0];
-    denoiser->best_reference_frame = mbmi->ref_frame[0];
+  if (mode == NEWMV) {
+    ctx->newmv_sse = sse;
+    ctx->best_sse_inter_mode = mode;
+    ctx->best_sse_mv = mbmi->mv[0];
+    ctx->best_reference_frame = mbmi->ref_frame[0];
   }
 }
 
 int vp9_denoiser_alloc(VP9_DENOISER *denoiser, int width, int height,
                        int ssx, int ssy, int border) {
   int i, fail;
   assert(denoiser != NULL);
 
   for (i = 0; i < MAX_REF_FRAMES; ++i) {
     fail = vp9_alloc_frame_buffer(&denoiser->running_avg_y[i], width, height,
@@ skipping 47 matching lines @@
   for (r = 0; r < yuv->uv_height / 2; ++r) {
     for (c = 0; c < yuv->uv_width / 2; ++c) {
       u[c] = UINT8_MAX / 2;
       v[c] = UINT8_MAX / 2;
     }
     u += yuv->uv_stride + yuv->uv_width / 2;
     v += yuv->uv_stride + yuv->uv_width / 2;
   }
 }
 #endif