shithub: libvpx

Info  •  Files  •  Log  •  Branches

Fix test on maximum downscaling limits

There is a normative scaling range of (x1/2, x16)
for VP9. This patch fixes the maximum downscaling
tests that are applied in the convolve function.

The code used a maximum downscaling limit of x1/5
for historic reasons related to the scalable
coding work. Since the downsampling in this
application is non-normative it will revert to
using a separate non-normative scaler.

Change-Id: Ide80ed712cee82fe5cb3c55076ac428295a6019f

--- a/vp9/common/vp9_convolve.c

+++ b/vp9/common/vp9_convolve.c

@@ -117,17 +117,25 @@

                      const InterpKernel *const y_filters,

                      int y0_q4, int y_step_q4,

                      int w, int h) {

-  // Fixed size intermediate buffer places limits on parameters.

-  // Maximum intermediate_height is 324, for y_step_q4 == 80,

-  // h == 64, taps == 8.

-  // y_step_q4 of 80 allows for 1/10 scale for 5 layer svc

-  uint8_t temp[64 * 324];

+  // Note: Fixed size intermediate buffer, temp, places limits on parameters.

+  // 2d filtering proceeds in 2 steps:

+  //   (1) Interpolate horizontally into an intermediate buffer, temp.

+  //   (2) Interpolate temp vertically to derive the sub-pixel result.

+  // Deriving the maximum number of rows in the temp buffer (135):

+  // --Smallest scaling factor is x1/2 ==> y_step_q4 = 32 (Normative).

+  // --Largest block size is 64x64 pixels.

+  // --64 rows in the downscaled frame span a distance of (64 - 1) * 32 in the

+  //   original frame (in 1/16th pixel units).

+  // --Must round-up because block may be located at sub-pixel position.

+  // --Require an additional SUBPEL_TAPS rows for the 8-tap filter tails.

+  // --((64 - 1) * 32 + 15) >> 4 + 8 = 135.

+  uint8_t temp[135 * 64];

   int intermediate_height = (((h - 1) * y_step_q4 + 15) >> 4) + SUBPEL_TAPS;

   assert(w <= 64);

   assert(h <= 64);

-  assert(y_step_q4 <= 80);

-  assert(x_step_q4 <= 80);

+  assert(y_step_q4 <= 32);

+  assert(x_step_q4 <= 32);

   if (intermediate_height < h)

     intermediate_height = h;

--- a/vp9/encoder/vp9_encoder.c

+++ b/vp9/encoder/vp9_encoder.c

@@ -524,6 +524,7 @@

   vp9_change_config(cpi, oxcf);

   cpi->static_mb_pct = 0;

+  cpi->ref_frame_flags = 0;

   init_buffer_indices(cpi);

@@ -564,7 +565,6 @@

   cpi->pass = get_pass(cpi->oxcf.mode);

   rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;

-  cpi->ref_frame_flags = VP9_ALT_FLAG | VP9_GOLD_FLAG | VP9_LAST_FLAG;

   cpi->refresh_golden_frame = 0;

   cpi->refresh_last_frame = 1;

@@ -1571,12 +1571,15 @@

 void vp9_scale_references(VP9_COMP *cpi) {

   VP9_COMMON *cm = &cpi->common;

   MV_REFERENCE_FRAME ref_frame;

+  const VP9_REFFRAME ref_mask[3] = {VP9_LAST_FLAG, VP9_GOLD_FLAG, VP9_ALT_FLAG};

   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {

     const int idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)];

     const YV12_BUFFER_CONFIG *const ref = &cm->frame_bufs[idx].buf;

-    if (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height) {

+    // Need to convert from VP9_REFFRAME to index into ref_mask (subtract 1).

+    if ((cpi->ref_frame_flags & ref_mask[ref_frame - 1]) &&

+        (ref->y_crop_width != cm->width || ref->y_crop_height != cm->height)) {

       const int new_fb = get_free_fb(cm);

       vp9_realloc_frame_buffer(&cm->frame_bufs[new_fb].buf,

                                cm->width, cm->height,

-- 

⑨