The Tor Browser: media/libvpx/vp9/encoder/vp9

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /*

     2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.

     3  *

     4  *  Use of this source code is governed by a BSD-style license

     5  *  that can be found in the LICENSE file in the root of the source

     6  *  tree. An additional intellectual property rights grant can be found

     7  *  in the file PATENTS.  All contributing project authors may

     8  *  be found in the AUTHORS file in the root of the source tree.

     9  */

    11 #include <assert.h>

    12 #include <limits.h>

    13 #include "vp9/common/vp9_onyxc_int.h"

    14 #include "vp9/encoder/vp9_onyx_int.h"

    15 #include "vp9/encoder/vp9_picklpf.h"

    16 #include "vp9/encoder/vp9_quantize.h"

    17 #include "vpx_mem/vpx_mem.h"

    18 #include "vpx_scale/vpx_scale.h"

    19 #include "vp9/common/vp9_alloccommon.h"

    20 #include "vp9/common/vp9_loopfilter.h"

    21 #include "./vpx_scale_rtcd.h"

    23 void vp9_yv12_copy_partial_frame_c(YV12_BUFFER_CONFIG *src_ybc,

    24                                    YV12_BUFFER_CONFIG *dst_ybc, int fraction) {

    25   const int height = src_ybc->y_height;

    26   const int stride = src_ybc->y_stride;

    27   const int offset = stride * ((height >> 5) * 16 - 8);

    28   const int lines_to_copy = MAX(height >> (fraction + 4), 1) << 4;

    30   assert(src_ybc->y_stride == dst_ybc->y_stride);

    31   vpx_memcpy(dst_ybc->y_buffer + offset, src_ybc->y_buffer + offset,

    32              stride * (lines_to_copy + 16));

    33 }

    35 static int calc_partial_ssl_err(YV12_BUFFER_CONFIG *source,

    36                                 YV12_BUFFER_CONFIG *dest, int Fraction) {

    37   int i, j;

    38   int Total = 0;

    39   int srcoffset, dstoffset;

    40   uint8_t *src = source->y_buffer;

    41   uint8_t *dst = dest->y_buffer;

    43   int linestocopy = (source->y_height >> (Fraction + 4));

    45   if (linestocopy < 1)

    46     linestocopy = 1;

    48   linestocopy <<= 4;

    51   srcoffset = source->y_stride   * (dest->y_height >> 5) * 16;

    52   dstoffset = dest->y_stride     * (dest->y_height >> 5) * 16;

    54   src += srcoffset;

    55   dst += dstoffset;

    57   // Loop through the raw Y plane and reconstruction data summing the square

    58   // differences.

    59   for (i = 0; i < linestocopy; i += 16) {

    60     for (j = 0; j < source->y_width; j += 16) {

    61       unsigned int sse;

    62       Total += vp9_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride,

    63                             &sse);

    64     }

    66     src += 16 * source->y_stride;

    67     dst += 16 * dest->y_stride;

    68   }

    70   return Total;

    71 }

    73 // Enforce a minimum filter level based upon baseline Q

    74 static int get_min_filter_level(VP9_COMP *cpi, int base_qindex) {

    75   int min_filter_level;

    76   min_filter_level = 0;

    78   return min_filter_level;

    79 }

    81 // Enforce a maximum filter level based upon baseline Q

    82 static int get_max_filter_level(VP9_COMP *cpi, int base_qindex) {

    83   int max_filter_level = MAX_LOOP_FILTER;

    84   (void)base_qindex;

    86   if (cpi->twopass.section_intra_rating > 8)

    87     max_filter_level = MAX_LOOP_FILTER * 3 / 4;

    89   return max_filter_level;

    90 }

    93 // Stub function for now Alt LF not used

    94 void vp9_set_alt_lf_level(VP9_COMP *cpi, int filt_val) {

    95 }

    97 void vp9_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi, int partial) {

    98   VP9_COMMON *const cm = &cpi->common;

    99   struct loopfilter *const lf = &cm->lf;

   101   int best_err = 0;

   102   int filt_err = 0;

   103   const int min_filter_level = get_min_filter_level(cpi, cm->base_qindex);

   104   const int max_filter_level = get_max_filter_level(cpi, cm->base_qindex);

   106   int filter_step;

   107   int filt_high = 0;

   108   // Start search at previous frame filter level

   109   int filt_mid = lf->filter_level;

   110   int filt_low = 0;

   111   int filt_best;

   112   int filt_direction = 0;

   114   int Bias = 0;  // Bias against raising loop filter in favor of lowering it.

   116   //  Make a copy of the unfiltered / processed recon buffer

   117   vpx_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);

   119   lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0

   120                                                     : cpi->oxcf.Sharpness;

   122   // Start the search at the previous frame filter level unless it is now out of

   123   // range.

   124   filt_mid = clamp(lf->filter_level, min_filter_level, max_filter_level);

   126   // Define the initial step size

   127   filter_step = filt_mid < 16 ? 4 : filt_mid / 4;

   129   // Get baseline error score

   130   vp9_set_alt_lf_level(cpi, filt_mid);

   131   vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_mid, 1, partial);

   133   best_err = vp9_calc_ss_err(sd, cm->frame_to_show);

   134   filt_best = filt_mid;

   136   //  Re-instate the unfiltered frame

   137   vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);

   139   while (filter_step > 0) {

   140     Bias = (best_err >> (15 - (filt_mid / 8))) * filter_step;

   142     if (cpi->twopass.section_intra_rating < 20)

   143       Bias = Bias * cpi->twopass.section_intra_rating / 20;

   145     // yx, bias less for large block size

   146     if (cpi->common.tx_mode != ONLY_4X4)

   147       Bias >>= 1;

   149     filt_high = ((filt_mid + filter_step) > max_filter_level)

   150                     ? max_filter_level

   151                     : (filt_mid + filter_step);

   152     filt_low = ((filt_mid - filter_step) < min_filter_level)

   153                    ? min_filter_level

   154                    : (filt_mid - filter_step);

   156     if ((filt_direction <= 0) && (filt_low != filt_mid)) {

   157       // Get Low filter error score

   158       vp9_set_alt_lf_level(cpi, filt_low);

   159       vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_low, 1, partial);

   161       filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);

   163       //  Re-instate the unfiltered frame

   164       vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);

   166       // If value is close to the best so far then bias towards a lower loop

   167       // filter value.

   168       if ((filt_err - Bias) < best_err) {

   169         // Was it actually better than the previous best?

   170         if (filt_err < best_err)

   171           best_err = filt_err;

   173         filt_best = filt_low;

   174       }

   175     }

   177     // Now look at filt_high

   178     if ((filt_direction >= 0) && (filt_high != filt_mid)) {

   179       vp9_set_alt_lf_level(cpi, filt_high);

   180       vp9_loop_filter_frame(cm, &cpi->mb.e_mbd, filt_high, 1, partial);

   182       filt_err = vp9_calc_ss_err(sd, cm->frame_to_show);

   184       //  Re-instate the unfiltered frame

   185       vpx_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);

   187       // Was it better than the previous best?

   188       if (filt_err < (best_err - Bias)) {

   189         best_err = filt_err;

   190         filt_best = filt_high;

   191       }

   192     }

   194     // Half the step distance if the best filter value was the same as last time

   195     if (filt_best == filt_mid) {

   196       filter_step = filter_step / 2;

   197       filt_direction = 0;

   198     } else {

   199       filt_direction = (filt_best < filt_mid) ? -1 : 1;

   200       filt_mid = filt_best;

   201     }

   202   }

   204   lf->filter_level = filt_best;

   205 }

The Tor Browser / file revision