The Tor Browser: media/libvpx/vp8/encoder/picklpf.c@6474c204b198

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  */

    12 #include "./vpx_scale_rtcd.h"

    13 #include "vp8/common/onyxc_int.h"

    14 #include "onyx_int.h"

    15 #include "quantize.h"

    16 #include "vpx_mem/vpx_mem.h"

    17 #include "vpx_scale/vpx_scale.h"

    18 #include "vp8/common/alloccommon.h"

    19 #include "vp8/common/loopfilter.h"

    20 #if ARCH_ARM

    21 #include "vpx_ports/arm.h"

    22 #endif

    24 extern int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest);

    26 void vp8_yv12_copy_partial_frame_c(YV12_BUFFER_CONFIG *src_ybc,

    27                                    YV12_BUFFER_CONFIG *dst_ybc)

    28 {

    29     unsigned char *src_y, *dst_y;

    30     int yheight;

    31     int ystride;

    32     int yoffset;

    33     int linestocopy;

    35     yheight  = src_ybc->y_height;

    36     ystride  = src_ybc->y_stride;

    38     /* number of MB rows to use in partial filtering */

    39     linestocopy = (yheight >> 4) / PARTIAL_FRAME_FRACTION;

    40     linestocopy = linestocopy ? linestocopy << 4 : 16;     /* 16 lines per MB */

    42     /* Copy extra 4 so that full filter context is available if filtering done

    43      * on the copied partial frame and not original. Partial filter does mb

    44      * filtering for top row also, which can modify3 pixels above.

    45      */

    46     linestocopy += 4;

    47     /* partial image starts at ~middle of frame (macroblock border)*/

    48     yoffset  = ystride * (((yheight >> 5) * 16) - 4);

    49     src_y = src_ybc->y_buffer + yoffset;

    50     dst_y = dst_ybc->y_buffer + yoffset;

    52     vpx_memcpy(dst_y, src_y, ystride * linestocopy);

    53 }

    55 static int calc_partial_ssl_err(YV12_BUFFER_CONFIG *source,

    56                                 YV12_BUFFER_CONFIG *dest)

    57 {

    58     int i, j;

    59     int Total = 0;

    60     int srcoffset, dstoffset;

    61     unsigned char *src = source->y_buffer;

    62     unsigned char *dst = dest->y_buffer;

    64     int linestocopy;

    66     /* number of MB rows to use in partial filtering */

    67     linestocopy = (source->y_height >> 4) / PARTIAL_FRAME_FRACTION;

    68     linestocopy = linestocopy ? linestocopy << 4 : 16;     /* 16 lines per MB */

    71     /* partial image starts at ~middle of frame (macroblock border)*/

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

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

    75     src += srcoffset;

    76     dst += dstoffset;

    78     /* Loop through the Y plane raw and reconstruction data summing

    79      * (square differences)

    80      */

    81     for (i = 0; i < linestocopy; i += 16)

    82     {

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

    84         {

    85             unsigned int sse;

    86             Total += vp8_mse16x16(src + j, source->y_stride,

    87                                                      dst + j, dest->y_stride,

    88                                                      &sse);

    89         }

    91         src += 16 * source->y_stride;

    92         dst += 16 * dest->y_stride;

    93     }

    95     return Total;

    96 }

    98 /* Enforce a minimum filter level based upon baseline Q */

    99 static int get_min_filter_level(VP8_COMP *cpi, int base_qindex)

   100 {

   101     int min_filter_level;

   103     if (cpi->source_alt_ref_active && cpi->common.refresh_golden_frame &&

   104         !cpi->common.refresh_alt_ref_frame)

   105         min_filter_level = 0;

   106     else

   107     {

   108         if (base_qindex <= 6)

   109             min_filter_level = 0;

   110         else if (base_qindex <= 16)

   111             min_filter_level = 1;

   112         else

   113             min_filter_level = (base_qindex / 8);

   114     }

   116     return min_filter_level;

   117 }

   119 /* Enforce a maximum filter level based upon baseline Q */

   120 static int get_max_filter_level(VP8_COMP *cpi, int base_qindex)

   121 {

   122     /* PGW August 2006: Highest filter values almost always a bad idea */

   124     /* jbb chg: 20100118 - not so any more with this overquant stuff allow

   125      * high values with lots of intra coming in.

   126      */

   127     int max_filter_level = MAX_LOOP_FILTER;

   128     (void)base_qindex;

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

   131         max_filter_level = MAX_LOOP_FILTER * 3 / 4;

   133     return max_filter_level;

   134 }

   136 void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)

   137 {

   138     VP8_COMMON *cm = &cpi->common;

   140     int best_err = 0;

   141     int filt_err = 0;

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

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

   144     int filt_val;

   145     int best_filt_val = cm->filter_level;

   146     YV12_BUFFER_CONFIG * saved_frame = cm->frame_to_show;

   148     /* Replace unfiltered frame buffer with a new one */

   149     cm->frame_to_show = &cpi->pick_lf_lvl_frame;

   151     if (cm->frame_type == KEY_FRAME)

   152         cm->sharpness_level = 0;

   153     else

   154         cm->sharpness_level = cpi->oxcf.Sharpness;

   156     if (cm->sharpness_level != cm->last_sharpness_level)

   157     {

   158         vp8_loop_filter_update_sharpness(&cm->lf_info, cm->sharpness_level);

   159         cm->last_sharpness_level = cm->sharpness_level;

   160     }

   162     /* Start the search at the previous frame filter level unless it is

   163      * now out of range.

   164      */

   165     if (cm->filter_level < min_filter_level)

   166         cm->filter_level = min_filter_level;

   167     else if (cm->filter_level > max_filter_level)

   168         cm->filter_level = max_filter_level;

   170     filt_val = cm->filter_level;

   171     best_filt_val = filt_val;

   173     /* Get the err using the previous frame's filter value. */

   175     /* Copy the unfiltered / processed recon buffer to the new buffer */

   176     vp8_yv12_copy_partial_frame(saved_frame, cm->frame_to_show);

   177     vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);

   179     best_err = calc_partial_ssl_err(sd, cm->frame_to_show);

   181     filt_val -= 1 + (filt_val > 10);

   183     /* Search lower filter levels */

   184     while (filt_val >= min_filter_level)

   185     {

   186         /* Apply the loop filter */

   187         vp8_yv12_copy_partial_frame(saved_frame, cm->frame_to_show);

   188         vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);

   190         /* Get the err for filtered frame */

   191         filt_err = calc_partial_ssl_err(sd, cm->frame_to_show);

   193         /* Update the best case record or exit loop. */

   194         if (filt_err < best_err)

   195         {

   196             best_err = filt_err;

   197             best_filt_val = filt_val;

   198         }

   199         else

   200             break;

   202         /* Adjust filter level */

   203         filt_val -= 1 + (filt_val > 10);

   204     }

   206     /* Search up (note that we have already done filt_val = cm->filter_level) */

   207     filt_val = cm->filter_level + 1 + (filt_val > 10);

   209     if (best_filt_val == cm->filter_level)

   210     {

   211         /* Resist raising filter level for very small gains */

   212         best_err -= (best_err >> 10);

   214         while (filt_val < max_filter_level)

   215         {

   216             /* Apply the loop filter */

   217             vp8_yv12_copy_partial_frame(saved_frame, cm->frame_to_show);

   219             vp8_loop_filter_partial_frame(cm, &cpi->mb.e_mbd, filt_val);

   221             /* Get the err for filtered frame */

   222             filt_err = calc_partial_ssl_err(sd, cm->frame_to_show);

   224             /* Update the best case record or exit loop. */

   225             if (filt_err < best_err)

   226             {

   227                 /* Do not raise filter level if improvement is < 1 part

   228                  * in 4096

   229                  */

   230                 best_err = filt_err - (filt_err >> 10);

   232                 best_filt_val = filt_val;

   233             }

   234             else

   235                 break;

   237             /* Adjust filter level */

   238             filt_val += 1 + (filt_val > 10);

   239         }

   240     }

   242     cm->filter_level = best_filt_val;

   244     if (cm->filter_level < min_filter_level)

   245         cm->filter_level = min_filter_level;

   247     if (cm->filter_level > max_filter_level)

   248         cm->filter_level = max_filter_level;

   250     /* restore unfiltered frame pointer */

   251     cm->frame_to_show = saved_frame;

   252 }

   254 /* Stub function for now Alt LF not used */

   255 void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val)

   256 {

   257     MACROBLOCKD *mbd = &cpi->mb.e_mbd;

   258     (void) filt_val;

   260     mbd->segment_feature_data[MB_LVL_ALT_LF][0] = cpi->segment_feature_data[MB_LVL_ALT_LF][0];

   261     mbd->segment_feature_data[MB_LVL_ALT_LF][1] = cpi->segment_feature_data[MB_LVL_ALT_LF][1];

   262     mbd->segment_feature_data[MB_LVL_ALT_LF][2] = cpi->segment_feature_data[MB_LVL_ALT_LF][2];

   263     mbd->segment_feature_data[MB_LVL_ALT_LF][3] = cpi->segment_feature_data[MB_LVL_ALT_LF][3];

   264 }

   266 void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)

   267 {

   268     VP8_COMMON *cm = &cpi->common;

   270     int best_err = 0;

   271     int filt_err = 0;

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

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

   275     int filter_step;

   276     int filt_high = 0;

   277     /* Start search at previous frame filter level */

   278     int filt_mid = cm->filter_level;

   279     int filt_low = 0;

   280     int filt_best;

   281     int filt_direction = 0;

   283     /* Bias against raising loop filter and in favor of lowering it */

   284     int Bias = 0;

   286     int ss_err[MAX_LOOP_FILTER + 1];

   288     YV12_BUFFER_CONFIG * saved_frame = cm->frame_to_show;

   290     vpx_memset(ss_err, 0, sizeof(ss_err));

   292     /* Replace unfiltered frame buffer with a new one */

   293     cm->frame_to_show = &cpi->pick_lf_lvl_frame;

   295     if (cm->frame_type == KEY_FRAME)

   296         cm->sharpness_level = 0;

   297     else

   298         cm->sharpness_level = cpi->oxcf.Sharpness;

   300     /* Start the search at the previous frame filter level unless it is

   301      * now out of range.

   302      */

   303     filt_mid = cm->filter_level;

   305     if (filt_mid < min_filter_level)

   306         filt_mid = min_filter_level;

   307     else if (filt_mid > max_filter_level)

   308         filt_mid = max_filter_level;

   310     /* Define the initial step size */

   311     filter_step = (filt_mid < 16) ? 4 : filt_mid / 4;

   313     /* Get baseline error score */

   315     /* Copy the unfiltered / processed recon buffer to the new buffer */

   316     vpx_yv12_copy_y(saved_frame, cm->frame_to_show);

   318     vp8cx_set_alt_lf_level(cpi, filt_mid);

   319     vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_mid);

   321     best_err = vp8_calc_ss_err(sd, cm->frame_to_show);

   323     ss_err[filt_mid] = best_err;

   325     filt_best = filt_mid;

   327     while (filter_step > 0)

   328     {

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

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

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

   334         filt_high = ((filt_mid + filter_step) > max_filter_level) ? max_filter_level : (filt_mid + filter_step);

   335         filt_low = ((filt_mid - filter_step) < min_filter_level) ? min_filter_level : (filt_mid - filter_step);

   337         if ((filt_direction <= 0) && (filt_low != filt_mid))

   338         {

   339             if(ss_err[filt_low] == 0)

   340             {

   341                 /* Get Low filter error score */

   342                 vpx_yv12_copy_y(saved_frame, cm->frame_to_show);

   343                 vp8cx_set_alt_lf_level(cpi, filt_low);

   344                 vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_low);

   346                 filt_err = vp8_calc_ss_err(sd, cm->frame_to_show);

   347                 ss_err[filt_low] = filt_err;

   348             }

   349             else

   350                 filt_err = ss_err[filt_low];

   352             /* If value is close to the best so far then bias towards a

   353              * lower loop filter value.

   354              */

   355             if ((filt_err - Bias) < best_err)

   356             {

   357                 /* Was it actually better than the previous best? */

   358                 if (filt_err < best_err)

   359                     best_err = filt_err;

   361                 filt_best = filt_low;

   362             }

   363         }

   365         /* Now look at filt_high */

   366         if ((filt_direction >= 0) && (filt_high != filt_mid))

   367         {

   368             if(ss_err[filt_high] == 0)

   369             {

   370                 vpx_yv12_copy_y(saved_frame, cm->frame_to_show);

   371                 vp8cx_set_alt_lf_level(cpi, filt_high);

   372                 vp8_loop_filter_frame_yonly(cm, &cpi->mb.e_mbd, filt_high);

   374                 filt_err = vp8_calc_ss_err(sd, cm->frame_to_show);

   375                 ss_err[filt_high] = filt_err;

   376             }

   377             else

   378                 filt_err = ss_err[filt_high];

   380             /* Was it better than the previous best? */

   381             if (filt_err < (best_err - Bias))

   382             {

   383                 best_err = filt_err;

   384                 filt_best = filt_high;

   385             }

   386         }

   388         /* Half the step distance if the best filter value was the same

   389          * as last time

   390          */

   391         if (filt_best == filt_mid)

   392         {

   393             filter_step = filter_step / 2;

   394             filt_direction = 0;

   395         }

   396         else

   397         {

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

   399             filt_mid = filt_best;

   400         }

   401     }

   403     cm->filter_level = filt_best;

   405     /* restore unfiltered frame pointer */

   406     cm->frame_to_show = saved_frame;

   407 }

The Tor Browser / file revision

media/libvpx/vp8/encoder/picklpf.c@6474c204b198

media/libvpx/vp8/encoder/picklpf.c