Update libvpx snapshot to v0.9.7-p1 (Cayuga).

source/libvpx/vp8/common/postproc.c

 /*
  *  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.
  */
 
@@ skipping 786 matching lines @@
         MODE_INFO *mi = oci->mi;
 
         y_ptr = post->y_buffer + 4 * post->y_stride + 4;
 
         /* vp8_filter each macro block */
         for (i = 0; i < mb_rows; i++)
         {
             for (j = 0; j < mb_cols; j++)
             {
                 char zz[4];
+                int dc_diff = !(mi[mb_index].mbmi.mode != B_PRED &&
+                              mi[mb_index].mbmi.mode != SPLITMV &&
+                              mi[mb_index].mbmi.mb_skip_coeff);
 
                 if (oci->frame_type == KEY_FRAME)
                     sprintf(zz, "a");
                 else
-                    sprintf(zz, "%c", mi[mb_index].mbmi.dc_diff + '0');
+                    sprintf(zz, "%c", dc_diff + '0');
 
                 vp8_blit_text(zz, y_ptr, post->y_stride);
                 mb_index ++;
                 y_ptr += 16;
             }
 
             mb_index ++; /* border */
             y_ptr += post->y_stride  * 16 - post->y_width;
 
         }
     }
 
     if (flags & VP8D_DEBUG_TXT_RATE_INFO)
     {
         char message[512];
         sprintf(message, "Bitrate: %10.2f frame_rate: %10.2f ", oci->bitrate, oci->framerate);
         vp8_blit_text(message, oci->post_proc_buffer.y_buffer, oci->post_proc_buffer.y_stride);
     }
 
     /* Draw motion vectors */
     if ((flags & VP8D_DEBUG_DRAW_MV) && ppflags->display_mv_flag)
     {
         YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer;
         int width  = post->y_width;
         int height = post->y_height;
-        int mb_cols = width  >> 4;
         unsigned char *y_buffer = oci->post_proc_buffer.y_buffer;
         int y_stride = oci->post_proc_buffer.y_stride;
         MODE_INFO *mi = oci->mi;
         int x0, y0;
 
         for (y0 = 0; y0 < height; y0 += 16)
         {
             for (x0 = 0; x0 < width; x0 += 16)
             {
                 int x1, y1;
 
                 if (!(ppflags->display_mv_flag & (1<<mi->mbmi.mode)))
                 {
                     mi++;
                     continue;
                 }
 
                 if (mi->mbmi.mode == SPLITMV)
                 {
                     switch (mi->mbmi.partitioning)
                     {
                         case 0 :    /* mv_top_bottom */
                         {
-                            B_MODE_INFO *bmi = &mi->bmi[0];
+                            union b_mode_info *bmi = &mi->bmi[0];
                             MV *mv = &bmi->mv.as_mv;
 
                             x1 = x0 + 8 + (mv->col >> 3);
                             y1 = y0 + 4 + (mv->row >> 3);
 
                             constrain_line (x0+8, &x1, y0+4, &y1, width, height);
                             vp8_blit_line  (x0+8,  x1, y0+4,  y1, y_buffer, y_stride);
 
                             bmi = &mi->bmi[8];
 
                             x1 = x0 + 8 + (mv->col >> 3);
                             y1 = y0 +12 + (mv->row >> 3);
 
                             constrain_line (x0+8, &x1, y0+12, &y1, width, height);
                             vp8_blit_line  (x0+8,  x1, y0+12,  y1, y_buffer, y_stride);
 
                             break;
                         }
                         case 1 :    /* mv_left_right */
                         {
-                            B_MODE_INFO *bmi = &mi->bmi[0];
+                            union b_mode_info *bmi = &mi->bmi[0];
                             MV *mv = &bmi->mv.as_mv;
 
                             x1 = x0 + 4 + (mv->col >> 3);
                             y1 = y0 + 8 + (mv->row >> 3);
 
                             constrain_line (x0+4, &x1, y0+8, &y1, width, height);
                             vp8_blit_line  (x0+4,  x1, y0+8,  y1, y_buffer, y_stride);
 
                             bmi = &mi->bmi[2];
 
                             x1 = x0 +12 + (mv->col >> 3);
                             y1 = y0 + 8 + (mv->row >> 3);
 
                             constrain_line (x0+12, &x1, y0+8, &y1, width, height);
                             vp8_blit_line  (x0+12,  x1, y0+8,  y1, y_buffer, y_stride);
 
                             break;
                         }
                         case 2 :    /* mv_quarters   */
                         {
-                            B_MODE_INFO *bmi = &mi->bmi[0];
+                            union b_mode_info *bmi = &mi->bmi[0];
                             MV *mv = &bmi->mv.as_mv;
 
                             x1 = x0 + 4 + (mv->col >> 3);
                             y1 = y0 + 4 + (mv->row >> 3);
 
                             constrain_line (x0+4, &x1, y0+4, &y1, width, height);
                             vp8_blit_line  (x0+4,  x1, y0+4,  y1, y_buffer, y_stride);
 
                             bmi = &mi->bmi[2];
 
@@ skipping 15 matching lines @@
 
                             x1 = x0 +12 + (mv->col >> 3);
                             y1 = y0 +12 + (mv->row >> 3);
 
                             constrain_line (x0+12, &x1, y0+12, &y1, width, height);
                             vp8_blit_line  (x0+12,  x1, y0+12,  y1, y_buffer, y_stride);
                             break;
                         }
                         default :
                         {
-                            B_MODE_INFO *bmi = mi->bmi;
+                            union b_mode_info *bmi = mi->bmi;
                             int bx0, by0;
 
                             for (by0 = y0; by0 < (y0+16); by0 += 4)
                             {
                                 for (bx0 = x0; bx0 < (x0+16); bx0 += 4)
                                 {
                                     MV *mv = &bmi->mv.as_mv;
 
                                     x1 = bx0 + 2 + (mv->col >> 3);
                                     y1 = by0 + 2 + (mv->row >> 3);
@@ skipping 52 matching lines @@
         {
             for (x = 0; x < width; x += 16)
             {
                 int Y = 0, U = 0, V = 0;
 
                 if (mi->mbmi.mode == B_PRED &&
                     ((ppflags->display_mb_modes_flag & B_PRED) || ppflags->display_b_modes_flag))
                 {
                     int by, bx;
                     unsigned char *yl, *ul, *vl;
-                    B_MODE_INFO *bmi = mi->bmi;
+                    union b_mode_info *bmi = mi->bmi;
 
                     yl = y_ptr + x;
                     ul = u_ptr + (x>>1);
                     vl = v_ptr + (x>>1);
 
                     for (by = 0; by < 16; by += 4)
                     {
                         for (bx = 0; bx < 16; bx += 4)
                         {
                             if ((ppflags->display_b_modes_flag & (1<<mi->mbmi.mode))
                                 || (ppflags->display_mb_modes_flag & B_PRED))
                             {
-                                Y = B_PREDICTION_MODE_colors[bmi->mode][0];
-                                U = B_PREDICTION_MODE_colors[bmi->mode][1];
-                                V = B_PREDICTION_MODE_colors[bmi->mode][2];
+                                Y = B_PREDICTION_MODE_colors[bmi->as_mode][0];
+                                U = B_PREDICTION_MODE_colors[bmi->as_mode][1];
+                                V = B_PREDICTION_MODE_colors[bmi->as_mode][2];
 
                                 POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_b)
                                     (yl+bx, ul+(bx>>1), vl+(bx>>1), Y, U, V, 0xc000, y_stride);
                             }
                             bmi++;
                         }
 
                         yl += y_stride*4;
                         ul += y_stride*1;
                         vl += y_stride*1;
@@ skipping 60 matching lines @@
 #endif
 
     *dest = oci->post_proc_buffer;
 
     /* handle problem with extending borders */
     dest->y_width = oci->Width;
     dest->y_height = oci->Height;
     dest->uv_height = dest->y_height / 2;
     return 0;
 }