ffmpeg source update for sep 09

source/patched-ffmpeg-mt/libavcodec/vp8.c

 /**
  * VP8 compatible video decoder
  *
  * Copyright (C) 2010 David Conrad
  * Copyright (C) 2010 Ronald S. Bultje
  * Copyright (C) 2010 Jason Garrett-Glaser
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ skipping 69 matching lines @@
     /**
      * All coefficients are contained in separate arith coding contexts.
      * There can be 1, 2, 4, or 8 of these after the header context.
      */
     int num_coeff_partitions;
     VP56RangeCoder coeff_partition[8];
 
     VP8Macroblock *macroblocks;
     VP8Macroblock *macroblocks_base;
     VP8FilterStrength *filter_strength;
-    int mb_stride;
 
     uint8_t *intra4x4_pred_mode_top;
     uint8_t intra4x4_pred_mode_left[4];
     uint8_t *segmentation_map;
-    int b4_stride;
 
     /**
      * Cache of the top row needed for intra prediction
      * 16 for luma, 8 for each chroma plane
      */
     uint8_t (*top_border)[16+8+8];
 
     /**
      * For coeff decode, we need to know whether the above block had non-zero
      * coefficients. This means for each macroblock, we need data for 4 luma
@@ skipping 112 matching lines @@
     av_freep(&s->top_nnz);
     av_freep(&s->edge_emu_buffer);
     av_freep(&s->top_border);
     av_freep(&s->segmentation_map);
 
     s->macroblocks        = NULL;
 }
 
 static int update_dimensions(VP8Context *s, int width, int height)
 {
-    if (av_check_image_size(width, height, 0, s->avctx))
+    if (av_image_check_size(width, height, 0, s->avctx))
         return AVERROR_INVALIDDATA;
 
     vp8_decode_flush(s->avctx);
 
     avcodec_set_dimensions(s->avctx, width, height);
 
     s->mb_width  = (s->avctx->coded_width +15) / 16;
     s->mb_height = (s->avctx->coded_height+15) / 16;
 
-    // we allocate a border around the top/left of intra4x4 modes
-    // this is 4 blocks for intra4x4 to keep 4-byte alignment for fill_rectangle
-    s->mb_stride = s->mb_width+1;
-    s->b4_stride = 4*s->mb_stride;
-
-    s->macroblocks_base        = av_mallocz((s->mb_stride+s->mb_height*2+2)*sizeof(*s->macroblocks));
-    s->filter_strength         = av_mallocz(s->mb_stride*sizeof(*s->filter_strength));
-    s->intra4x4_pred_mode_top  = av_mallocz(s->b4_stride*4);
+    s->macroblocks_base        = av_mallocz((s->mb_width+s->mb_height*2+1)*sizeof(*s->macroblocks));
+    s->filter_strength         = av_mallocz(s->mb_width*sizeof(*s->filter_strength));
+    s->intra4x4_pred_mode_top  = av_mallocz(s->mb_width*4);
     s->top_nnz                 = av_mallocz(s->mb_width*sizeof(*s->top_nnz));
     s->top_border              = av_mallocz((s->mb_width+1)*sizeof(*s->top_border));
-    s->segmentation_map        = av_mallocz(s->mb_stride*s->mb_height);
+    s->segmentation_map        = av_mallocz(s->mb_width*s->mb_height);
 
     if (!s->macroblocks_base || !s->filter_strength || !s->intra4x4_pred_mode_top ||
         !s->top_nnz || !s->top_border || !s->segmentation_map)
         return AVERROR(ENOMEM);
 
     s->macroblocks        = s->macroblocks_base + 1;
 
     return 0;
 }
 
@@ skipping 269 matching lines @@
 void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src, int mb_x, int mb_y)
 {
 #define MARGIN (16 << 2)
     dst->x = av_clip(src->x, -((mb_x << 6) + MARGIN),
                      ((s->mb_width  - 1 - mb_x) << 6) + MARGIN);
     dst->y = av_clip(src->y, -((mb_y << 6) + MARGIN),
                      ((s->mb_height - 1 - mb_y) << 6) + MARGIN);
 }
 
 static av_always_inline
-void find_near_mvs(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
+void find_near_mvs(VP8Context *s, VP8Macroblock *mb,
                    VP56mv near[2], VP56mv *best, uint8_t cnt[4])
 {
     VP8Macroblock *mb_edge[3] = { mb + 2 /* top */,
                                   mb - 1 /* left */,
                                   mb + 1 /* top-left */ };
     enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
     VP56mv near_mv[4]  = {{ 0 }};
     enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
     int idx = CNT_ZERO;
     int best_idx = CNT_ZERO;
@@ skipping 211 matching lines @@
 
         // inter MB, 16.2
         if (vp56_rac_get_prob_branchy(c, s->prob->last))
             mb->ref_frame = vp56_rac_get_prob(c, s->prob->golden) ?
                 VP56_FRAME_GOLDEN2 /* altref */ : VP56_FRAME_GOLDEN;
         else
             mb->ref_frame = VP56_FRAME_PREVIOUS;
         s->ref_count[mb->ref_frame-1]++;
 
         // motion vectors, 16.3
-        find_near_mvs(s, mb, mb_x, mb_y, near, &best, cnt);
+        find_near_mvs(s, mb, near, &best, cnt);
         if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[0]][0])) {
             if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[1]][1])) {
                 if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[2]][2])) {
                     if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[3]][3])) {
                         mb->mode = VP8_MVMODE_SPLIT;
                         clamp_mv(s, &mb->mv, &mb->mv, mb_x, mb_y);
                         mb->mv = mb->bmv[decode_splitmvs(s, c, mb) - 1];
                     } else {
                         mb->mode = VP8_MVMODE_NEW;
                         clamp_mv(s, &mb->mv, &mb->mv, mb_x, mb_y);
-                        mb->mv.y += + read_mv_component(c, s->prob->mvc[0]);
-                        mb->mv.x += + read_mv_component(c, s->prob->mvc[1]);
+                        mb->mv.y += read_mv_component(c, s->prob->mvc[0]);
+                        mb->mv.x += read_mv_component(c, s->prob->mvc[1]);
                     }
                 } else {
                     mb->mode = VP8_MVMODE_NEAR;
                     clamp_mv(s, &mb->mv, &near[1], mb_x, mb_y);
                 }
             } else {
                 mb->mode = VP8_MVMODE_NEAREST;
                 clamp_mv(s, &mb->mv, &near[0], mb_x, mb_y);
             }
         } else {
@@ skipping 736 matching lines @@
     }
 
     s->linesize   = curframe->linesize[0];
     s->uvlinesize = curframe->linesize[1];
 
     if (!s->edge_emu_buffer)
         s->edge_emu_buffer = av_malloc(21*s->linesize);
 
     memset(s->top_nnz, 0, s->mb_width*sizeof(*s->top_nnz));
 
-    /* Zero macroblock structures for top/left prediction from outside the frame. */
-    memset(s->macroblocks, 0, (s->mb_width + s->mb_height*2)*sizeof(*s->macroblocks));
+    /* Zero macroblock structures for top/top-left prediction from outside the frame. */
+    memset(s->macroblocks + s->mb_height*2 - 1, 0, (s->mb_width+1)*sizeof(*s->macroblocks));
 
     // top edge of 127 for intra prediction
     memset(s->top_border, 127, (s->mb_width+1)*sizeof(*s->top_border));
     memset(s->ref_count, 0, sizeof(s->ref_count));
     if (s->keyframe)
-        memset(s->intra4x4_pred_mode_top, DC_PRED, s->b4_stride*4);
+        memset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width*4);
 
     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
         VP56RangeCoder *c = &s->coeff_partition[mb_y & (s->num_coeff_partitions-1)];
         VP8Macroblock *mb = s->macroblocks + (s->mb_height - mb_y - 1)*2;
-        uint8_t *segment_map = s->segmentation_map + mb_y*s->mb_stride;
-        int mb_xy = mb_y * s->mb_stride;
+        int mb_xy = mb_y*s->mb_width;
         uint8_t *dst[3] = {
             curframe->data[0] + 16*mb_y*s->linesize,
             curframe->data[1] +  8*mb_y*s->uvlinesize,
             curframe->data[2] +  8*mb_y*s->uvlinesize
         };
 
+        memset(mb - 1, 0, sizeof(*mb));   // zero left macroblock
         memset(s->left_nnz, 0, sizeof(s->left_nnz));
         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED*0x01010101);
 
         // left edge of 129 for intra prediction
         if (!(avctx->flags & CODEC_FLAG_EMU_EDGE))
             for (i = 0; i < 3; i++)
                 for (y = 0; y < 16>>!!i; y++)
                     dst[i][y*curframe->linesize[i]-1] = 129;
         if (mb_y)
             memset(s->top_border, 129, sizeof(*s->top_border));
 
         for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
-            uint8_t *segment_mb = segment_map+mb_x;
-
             /* Prefetch the current frame, 4 MBs ahead */
             s->dsp.prefetch(dst[0] + (mb_x&3)*4*s->linesize + 64, s->linesize, 4);
             s->dsp.prefetch(dst[1] + (mb_x&7)*s->uvlinesize + 64, dst[2] - dst[1], 2);
 
-            decode_mb_mode(s, mb, mb_x, mb_y, segment_mb);
+            decode_mb_mode(s, mb, mb_x, mb_y, s->segmentation_map + mb_xy);
 
             prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_PREVIOUS);
 
             if (!mb->skip)
                 decode_mb_coeffs(s, c, mb, s->top_nnz[mb_x], s->left_nnz);
 
             if (mb->mode <= MODE_I4x4)
                 intra_predict(s, dst, mb, mb_x, mb_y);
             else
                 inter_predict(s, dst, mb, mb_x, mb_y);
@@ skipping 100 matching lines @@
     CODEC_ID_VP8,
     sizeof(VP8Context),
     vp8_decode_init,
     NULL,
     vp8_decode_free,
     vp8_decode_frame,
     CODEC_CAP_DR1,
     .flush = vp8_decode_flush,
     .long_name = NULL_IF_CONFIG_SMALL("On2 VP8"),
 };