Update libvpx sources to v0.9.2-35-ga8a38bc. ...

source/libvpx/vp8/decoder/decodframe.c

 /*
- *  Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
+ *  Copyright (c) 2010 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 "onyxd_int.h"
 #include "header.h"
 #include "reconintra.h"
 #include "reconintra4x4.h"
 #include "recon.h"
 #include "reconinter.h"
 #include "dequantize.h"
 #include "detokenize.h"
 #include "invtrans.h"
 #include "alloccommon.h"
 #include "entropymode.h"
 #include "quant_common.h"
+#include "vpx_scale/vpxscale.h"
+#include "vpx_scale/yv12extend.h"
+#include "setupintrarecon.h"
 
-#include "setupintrarecon.h"
-#include "demode.h"
 #include "decodemv.h"
 #include "extend.h"
 #include "vpx_mem/vpx_mem.h"
 #include "idct.h"
 #include "dequantize.h"
 #include "predictdc.h"
 #include "threading.h"
 #include "decoderthreading.h"
 #include "dboolhuff.h"
 
@@ skipping 20 matching lines @@
             r = (rc >> 2);
             c = (rc & 3);
 
             pc->Y1dequant[Q][r][c] = (short)vp8_ac_yquant(Q);
             pc->Y2dequant[Q][r][c] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
             pc->UVdequant[Q][r][c] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
         }
     }
 }
 
-static void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
+void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
 {
     int i;
     int QIndex;
     MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
     VP8_COMMON *const pc = & pbi->common;
 
     // Decide whether to use the default or alternate baseline Q value.
     if (xd->segmentation_enabled)
     {
         // Abs Value
@@ skipping 66 matching lines @@
 
     if (mv->row < (xd->mb_to_top_edge - (19 << 3)))
         mv->row = xd->mb_to_top_edge - (16 << 3);
     else if (mv->row > xd->mb_to_bottom_edge + (18 << 3))
         mv->row = xd->mb_to_bottom_edge + (16 << 3);
 }
 
 /* A version of the above function for chroma block MVs.*/
 static void clamp_uvmv_to_umv_border(MV *mv, const MACROBLOCKD *xd)
 {
-    if (2*mv->col < (xd->mb_to_left_edge - (19 << 3)))
-        mv->col = (xd->mb_to_left_edge - (16 << 3)) >> 1;
-    else if (2*mv->col > xd->mb_to_right_edge + (18 << 3))
-        mv->col = (xd->mb_to_right_edge + (16 << 3)) >> 1;
+    mv->col = (2*mv->col < (xd->mb_to_left_edge - (19 << 3))) ? (xd->mb_to_left_edge - (16 << 3)) >> 1 : mv->col;
+    mv->col = (2*mv->col > xd->mb_to_right_edge + (18 << 3)) ? (xd->mb_to_right_edge + (16 << 3)) >> 1 : mv->col;
 
-    if (2*mv->row < (xd->mb_to_top_edge - (19 << 3)))
-        mv->row = (xd->mb_to_top_edge - (16 << 3)) >> 1;
-    else if (2*mv->row > xd->mb_to_bottom_edge + (18 << 3))
-        mv->row = (xd->mb_to_bottom_edge + (16 << 3)) >> 1;
+    mv->row = (2*mv->row < (xd->mb_to_top_edge - (19 << 3))) ? (xd->mb_to_top_edge - (16 << 3)) >> 1 : mv->row;
+    mv->row = (2*mv->row > xd->mb_to_bottom_edge + (18 << 3)) ? (xd->mb_to_bottom_edge + (16 << 3)) >> 1 : mv->row;
 }
 
-static void clamp_mvs(MACROBLOCKD *xd)
+void clamp_mvs(MACROBLOCKD *xd)
 {
     if (xd->mode_info_context->mbmi.mode == SPLITMV)
     {
         int i;
 
         for (i=0; i<16; i++)
             clamp_mv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
         for (i=16; i<24; i++)
             clamp_uvmv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
     }
@@ skipping 115 matching lines @@
                          xd->predictor, xd->dst.y_buffer,
                          xd->dst.y_stride, xd->eobs);
     }
 
     DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block)
                     (xd->qcoeff+16*16, &xd->block[16].dequant[0][0],
                      xd->predictor+16*16, xd->dst.u_buffer, xd->dst.v_buffer,
                      xd->dst.uv_stride, xd->eobs+16);
 }
 
+
 static int get_delta_q(vp8_reader *bc, int prev, int *q_update)
 {
     int ret_val = 0;
 
     if (vp8_read_bit(bc))
     {
         ret_val = vp8_read_literal(bc, 4);
 
         if (vp8_read_bit(bc))
             ret_val = -ret_val;
@@ skipping 84 matching lines @@
         vp8_decode_macroblock(pbi, xd);
 
 
         recon_yoffset += 16;
         recon_uvoffset += 8;
 
         ++xd->mode_info_context;  /* next mb */
 
         xd->above_context++;
 
-        pbi->current_mb_col_main = mb_col;
     }
 
     // adjust to the next row of mbs
     vp8_extend_mb_row(
         &pc->yv12_fb[dst_fb_idx],
         xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8
     );
 
     ++xd->mode_info_context;      /* skip prediction column */
-
-    pbi->last_mb_row_decoded = mb_row;
 }
 
 
 static unsigned int read_partition_size(const unsigned char *cx_size)
 {
     const unsigned int size =
         cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
     return size;
 }
 
@@ skipping 171 matching lines @@
                                "Invalid frame sync code");
 
         pc->Width = (data[3] | (data[4] << 8)) & 0x3fff;
         pc->horiz_scale = data[4] >> 6;
         pc->Height = (data[5] | (data[6] << 8)) & 0x3fff;
         pc->vert_scale = data[6] >> 6;
         data += 7;
 
         if (Width != pc->Width  ||  Height != pc->Height)
         {
+            int prev_mb_rows = pc->mb_rows;
+
             if (pc->Width <= 0)
             {
                 pc->Width = Width;
                 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                    "Invalid frame width");
             }
 
             if (pc->Height <= 0)
             {
                 pc->Height = Height;
                 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                    "Invalid frame height");
             }
 
             if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
                 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                                    "Failed to allocate frame buffers");
+
+#if CONFIG_MULTITHREAD
+            if (pbi->b_multithreaded_rd)
+                vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
+#endif
         }
     }
 
     if (pc->Width == 0 || pc->Height == 0)
     {
         return -1;
     }
 
     init_frame(pbi);
 
@@ skipping 184 matching lines @@
                             *p = (vp8_prob)vp8_read_literal(bc, 8);
 
                         }
                     }
     }
 
     vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
     vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
 
     // set up frame new frame for intra coded blocks
-    vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
+    if (!(pbi->b_multithreaded_rd) || pc->multi_token_partition == ONE_PARTITION || !(pc->filter_level))
+        vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
 
     vp8_setup_block_dptrs(xd);
 
     vp8_build_block_doffsets(xd);
 
     // clear out the coeff buffer
     vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
 
     // Read the mb_no_coeff_skip flag
     pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);
 
-    if (pc->frame_type == KEY_FRAME)
-        vp8_kfread_modes(pbi);
-    else
-        vp8_decode_mode_mvs(pbi);
+
+    vp8_decode_mode_mvs(pbi);
 
     vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
 
     vpx_memcpy(&xd->block[0].bmi, &xd->mode_info_context->bmi[0], sizeof(B_MODE_INFO));
 
-
-    if (pbi->b_multithreaded_lf && pc->filter_level != 0)
-        vp8_start_lfthread(pbi);
-
     if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION)
     {
-        vp8_mtdecode_mb_rows(pbi, xd);
+        vp8mt_decode_mb_rows(pbi, xd);
+        if(pbi->common.filter_level)
+        {
+            //vp8_mt_loop_filter_frame(pbi);   //cm, &pbi->mb, cm->filter_level);
+
+            pc->last_frame_type = pc->frame_type;
+            pc->last_filter_type = pc->filter_type;
+            pc->last_sharpness_level = pc->sharpness_level;
+        }
+        vp8_yv12_extend_frame_borders_ptr(&pc->yv12_fb[pc->new_fb_idx]);    //cm->frame_to_show);
     }
     else
     {
         int ibc = 0;
         int num_part = 1 << pc->multi_token_partition;
 
         // Decode the individual macro block
         for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
         {
 
             if (num_part > 1)
             {
                 xd->current_bc = & pbi->mbc[ibc];
                 ibc++;
 
                 if (ibc == num_part)
                     ibc = 0;
             }
 
             vp8_decode_mb_row(pbi, pc, mb_row, xd);
         }
-
-        pbi->last_mb_row_decoded = mb_row;
     }
 
 
     stop_token_decoder(pbi);
 
     // vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes  \n",bc->pos+pbi->bc2.pos);
 
     // If this was a kf or Gf note the Q used
     if ((pc->frame_type == KEY_FRAME) ||
          pc->refresh_golden_frame || pc->refresh_alt_ref_frame)
@@ skipping 11 matching lines @@
         FILE *f = fopen("decompressor.VP8", "ab");
         unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8;
         fwrite((void *) &size, 4, 1, f);
         fwrite((void *) pbi->Source, size, 1, f);
         fclose(f);
     }
 #endif
 
     return 0;
 }