libavcodec/vc1dec.c
Go to the documentation of this file.
00001 /*
00002  * VC-1 and WMV3 decoder
00003  * Copyright (c) 2011 Mashiat Sarker Shakkhar
00004  * Copyright (c) 2006-2007 Konstantin Shishkov
00005  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
00006  *
00007  * This file is part of Libav.
00008  *
00009  * Libav is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public
00011  * License as published by the Free Software Foundation; either
00012  * version 2.1 of the License, or (at your option) any later version.
00013  *
00014  * Libav is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with Libav; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00022  */
00023 
00029 #include "internal.h"
00030 #include "dsputil.h"
00031 #include "avcodec.h"
00032 #include "mpegvideo.h"
00033 #include "h263.h"
00034 #include "vc1.h"
00035 #include "vc1data.h"
00036 #include "vc1acdata.h"
00037 #include "msmpeg4data.h"
00038 #include "unary.h"
00039 #include "simple_idct.h"
00040 #include "mathops.h"
00041 #include "vdpau_internal.h"
00042 
00043 #undef NDEBUG
00044 #include <assert.h>
00045 
00046 #define MB_INTRA_VLC_BITS 9
00047 #define DC_VLC_BITS 9
00048 #define AC_VLC_BITS 9
00049 
00050 
00051 static const uint16_t vlc_offs[] = {
00052         0,   520,   552,   616,  1128,  1160,  1224,  1740,  1772,  1836,  1900,  2436,
00053      2986,  3050,  3610,  4154,  4218,  4746,  5326,  5390,  5902,  6554,  7658,  8342,
00054      9304,  9988, 10630, 11234, 12174, 13006, 13560, 14232, 14786, 15432, 16350, 17522,
00055     20372, 21818, 22330, 22394, 23166, 23678, 23742, 24820, 25332, 25396, 26460, 26980,
00056     27048, 27592, 27600, 27608, 27616, 27624, 28224, 28258, 28290, 28802, 28834, 28866,
00057     29378, 29412, 29444, 29960, 29994, 30026, 30538, 30572, 30604, 31120, 31154, 31186,
00058     31714, 31746, 31778, 32306, 32340, 32372
00059 };
00060 
00061 // offset tables for interlaced picture MVDATA decoding
00062 static const int offset_table1[9] = {  0,  1,  2,  4,  8, 16, 32,  64, 128 };
00063 static const int offset_table2[9] = {  0,  1,  3,  7, 15, 31, 63, 127, 255 };
00064 
00070 int ff_vc1_init_common(VC1Context *v)
00071 {
00072     static int done = 0;
00073     int i = 0;
00074     static VLC_TYPE vlc_table[32372][2];
00075 
00076     v->hrd_rate = v->hrd_buffer = NULL;
00077 
00078     /* VLC tables */
00079     if (!done) {
00080         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
00081                         ff_vc1_bfraction_bits, 1, 1,
00082                         ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
00083         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
00084                         ff_vc1_norm2_bits, 1, 1,
00085                         ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
00086         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
00087                         ff_vc1_norm6_bits, 1, 1,
00088                         ff_vc1_norm6_codes, 2, 2, 556);
00089         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
00090                         ff_vc1_imode_bits, 1, 1,
00091                         ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
00092         for (i = 0; i < 3; i++) {
00093             ff_vc1_ttmb_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 0]];
00094             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i * 3 + 1] - vlc_offs[i * 3 + 0];
00095             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
00096                      ff_vc1_ttmb_bits[i], 1, 1,
00097                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00098             ff_vc1_ttblk_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 1]];
00099             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i * 3 + 2] - vlc_offs[i * 3 + 1];
00100             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
00101                      ff_vc1_ttblk_bits[i], 1, 1,
00102                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00103             ff_vc1_subblkpat_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 2]];
00104             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i * 3 + 3] - vlc_offs[i * 3 + 2];
00105             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
00106                      ff_vc1_subblkpat_bits[i], 1, 1,
00107                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00108         }
00109         for (i = 0; i < 4; i++) {
00110             ff_vc1_4mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 9]];
00111             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i * 3 + 10] - vlc_offs[i * 3 + 9];
00112             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
00113                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
00114                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00115             ff_vc1_cbpcy_p_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 10]];
00116             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i * 3 + 11] - vlc_offs[i * 3 + 10];
00117             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
00118                      ff_vc1_cbpcy_p_bits[i], 1, 1,
00119                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00120             ff_vc1_mv_diff_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 11]];
00121             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i * 3 + 12] - vlc_offs[i * 3 + 11];
00122             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
00123                      ff_vc1_mv_diff_bits[i], 1, 1,
00124                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00125         }
00126         for (i = 0; i < 8; i++) {
00127             ff_vc1_ac_coeff_table[i].table           = &vlc_table[vlc_offs[i * 2 + 21]];
00128             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i * 2 + 22] - vlc_offs[i * 2 + 21];
00129             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
00130                      &vc1_ac_tables[i][0][1], 8, 4,
00131                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
00132             /* initialize interlaced MVDATA tables (2-Ref) */
00133             ff_vc1_2ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 2 + 22]];
00134             ff_vc1_2ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 2 + 23] - vlc_offs[i * 2 + 22];
00135             init_vlc(&ff_vc1_2ref_mvdata_vlc[i], VC1_2REF_MVDATA_VLC_BITS, 126,
00136                      ff_vc1_2ref_mvdata_bits[i], 1, 1,
00137                      ff_vc1_2ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
00138         }
00139         for (i = 0; i < 4; i++) {
00140             /* initialize 4MV MBMODE VLC tables for interlaced frame P picture */
00141             ff_vc1_intfr_4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 37]];
00142             ff_vc1_intfr_4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 38] - vlc_offs[i * 3 + 37];
00143             init_vlc(&ff_vc1_intfr_4mv_mbmode_vlc[i], VC1_INTFR_4MV_MBMODE_VLC_BITS, 15,
00144                      ff_vc1_intfr_4mv_mbmode_bits[i], 1, 1,
00145                      ff_vc1_intfr_4mv_mbmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00146             /* initialize NON-4MV MBMODE VLC tables for the same */
00147             ff_vc1_intfr_non4mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 38]];
00148             ff_vc1_intfr_non4mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 39] - vlc_offs[i * 3 + 38];
00149             init_vlc(&ff_vc1_intfr_non4mv_mbmode_vlc[i], VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 9,
00150                      ff_vc1_intfr_non4mv_mbmode_bits[i], 1, 1,
00151                      ff_vc1_intfr_non4mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00152             /* initialize interlaced MVDATA tables (1-Ref) */
00153             ff_vc1_1ref_mvdata_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 39]];
00154             ff_vc1_1ref_mvdata_vlc[i].table_allocated = vlc_offs[i * 3 + 40] - vlc_offs[i * 3 + 39];
00155             init_vlc(&ff_vc1_1ref_mvdata_vlc[i], VC1_1REF_MVDATA_VLC_BITS, 72,
00156                      ff_vc1_1ref_mvdata_bits[i], 1, 1,
00157                      ff_vc1_1ref_mvdata_codes[i], 4, 4, INIT_VLC_USE_NEW_STATIC);
00158         }
00159         for (i = 0; i < 4; i++) {
00160             /* Initialize 2MV Block pattern VLC tables */
00161             ff_vc1_2mv_block_pattern_vlc[i].table           = &vlc_table[vlc_offs[i + 49]];
00162             ff_vc1_2mv_block_pattern_vlc[i].table_allocated = vlc_offs[i + 50] - vlc_offs[i + 49];
00163             init_vlc(&ff_vc1_2mv_block_pattern_vlc[i], VC1_2MV_BLOCK_PATTERN_VLC_BITS, 4,
00164                      ff_vc1_2mv_block_pattern_bits[i], 1, 1,
00165                      ff_vc1_2mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00166         }
00167         for (i = 0; i < 8; i++) {
00168             /* Initialize interlaced CBPCY VLC tables (Table 124 - Table 131) */
00169             ff_vc1_icbpcy_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 53]];
00170             ff_vc1_icbpcy_vlc[i].table_allocated = vlc_offs[i * 3 + 54] - vlc_offs[i * 3 + 53];
00171             init_vlc(&ff_vc1_icbpcy_vlc[i], VC1_ICBPCY_VLC_BITS, 63,
00172                      ff_vc1_icbpcy_p_bits[i], 1, 1,
00173                      ff_vc1_icbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00174             /* Initialize interlaced field picture MBMODE VLC tables */
00175             ff_vc1_if_mmv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 54]];
00176             ff_vc1_if_mmv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 55] - vlc_offs[i * 3 + 54];
00177             init_vlc(&ff_vc1_if_mmv_mbmode_vlc[i], VC1_IF_MMV_MBMODE_VLC_BITS, 8,
00178                      ff_vc1_if_mmv_mbmode_bits[i], 1, 1,
00179                      ff_vc1_if_mmv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00180             ff_vc1_if_1mv_mbmode_vlc[i].table           = &vlc_table[vlc_offs[i * 3 + 55]];
00181             ff_vc1_if_1mv_mbmode_vlc[i].table_allocated = vlc_offs[i * 3 + 56] - vlc_offs[i * 3 + 55];
00182             init_vlc(&ff_vc1_if_1mv_mbmode_vlc[i], VC1_IF_1MV_MBMODE_VLC_BITS, 6,
00183                      ff_vc1_if_1mv_mbmode_bits[i], 1, 1,
00184                      ff_vc1_if_1mv_mbmode_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00185         }
00186         done = 1;
00187     }
00188 
00189     /* Other defaults */
00190     v->pq      = -1;
00191     v->mvrange = 0; /* 7.1.1.18, p80 */
00192 
00193     return 0;
00194 }
00195 
00196 /***********************************************************************/
00207 enum Imode {
00208     IMODE_RAW,
00209     IMODE_NORM2,
00210     IMODE_DIFF2,
00211     IMODE_NORM6,
00212     IMODE_DIFF6,
00213     IMODE_ROWSKIP,
00214     IMODE_COLSKIP
00215 }; //imode defines
00217 
00218  //Bitplane group
00220 
00221 static void vc1_put_signed_blocks_clamped(VC1Context *v)
00222 {
00223     MpegEncContext *s = &v->s;
00224     int topleft_mb_pos, top_mb_pos;
00225     int stride_y, fieldtx;
00226     int v_dist;
00227 
00228     /* The put pixels loop is always one MB row behind the decoding loop,
00229      * because we can only put pixels when overlap filtering is done, and
00230      * for filtering of the bottom edge of a MB, we need the next MB row
00231      * present as well.
00232      * Within the row, the put pixels loop is also one MB col behind the
00233      * decoding loop. The reason for this is again, because for filtering
00234      * of the right MB edge, we need the next MB present. */
00235     if (!s->first_slice_line) {
00236         if (s->mb_x) {
00237             topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
00238             fieldtx        = v->fieldtx_plane[topleft_mb_pos];
00239             stride_y       = s->linesize << fieldtx;
00240             v_dist         = (16 - fieldtx) >> (fieldtx == 0);
00241             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
00242                                              s->dest[0] - 16 * s->linesize - 16,
00243                                              stride_y);
00244             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
00245                                              s->dest[0] - 16 * s->linesize - 8,
00246                                              stride_y);
00247             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
00248                                              s->dest[0] - v_dist * s->linesize - 16,
00249                                              stride_y);
00250             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
00251                                              s->dest[0] - v_dist * s->linesize - 8,
00252                                              stride_y);
00253             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
00254                                              s->dest[1] - 8 * s->uvlinesize - 8,
00255                                              s->uvlinesize);
00256             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
00257                                              s->dest[2] - 8 * s->uvlinesize - 8,
00258                                              s->uvlinesize);
00259         }
00260         if (s->mb_x == s->mb_width - 1) {
00261             top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
00262             fieldtx    = v->fieldtx_plane[top_mb_pos];
00263             stride_y   = s->linesize << fieldtx;
00264             v_dist     = fieldtx ? 15 : 8;
00265             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
00266                                              s->dest[0] - 16 * s->linesize,
00267                                              stride_y);
00268             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
00269                                              s->dest[0] - 16 * s->linesize + 8,
00270                                              stride_y);
00271             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
00272                                              s->dest[0] - v_dist * s->linesize,
00273                                              stride_y);
00274             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
00275                                              s->dest[0] - v_dist * s->linesize + 8,
00276                                              stride_y);
00277             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
00278                                              s->dest[1] - 8 * s->uvlinesize,
00279                                              s->uvlinesize);
00280             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
00281                                              s->dest[2] - 8 * s->uvlinesize,
00282                                              s->uvlinesize);
00283         }
00284     }
00285 
00286 #define inc_blk_idx(idx) do { \
00287         idx++; \
00288         if (idx >= v->n_allocated_blks) \
00289             idx = 0; \
00290     } while (0)
00291 
00292     inc_blk_idx(v->topleft_blk_idx);
00293     inc_blk_idx(v->top_blk_idx);
00294     inc_blk_idx(v->left_blk_idx);
00295     inc_blk_idx(v->cur_blk_idx);
00296 }
00297 
00298 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
00299 {
00300     MpegEncContext *s = &v->s;
00301     int j;
00302     if (!s->first_slice_line) {
00303         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
00304         if (s->mb_x)
00305             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00306         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
00307         for (j = 0; j < 2; j++) {
00308             v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
00309             if (s->mb_x)
00310                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00311         }
00312     }
00313     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
00314 
00315     if (s->mb_y == s->end_mb_y - 1) {
00316         if (s->mb_x) {
00317             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
00318             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
00319             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
00320         }
00321         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
00322     }
00323 }
00324 
00325 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
00326 {
00327     MpegEncContext *s = &v->s;
00328     int j;
00329 
00330     /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
00331      * means it runs two rows/cols behind the decoding loop. */
00332     if (!s->first_slice_line) {
00333         if (s->mb_x) {
00334             if (s->mb_y >= s->start_mb_y + 2) {
00335                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00336 
00337                 if (s->mb_x >= 2)
00338                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
00339                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
00340                 for (j = 0; j < 2; j++) {
00341                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00342                     if (s->mb_x >= 2) {
00343                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
00344                     }
00345                 }
00346             }
00347             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
00348         }
00349 
00350         if (s->mb_x == s->mb_width - 1) {
00351             if (s->mb_y >= s->start_mb_y + 2) {
00352                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00353 
00354                 if (s->mb_x)
00355                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
00356                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
00357                 for (j = 0; j < 2; j++) {
00358                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00359                     if (s->mb_x >= 2) {
00360                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
00361                     }
00362                 }
00363             }
00364             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
00365         }
00366 
00367         if (s->mb_y == s->end_mb_y) {
00368             if (s->mb_x) {
00369                 if (s->mb_x >= 2)
00370                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00371                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
00372                 if (s->mb_x >= 2) {
00373                     for (j = 0; j < 2; j++) {
00374                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00375                     }
00376                 }
00377             }
00378 
00379             if (s->mb_x == s->mb_width - 1) {
00380                 if (s->mb_x)
00381                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00382                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
00383                 if (s->mb_x) {
00384                     for (j = 0; j < 2; j++) {
00385                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00386                     }
00387                 }
00388             }
00389         }
00390     }
00391 }
00392 
00393 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
00394 {
00395     MpegEncContext *s = &v->s;
00396     int mb_pos;
00397 
00398     if (v->condover == CONDOVER_NONE)
00399         return;
00400 
00401     mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00402 
00403     /* Within a MB, the horizontal overlap always runs before the vertical.
00404      * To accomplish that, we run the H on left and internal borders of the
00405      * currently decoded MB. Then, we wait for the next overlap iteration
00406      * to do H overlap on the right edge of this MB, before moving over and
00407      * running the V overlap. Therefore, the V overlap makes us trail by one
00408      * MB col and the H overlap filter makes us trail by one MB row. This
00409      * is reflected in the time at which we run the put_pixels loop. */
00410     if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
00411         if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00412                         v->over_flags_plane[mb_pos - 1])) {
00413             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
00414                                       v->block[v->cur_blk_idx][0]);
00415             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
00416                                       v->block[v->cur_blk_idx][2]);
00417             if (!(s->flags & CODEC_FLAG_GRAY)) {
00418                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
00419                                           v->block[v->cur_blk_idx][4]);
00420                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
00421                                           v->block[v->cur_blk_idx][5]);
00422             }
00423         }
00424         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
00425                                   v->block[v->cur_blk_idx][1]);
00426         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
00427                                   v->block[v->cur_blk_idx][3]);
00428 
00429         if (s->mb_x == s->mb_width - 1) {
00430             if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00431                                          v->over_flags_plane[mb_pos - s->mb_stride])) {
00432                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
00433                                           v->block[v->cur_blk_idx][0]);
00434                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
00435                                           v->block[v->cur_blk_idx][1]);
00436                 if (!(s->flags & CODEC_FLAG_GRAY)) {
00437                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
00438                                               v->block[v->cur_blk_idx][4]);
00439                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
00440                                               v->block[v->cur_blk_idx][5]);
00441                 }
00442             }
00443             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
00444                                       v->block[v->cur_blk_idx][2]);
00445             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
00446                                       v->block[v->cur_blk_idx][3]);
00447         }
00448     }
00449     if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
00450         if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00451                                      v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
00452             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
00453                                       v->block[v->left_blk_idx][0]);
00454             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
00455                                       v->block[v->left_blk_idx][1]);
00456             if (!(s->flags & CODEC_FLAG_GRAY)) {
00457                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
00458                                           v->block[v->left_blk_idx][4]);
00459                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
00460                                           v->block[v->left_blk_idx][5]);
00461             }
00462         }
00463         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
00464                                   v->block[v->left_blk_idx][2]);
00465         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
00466                                   v->block[v->left_blk_idx][3]);
00467     }
00468 }
00469 
00473 static void vc1_mc_1mv(VC1Context *v, int dir)
00474 {
00475     MpegEncContext *s = &v->s;
00476     DSPContext *dsp   = &v->s.dsp;
00477     uint8_t *srcY, *srcU, *srcV;
00478     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00479     int off, off_uv;
00480     int v_edge_pos = s->v_edge_pos >> v->field_mode;
00481 
00482     if ((!v->field_mode ||
00483          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
00484         !v->s.last_picture.f.data[0])
00485         return;
00486 
00487     mx = s->mv[dir][0][0];
00488     my = s->mv[dir][0][1];
00489 
00490     // store motion vectors for further use in B frames
00491     if (s->pict_type == AV_PICTURE_TYPE_P) {
00492         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
00493         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
00494     }
00495 
00496     uvmx = (mx + ((mx & 3) == 3)) >> 1;
00497     uvmy = (my + ((my & 3) == 3)) >> 1;
00498     v->luma_mv[s->mb_x][0] = uvmx;
00499     v->luma_mv[s->mb_x][1] = uvmy;
00500 
00501     if (v->field_mode &&
00502         v->cur_field_type != v->ref_field_type[dir]) {
00503         my   = my   - 2 + 4 * v->cur_field_type;
00504         uvmy = uvmy - 2 + 4 * v->cur_field_type;
00505     }
00506 
00507     // fastuvmc shall be ignored for interlaced frame picture
00508     if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
00509         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
00510         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
00511     }
00512     if (v->field_mode) { // interlaced field picture
00513         if (!dir) {
00514             if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
00515                 srcY = s->current_picture.f.data[0];
00516                 srcU = s->current_picture.f.data[1];
00517                 srcV = s->current_picture.f.data[2];
00518             } else {
00519                 srcY = s->last_picture.f.data[0];
00520                 srcU = s->last_picture.f.data[1];
00521                 srcV = s->last_picture.f.data[2];
00522             }
00523         } else {
00524             srcY = s->next_picture.f.data[0];
00525             srcU = s->next_picture.f.data[1];
00526             srcV = s->next_picture.f.data[2];
00527         }
00528     } else {
00529         if (!dir) {
00530             srcY = s->last_picture.f.data[0];
00531             srcU = s->last_picture.f.data[1];
00532             srcV = s->last_picture.f.data[2];
00533         } else {
00534             srcY = s->next_picture.f.data[0];
00535             srcU = s->next_picture.f.data[1];
00536             srcV = s->next_picture.f.data[2];
00537         }
00538     }
00539 
00540     src_x   = s->mb_x * 16 + (mx   >> 2);
00541     src_y   = s->mb_y * 16 + (my   >> 2);
00542     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
00543     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
00544 
00545     if (v->profile != PROFILE_ADVANCED) {
00546         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
00547         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
00548         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
00549         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
00550     } else {
00551         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
00552         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
00553         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
00554         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
00555     }
00556 
00557     srcY += src_y   * s->linesize   + src_x;
00558     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00559     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00560 
00561     if (v->field_mode && v->ref_field_type[dir]) {
00562         srcY += s->current_picture_ptr->f.linesize[0];
00563         srcU += s->current_picture_ptr->f.linesize[1];
00564         srcV += s->current_picture_ptr->f.linesize[2];
00565     }
00566 
00567     /* for grayscale we should not try to read from unknown area */
00568     if (s->flags & CODEC_FLAG_GRAY) {
00569         srcU = s->edge_emu_buffer + 18 * s->linesize;
00570         srcV = s->edge_emu_buffer + 18 * s->linesize;
00571     }
00572 
00573     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00574         || s->h_edge_pos < 22 || v_edge_pos < 22
00575         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
00576         || (unsigned)(src_y - s->mspel) > v_edge_pos    - (my&3) - 16 - s->mspel * 3) {
00577         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
00578 
00579         srcY -= s->mspel * (1 + s->linesize);
00580         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
00581                                 17 + s->mspel * 2, 17 + s->mspel * 2,
00582                                 src_x - s->mspel, src_y - s->mspel,
00583                                 s->h_edge_pos, v_edge_pos);
00584         srcY = s->edge_emu_buffer;
00585         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
00586                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
00587         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
00588                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
00589         srcU = uvbuf;
00590         srcV = uvbuf + 16;
00591         /* if we deal with range reduction we need to scale source blocks */
00592         if (v->rangeredfrm) {
00593             int i, j;
00594             uint8_t *src, *src2;
00595 
00596             src = srcY;
00597             for (j = 0; j < 17 + s->mspel * 2; j++) {
00598                 for (i = 0; i < 17 + s->mspel * 2; i++)
00599                     src[i] = ((src[i] - 128) >> 1) + 128;
00600                 src += s->linesize;
00601             }
00602             src  = srcU;
00603             src2 = srcV;
00604             for (j = 0; j < 9; j++) {
00605                 for (i = 0; i < 9; i++) {
00606                     src[i]  = ((src[i]  - 128) >> 1) + 128;
00607                     src2[i] = ((src2[i] - 128) >> 1) + 128;
00608                 }
00609                 src  += s->uvlinesize;
00610                 src2 += s->uvlinesize;
00611             }
00612         }
00613         /* if we deal with intensity compensation we need to scale source blocks */
00614         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00615             int i, j;
00616             uint8_t *src, *src2;
00617 
00618             src = srcY;
00619             for (j = 0; j < 17 + s->mspel * 2; j++) {
00620                 for (i = 0; i < 17 + s->mspel * 2; i++)
00621                     src[i] = v->luty[src[i]];
00622                 src += s->linesize;
00623             }
00624             src  = srcU;
00625             src2 = srcV;
00626             for (j = 0; j < 9; j++) {
00627                 for (i = 0; i < 9; i++) {
00628                     src[i]  = v->lutuv[src[i]];
00629                     src2[i] = v->lutuv[src2[i]];
00630                 }
00631                 src  += s->uvlinesize;
00632                 src2 += s->uvlinesize;
00633             }
00634         }
00635         srcY += s->mspel * (1 + s->linesize);
00636     }
00637 
00638     if (v->field_mode && v->cur_field_type) {
00639         off    = s->current_picture_ptr->f.linesize[0];
00640         off_uv = s->current_picture_ptr->f.linesize[1];
00641     } else {
00642         off    = 0;
00643         off_uv = 0;
00644     }
00645     if (s->mspel) {
00646         dxy = ((my & 3) << 2) | (mx & 3);
00647         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
00648         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
00649         srcY += s->linesize * 8;
00650         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
00651         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00652     } else { // hpel mc - always used for luma
00653         dxy = (my & 2) | ((mx & 2) >> 1);
00654         if (!v->rnd)
00655             dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
00656         else
00657             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
00658     }
00659 
00660     if (s->flags & CODEC_FLAG_GRAY) return;
00661     /* Chroma MC always uses qpel bilinear */
00662     uvmx = (uvmx & 3) << 1;
00663     uvmy = (uvmy & 3) << 1;
00664     if (!v->rnd) {
00665         dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
00666         dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
00667     } else {
00668         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
00669         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
00670     }
00671 }
00672 
00673 static inline int median4(int a, int b, int c, int d)
00674 {
00675     if (a < b) {
00676         if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00677         else       return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00678     } else {
00679         if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00680         else       return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00681     }
00682 }
00683 
00686 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
00687 {
00688     MpegEncContext *s = &v->s;
00689     DSPContext *dsp = &v->s.dsp;
00690     uint8_t *srcY;
00691     int dxy, mx, my, src_x, src_y;
00692     int off;
00693     int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
00694     int v_edge_pos = s->v_edge_pos >> v->field_mode;
00695 
00696     if ((!v->field_mode ||
00697          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
00698         !v->s.last_picture.f.data[0])
00699         return;
00700 
00701     mx = s->mv[dir][n][0];
00702     my = s->mv[dir][n][1];
00703 
00704     if (!dir) {
00705         if (v->field_mode) {
00706             if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
00707                 srcY = s->current_picture.f.data[0];
00708             else
00709                 srcY = s->last_picture.f.data[0];
00710         } else
00711             srcY = s->last_picture.f.data[0];
00712     } else
00713         srcY = s->next_picture.f.data[0];
00714 
00715     if (v->field_mode) {
00716         if (v->cur_field_type != v->ref_field_type[dir])
00717             my = my - 2 + 4 * v->cur_field_type;
00718     }
00719 
00720     if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
00721         int same_count = 0, opp_count = 0, k;
00722         int chosen_mv[2][4][2], f;
00723         int tx, ty;
00724         for (k = 0; k < 4; k++) {
00725             f = v->mv_f[0][s->block_index[k] + v->blocks_off];
00726             chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
00727             chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
00728             opp_count  += f;
00729             same_count += 1 - f;
00730         }
00731         f = opp_count > same_count;
00732         switch (f ? opp_count : same_count) {
00733         case 4:
00734             tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
00735                          chosen_mv[f][2][0], chosen_mv[f][3][0]);
00736             ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
00737                          chosen_mv[f][2][1], chosen_mv[f][3][1]);
00738             break;
00739         case 3:
00740             tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
00741             ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
00742             break;
00743         case 2:
00744             tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
00745             ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
00746             break;
00747         }
00748         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
00749         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
00750         for (k = 0; k < 4; k++)
00751             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
00752     }
00753 
00754     if (v->fcm == ILACE_FRAME) {  // not sure if needed for other types of picture
00755         int qx, qy;
00756         int width  = s->avctx->coded_width;
00757         int height = s->avctx->coded_height >> 1;
00758         qx = (s->mb_x * 16) + (mx >> 2);
00759         qy = (s->mb_y *  8) + (my >> 3);
00760 
00761         if (qx < -17)
00762             mx -= 4 * (qx + 17);
00763         else if (qx > width)
00764             mx -= 4 * (qx - width);
00765         if (qy < -18)
00766             my -= 8 * (qy + 18);
00767         else if (qy > height + 1)
00768             my -= 8 * (qy - height - 1);
00769     }
00770 
00771     if ((v->fcm == ILACE_FRAME) && fieldmv)
00772         off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
00773     else
00774         off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
00775     if (v->field_mode && v->cur_field_type)
00776         off += s->current_picture_ptr->f.linesize[0];
00777 
00778     src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
00779     if (!fieldmv)
00780         src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
00781     else
00782         src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
00783 
00784     if (v->profile != PROFILE_ADVANCED) {
00785         src_x = av_clip(src_x, -16, s->mb_width  * 16);
00786         src_y = av_clip(src_y, -16, s->mb_height * 16);
00787     } else {
00788         src_x = av_clip(src_x, -17, s->avctx->coded_width);
00789         if (v->fcm == ILACE_FRAME) {
00790             if (src_y & 1)
00791                 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
00792             else
00793                 src_y = av_clip(src_y, -18, s->avctx->coded_height);
00794         } else {
00795             src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
00796         }
00797     }
00798 
00799     srcY += src_y * s->linesize + src_x;
00800     if (v->field_mode && v->ref_field_type[dir])
00801         srcY += s->current_picture_ptr->f.linesize[0];
00802 
00803     if (fieldmv && !(src_y & 1))
00804         v_edge_pos--;
00805     if (fieldmv && (src_y & 1) && src_y < 4)
00806         src_y--;
00807     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00808         || s->h_edge_pos < 13 || v_edge_pos < 23
00809         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
00810         || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
00811         srcY -= s->mspel * (1 + (s->linesize << fieldmv));
00812         /* check emulate edge stride and offset */
00813         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
00814                                 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
00815                                 src_x - s->mspel, src_y - (s->mspel << fieldmv),
00816                                 s->h_edge_pos, v_edge_pos);
00817         srcY = s->edge_emu_buffer;
00818         /* if we deal with range reduction we need to scale source blocks */
00819         if (v->rangeredfrm) {
00820             int i, j;
00821             uint8_t *src;
00822 
00823             src = srcY;
00824             for (j = 0; j < 9 + s->mspel * 2; j++) {
00825                 for (i = 0; i < 9 + s->mspel * 2; i++)
00826                     src[i] = ((src[i] - 128) >> 1) + 128;
00827                 src += s->linesize << fieldmv;
00828             }
00829         }
00830         /* if we deal with intensity compensation we need to scale source blocks */
00831         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00832             int i, j;
00833             uint8_t *src;
00834 
00835             src = srcY;
00836             for (j = 0; j < 9 + s->mspel * 2; j++) {
00837                 for (i = 0; i < 9 + s->mspel * 2; i++)
00838                     src[i] = v->luty[src[i]];
00839                 src += s->linesize << fieldmv;
00840             }
00841         }
00842         srcY += s->mspel * (1 + (s->linesize << fieldmv));
00843     }
00844 
00845     if (s->mspel) {
00846         dxy = ((my & 3) << 2) | (mx & 3);
00847         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
00848     } else { // hpel mc - always used for luma
00849         dxy = (my & 2) | ((mx & 2) >> 1);
00850         if (!v->rnd)
00851             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00852         else
00853             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00854     }
00855 }
00856 
00857 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
00858 {
00859     int idx, i;
00860     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00861 
00862     idx =  ((a[3] != flag) << 3)
00863          | ((a[2] != flag) << 2)
00864          | ((a[1] != flag) << 1)
00865          |  (a[0] != flag);
00866     if (!idx) {
00867         *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00868         *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00869         return 4;
00870     } else if (count[idx] == 1) {
00871         switch (idx) {
00872         case 0x1:
00873             *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00874             *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00875             return 3;
00876         case 0x2:
00877             *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00878             *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00879             return 3;
00880         case 0x4:
00881             *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00882             *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00883             return 3;
00884         case 0x8:
00885             *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00886             *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00887             return 3;
00888         }
00889     } else if (count[idx] == 2) {
00890         int t1 = 0, t2 = 0;
00891         for (i = 0; i < 3; i++)
00892             if (!a[i]) {
00893                 t1 = i;
00894                 break;
00895             }
00896         for (i = t1 + 1; i < 4; i++)
00897             if (!a[i]) {
00898                 t2 = i;
00899                 break;
00900             }
00901         *tx = (mvx[t1] + mvx[t2]) / 2;
00902         *ty = (mvy[t1] + mvy[t2]) / 2;
00903         return 2;
00904     } else {
00905         return 0;
00906     }
00907     return -1;
00908 }
00909 
00912 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
00913 {
00914     MpegEncContext *s = &v->s;
00915     DSPContext *dsp   = &v->s.dsp;
00916     uint8_t *srcU, *srcV;
00917     int uvmx, uvmy, uvsrc_x, uvsrc_y;
00918     int k, tx = 0, ty = 0;
00919     int mvx[4], mvy[4], intra[4], mv_f[4];
00920     int valid_count;
00921     int chroma_ref_type = v->cur_field_type, off = 0;
00922     int v_edge_pos = s->v_edge_pos >> v->field_mode;
00923 
00924     if (!v->field_mode && !v->s.last_picture.f.data[0])
00925         return;
00926     if (s->flags & CODEC_FLAG_GRAY)
00927         return;
00928 
00929     for (k = 0; k < 4; k++) {
00930         mvx[k] = s->mv[dir][k][0];
00931         mvy[k] = s->mv[dir][k][1];
00932         intra[k] = v->mb_type[0][s->block_index[k]];
00933         if (v->field_mode)
00934             mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
00935     }
00936 
00937     /* calculate chroma MV vector from four luma MVs */
00938     if (!v->field_mode || (v->field_mode && !v->numref)) {
00939         valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
00940         if (!valid_count) {
00941             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
00942             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
00943             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
00944             return; //no need to do MC for intra blocks
00945         }
00946     } else {
00947         int dominant = 0;
00948         if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
00949             dominant = 1;
00950         valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
00951         if (dominant)
00952             chroma_ref_type = !v->cur_field_type;
00953     }
00954     if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
00955         return;
00956     s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
00957     s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
00958     uvmx = (tx + ((tx & 3) == 3)) >> 1;
00959     uvmy = (ty + ((ty & 3) == 3)) >> 1;
00960 
00961     v->luma_mv[s->mb_x][0] = uvmx;
00962     v->luma_mv[s->mb_x][1] = uvmy;
00963 
00964     if (v->fastuvmc) {
00965         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
00966         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
00967     }
00968     // Field conversion bias
00969     if (v->cur_field_type != chroma_ref_type)
00970         uvmy += 2 - 4 * chroma_ref_type;
00971 
00972     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00973     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00974 
00975     if (v->profile != PROFILE_ADVANCED) {
00976         uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width  * 8);
00977         uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
00978     } else {
00979         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
00980         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
00981     }
00982 
00983     if (!dir) {
00984         if (v->field_mode) {
00985             if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
00986                 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00987                 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00988             } else {
00989                 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00990                 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00991             }
00992         } else {
00993             srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00994             srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00995         }
00996     } else {
00997         srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00998         srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00999     }
01000 
01001     if (v->field_mode) {
01002         if (chroma_ref_type) {
01003             srcU += s->current_picture_ptr->f.linesize[1];
01004             srcV += s->current_picture_ptr->f.linesize[2];
01005         }
01006         off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
01007     }
01008 
01009     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
01010         || s->h_edge_pos < 18 || v_edge_pos < 18
01011         || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
01012         || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {
01013         s->dsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,
01014                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
01015                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
01016         s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
01017                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
01018                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
01019         srcU = s->edge_emu_buffer;
01020         srcV = s->edge_emu_buffer + 16;
01021 
01022         /* if we deal with range reduction we need to scale source blocks */
01023         if (v->rangeredfrm) {
01024             int i, j;
01025             uint8_t *src, *src2;
01026 
01027             src  = srcU;
01028             src2 = srcV;
01029             for (j = 0; j < 9; j++) {
01030                 for (i = 0; i < 9; i++) {
01031                     src[i]  = ((src[i]  - 128) >> 1) + 128;
01032                     src2[i] = ((src2[i] - 128) >> 1) + 128;
01033                 }
01034                 src  += s->uvlinesize;
01035                 src2 += s->uvlinesize;
01036             }
01037         }
01038         /* if we deal with intensity compensation we need to scale source blocks */
01039         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01040             int i, j;
01041             uint8_t *src, *src2;
01042 
01043             src  = srcU;
01044             src2 = srcV;
01045             for (j = 0; j < 9; j++) {
01046                 for (i = 0; i < 9; i++) {
01047                     src[i]  = v->lutuv[src[i]];
01048                     src2[i] = v->lutuv[src2[i]];
01049                 }
01050                 src  += s->uvlinesize;
01051                 src2 += s->uvlinesize;
01052             }
01053         }
01054     }
01055 
01056     /* Chroma MC always uses qpel bilinear */
01057     uvmx = (uvmx & 3) << 1;
01058     uvmy = (uvmy & 3) << 1;
01059     if (!v->rnd) {
01060         dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
01061         dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
01062     } else {
01063         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
01064         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
01065     }
01066 }
01067 
01070 static void vc1_mc_4mv_chroma4(VC1Context *v)
01071 {
01072     MpegEncContext *s = &v->s;
01073     DSPContext *dsp = &v->s.dsp;
01074     uint8_t *srcU, *srcV;
01075     int uvsrc_x, uvsrc_y;
01076     int uvmx_field[4], uvmy_field[4];
01077     int i, off, tx, ty;
01078     int fieldmv = v->blk_mv_type[s->block_index[0]];
01079     static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
01080     int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
01081     int v_edge_pos = s->v_edge_pos >> 1;
01082 
01083     if (!v->s.last_picture.f.data[0])
01084         return;
01085     if (s->flags & CODEC_FLAG_GRAY)
01086         return;
01087 
01088     for (i = 0; i < 4; i++) {
01089         tx = s->mv[0][i][0];
01090         uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
01091         ty = s->mv[0][i][1];
01092         if (fieldmv)
01093             uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
01094         else
01095             uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
01096     }
01097 
01098     for (i = 0; i < 4; i++) {
01099         off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
01100         uvsrc_x = s->mb_x * 8 +  (i & 1) * 4           + (uvmx_field[i] >> 2);
01101         uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
01102         // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
01103         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
01104         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
01105         srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
01106         srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
01107         uvmx_field[i] = (uvmx_field[i] & 3) << 1;
01108         uvmy_field[i] = (uvmy_field[i] & 3) << 1;
01109 
01110         if (fieldmv && !(uvsrc_y & 1))
01111             v_edge_pos--;
01112         if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
01113             uvsrc_y--;
01114         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
01115             || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
01116             || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
01117             || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
01118             s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
01119                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
01120                                     s->h_edge_pos >> 1, v_edge_pos);
01121             s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
01122                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
01123                                     s->h_edge_pos >> 1, v_edge_pos);
01124             srcU = s->edge_emu_buffer;
01125             srcV = s->edge_emu_buffer + 16;
01126 
01127             /* if we deal with intensity compensation we need to scale source blocks */
01128             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
01129                 int i, j;
01130                 uint8_t *src, *src2;
01131 
01132                 src  = srcU;
01133                 src2 = srcV;
01134                 for (j = 0; j < 5; j++) {
01135                     for (i = 0; i < 5; i++) {
01136                         src[i]  = v->lutuv[src[i]];
01137                         src2[i] = v->lutuv[src2[i]];
01138                     }
01139                     src  += s->uvlinesize << 1;
01140                     src2 += s->uvlinesize << 1;
01141                 }
01142             }
01143         }
01144         if (!v->rnd) {
01145             dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01146             dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01147         } else {
01148             v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01149             v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
01150         }
01151     }
01152 }
01153 
01154 /***********************************************************************/
01165 #define GET_MQUANT()                                           \
01166     if (v->dquantfrm) {                                        \
01167         int edges = 0;                                         \
01168         if (v->dqprofile == DQPROFILE_ALL_MBS) {               \
01169             if (v->dqbilevel) {                                \
01170                 mquant = (get_bits1(gb)) ? v->altpq : v->pq;   \
01171             } else {                                           \
01172                 mqdiff = get_bits(gb, 3);                      \
01173                 if (mqdiff != 7)                               \
01174                     mquant = v->pq + mqdiff;                   \
01175                 else                                           \
01176                     mquant = get_bits(gb, 5);                  \
01177             }                                                  \
01178         }                                                      \
01179         if (v->dqprofile == DQPROFILE_SINGLE_EDGE)             \
01180             edges = 1 << v->dqsbedge;                          \
01181         else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES)       \
01182             edges = (3 << v->dqsbedge) % 15;                   \
01183         else if (v->dqprofile == DQPROFILE_FOUR_EDGES)         \
01184             edges = 15;                                        \
01185         if ((edges&1) && !s->mb_x)                             \
01186             mquant = v->altpq;                                 \
01187         if ((edges&2) && s->first_slice_line)                  \
01188             mquant = v->altpq;                                 \
01189         if ((edges&4) && s->mb_x == (s->mb_width - 1))         \
01190             mquant = v->altpq;                                 \
01191         if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
01192             mquant = v->altpq;                                 \
01193     }
01194 
01202 #define GET_MVDATA(_dmv_x, _dmv_y)                                      \
01203     index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
01204                          VC1_MV_DIFF_VLC_BITS, 2);                      \
01205     if (index > 36) {                                                   \
01206         mb_has_coeffs = 1;                                              \
01207         index -= 37;                                                    \
01208     } else                                                              \
01209         mb_has_coeffs = 0;                                              \
01210     s->mb_intra = 0;                                                    \
01211     if (!index) {                                                       \
01212         _dmv_x = _dmv_y = 0;                                            \
01213     } else if (index == 35) {                                           \
01214         _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
01215         _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
01216     } else if (index == 36) {                                           \
01217         _dmv_x = 0;                                                     \
01218         _dmv_y = 0;                                                     \
01219         s->mb_intra = 1;                                                \
01220     } else {                                                            \
01221         index1 = index % 6;                                             \
01222         if (!s->quarter_sample && index1 == 5) val = 1;                 \
01223         else                                   val = 0;                 \
01224         if (size_table[index1] - val > 0)                               \
01225             val = get_bits(gb, size_table[index1] - val);               \
01226         else                                   val = 0;                 \
01227         sign = 0 - (val&1);                                             \
01228         _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
01229                                                                         \
01230         index1 = index / 6;                                             \
01231         if (!s->quarter_sample && index1 == 5) val = 1;                 \
01232         else                                   val = 0;                 \
01233         if (size_table[index1] - val > 0)                               \
01234             val = get_bits(gb, size_table[index1] - val);               \
01235         else                                   val = 0;                 \
01236         sign = 0 - (val & 1);                                           \
01237         _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign;   \
01238     }
01239 
01240 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
01241                                                    int *dmv_y, int *pred_flag)
01242 {
01243     int index, index1;
01244     int extend_x = 0, extend_y = 0;
01245     GetBitContext *gb = &v->s.gb;
01246     int bits, esc;
01247     int val, sign;
01248     const int* offs_tab;
01249 
01250     if (v->numref) {
01251         bits = VC1_2REF_MVDATA_VLC_BITS;
01252         esc  = 125;
01253     } else {
01254         bits = VC1_1REF_MVDATA_VLC_BITS;
01255         esc  = 71;
01256     }
01257     switch (v->dmvrange) {
01258     case 1:
01259         extend_x = 1;
01260         break;
01261     case 2:
01262         extend_y = 1;
01263         break;
01264     case 3:
01265         extend_x = extend_y = 1;
01266         break;
01267     }
01268     index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
01269     if (index == esc) {
01270         *dmv_x = get_bits(gb, v->k_x);
01271         *dmv_y = get_bits(gb, v->k_y);
01272         if (v->numref) {
01273             *pred_flag = *dmv_y & 1;
01274             *dmv_y     = (*dmv_y + *pred_flag) >> 1;
01275         }
01276     }
01277     else {
01278         if (extend_x)
01279             offs_tab = offset_table2;
01280         else
01281             offs_tab = offset_table1;
01282         index1 = (index + 1) % 9;
01283         if (index1 != 0) {
01284             val    = get_bits(gb, index1 + extend_x);
01285             sign   = 0 -(val & 1);
01286             *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
01287         } else
01288             *dmv_x = 0;
01289         if (extend_y)
01290             offs_tab = offset_table2;
01291         else
01292             offs_tab = offset_table1;
01293         index1 = (index + 1) / 9;
01294         if (index1 > v->numref) {
01295             val    = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
01296             sign   = 0 - (val & 1);
01297             *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
01298         } else
01299             *dmv_y = 0;
01300         if (v->numref)
01301             *pred_flag = index1 & 1;
01302     }
01303 }
01304 
01305 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
01306 {
01307     int scaledvalue, refdist;
01308     int scalesame1, scalesame2;
01309     int scalezone1_x, zone1offset_x;
01310     int table_index = dir ^ v->second_field;
01311 
01312     if (v->s.pict_type != AV_PICTURE_TYPE_B)
01313         refdist = v->refdist;
01314     else
01315         refdist = dir ? v->brfd : v->frfd;
01316     if (refdist > 3)
01317         refdist = 3;
01318     scalesame1    = vc1_field_mvpred_scales[table_index][1][refdist];
01319     scalesame2    = vc1_field_mvpred_scales[table_index][2][refdist];
01320     scalezone1_x  = vc1_field_mvpred_scales[table_index][3][refdist];
01321     zone1offset_x = vc1_field_mvpred_scales[table_index][5][refdist];
01322 
01323     if (FFABS(n) > 255)
01324         scaledvalue = n;
01325     else {
01326         if (FFABS(n) < scalezone1_x)
01327             scaledvalue = (n * scalesame1) >> 8;
01328         else {
01329             if (n < 0)
01330                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
01331             else
01332                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
01333         }
01334     }
01335     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
01336 }
01337 
01338 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
01339 {
01340     int scaledvalue, refdist;
01341     int scalesame1, scalesame2;
01342     int scalezone1_y, zone1offset_y;
01343     int table_index = dir ^ v->second_field;
01344 
01345     if (v->s.pict_type != AV_PICTURE_TYPE_B)
01346         refdist = v->refdist;
01347     else
01348         refdist = dir ? v->brfd : v->frfd;
01349     if (refdist > 3)
01350         refdist = 3;
01351     scalesame1    = vc1_field_mvpred_scales[table_index][1][refdist];
01352     scalesame2    = vc1_field_mvpred_scales[table_index][2][refdist];
01353     scalezone1_y  = vc1_field_mvpred_scales[table_index][4][refdist];
01354     zone1offset_y = vc1_field_mvpred_scales[table_index][6][refdist];
01355 
01356     if (FFABS(n) > 63)
01357         scaledvalue = n;
01358     else {
01359         if (FFABS(n) < scalezone1_y)
01360             scaledvalue = (n * scalesame1) >> 8;
01361         else {
01362             if (n < 0)
01363                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
01364             else
01365                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
01366         }
01367     }
01368 
01369     if (v->cur_field_type && !v->ref_field_type[dir])
01370         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
01371     else
01372         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
01373 }
01374 
01375 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
01376 {
01377     int scalezone1_x, zone1offset_x;
01378     int scaleopp1, scaleopp2, brfd;
01379     int scaledvalue;
01380 
01381     brfd = FFMIN(v->brfd, 3);
01382     scalezone1_x  = vc1_b_field_mvpred_scales[3][brfd];
01383     zone1offset_x = vc1_b_field_mvpred_scales[5][brfd];
01384     scaleopp1     = vc1_b_field_mvpred_scales[1][brfd];
01385     scaleopp2     = vc1_b_field_mvpred_scales[2][brfd];
01386 
01387     if (FFABS(n) > 255)
01388         scaledvalue = n;
01389     else {
01390         if (FFABS(n) < scalezone1_x)
01391             scaledvalue = (n * scaleopp1) >> 8;
01392         else {
01393             if (n < 0)
01394                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
01395             else
01396                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
01397         }
01398     }
01399     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
01400 }
01401 
01402 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
01403 {
01404     int scalezone1_y, zone1offset_y;
01405     int scaleopp1, scaleopp2, brfd;
01406     int scaledvalue;
01407 
01408     brfd = FFMIN(v->brfd, 3);
01409     scalezone1_y  = vc1_b_field_mvpred_scales[4][brfd];
01410     zone1offset_y = vc1_b_field_mvpred_scales[6][brfd];
01411     scaleopp1     = vc1_b_field_mvpred_scales[1][brfd];
01412     scaleopp2     = vc1_b_field_mvpred_scales[2][brfd];
01413 
01414     if (FFABS(n) > 63)
01415         scaledvalue = n;
01416     else {
01417         if (FFABS(n) < scalezone1_y)
01418             scaledvalue = (n * scaleopp1) >> 8;
01419         else {
01420             if (n < 0)
01421                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
01422             else
01423                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
01424         }
01425     }
01426     if (v->cur_field_type && !v->ref_field_type[dir]) {
01427         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
01428     } else {
01429         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
01430     }
01431 }
01432 
01433 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
01434                                          int dim, int dir)
01435 {
01436     int brfd, scalesame;
01437     int hpel = 1 - v->s.quarter_sample;
01438 
01439     n >>= hpel;
01440     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
01441         if (dim)
01442             n = scaleforsame_y(v, i, n, dir) << hpel;
01443         else
01444             n = scaleforsame_x(v, n, dir) << hpel;
01445         return n;
01446     }
01447     brfd      = FFMIN(v->brfd, 3);
01448     scalesame = vc1_b_field_mvpred_scales[0][brfd];
01449 
01450     n = (n * scalesame >> 8) << hpel;
01451     return n;
01452 }
01453 
01454 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
01455                                         int dim, int dir)
01456 {
01457     int refdist, scaleopp;
01458     int hpel = 1 - v->s.quarter_sample;
01459 
01460     n >>= hpel;
01461     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
01462         if (dim)
01463             n = scaleforopp_y(v, n, dir) << hpel;
01464         else
01465             n = scaleforopp_x(v, n) << hpel;
01466         return n;
01467     }
01468     if (v->s.pict_type != AV_PICTURE_TYPE_B)
01469         refdist = FFMIN(v->refdist, 3);
01470     else
01471         refdist = dir ? v->brfd : v->frfd;
01472     scaleopp = vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
01473 
01474     n = (n * scaleopp >> 8) << hpel;
01475     return n;
01476 }
01477 
01480 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
01481                                int mv1, int r_x, int r_y, uint8_t* is_intra,
01482                                int pred_flag, int dir)
01483 {
01484     MpegEncContext *s = &v->s;
01485     int xy, wrap, off = 0;
01486     int16_t *A, *B, *C;
01487     int px, py;
01488     int sum;
01489     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
01490     int opposit, a_f, b_f, c_f;
01491     int16_t field_predA[2];
01492     int16_t field_predB[2];
01493     int16_t field_predC[2];
01494     int a_valid, b_valid, c_valid;
01495     int hybridmv_thresh, y_bias = 0;
01496 
01497     if (v->mv_mode == MV_PMODE_MIXED_MV ||
01498         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
01499         mixedmv_pic = 1;
01500     else
01501         mixedmv_pic = 0;
01502     /* scale MV difference to be quad-pel */
01503     dmv_x <<= 1 - s->quarter_sample;
01504     dmv_y <<= 1 - s->quarter_sample;
01505 
01506     wrap = s->b8_stride;
01507     xy   = s->block_index[n];
01508 
01509     if (s->mb_intra) {
01510         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
01511         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
01512         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
01513         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
01514         if (mv1) { /* duplicate motion data for 1-MV block */
01515             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
01516             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
01517             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
01518             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
01519             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
01520             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
01521             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
01522             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
01523             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
01524             s->current_picture.f.motion_val[1][xy + wrap][0]                     = 0;
01525             s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
01526             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
01527             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
01528         }
01529         return;
01530     }
01531 
01532     C = s->current_picture.f.motion_val[dir][xy -    1 + v->blocks_off];
01533     A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
01534     if (mv1) {
01535         if (v->field_mode && mixedmv_pic)
01536             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01537         else
01538             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
01539     } else {
01540         //in 4-MV mode different blocks have different B predictor position
01541         switch (n) {
01542         case 0:
01543             off = (s->mb_x > 0) ? -1 : 1;
01544             break;
01545         case 1:
01546             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
01547             break;
01548         case 2:
01549             off = 1;
01550             break;
01551         case 3:
01552             off = -1;
01553         }
01554     }
01555     B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
01556 
01557     a_valid = !s->first_slice_line || (n == 2 || n == 3);
01558     b_valid = a_valid && (s->mb_width > 1);
01559     c_valid = s->mb_x || (n == 1 || n == 3);
01560     if (v->field_mode) {
01561         a_valid = a_valid && !is_intra[xy - wrap];
01562         b_valid = b_valid && !is_intra[xy - wrap + off];
01563         c_valid = c_valid && !is_intra[xy - 1];
01564     }
01565 
01566     if (a_valid) {
01567         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
01568         num_oppfield  += a_f;
01569         num_samefield += 1 - a_f;
01570         field_predA[0] = A[0];
01571         field_predA[1] = A[1];
01572     } else {
01573         field_predA[0] = field_predA[1] = 0;
01574         a_f = 0;
01575     }
01576     if (b_valid) {
01577         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
01578         num_oppfield  += b_f;
01579         num_samefield += 1 - b_f;
01580         field_predB[0] = B[0];
01581         field_predB[1] = B[1];
01582     } else {
01583         field_predB[0] = field_predB[1] = 0;
01584         b_f = 0;
01585     }
01586     if (c_valid) {
01587         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
01588         num_oppfield  += c_f;
01589         num_samefield += 1 - c_f;
01590         field_predC[0] = C[0];
01591         field_predC[1] = C[1];
01592     } else {
01593         field_predC[0] = field_predC[1] = 0;
01594         c_f = 0;
01595     }
01596 
01597     if (v->field_mode) {
01598         if (num_samefield <= num_oppfield)
01599             opposit = 1 - pred_flag;
01600         else
01601             opposit = pred_flag;
01602     } else
01603         opposit = 0;
01604     if (opposit) {
01605         if (a_valid && !a_f) {
01606             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
01607             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
01608         }
01609         if (b_valid && !b_f) {
01610             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
01611             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
01612         }
01613         if (c_valid && !c_f) {
01614             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
01615             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
01616         }
01617         v->mv_f[dir][xy + v->blocks_off] = 1;
01618         v->ref_field_type[dir] = !v->cur_field_type;
01619     } else {
01620         if (a_valid && a_f) {
01621             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
01622             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
01623         }
01624         if (b_valid && b_f) {
01625             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
01626             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
01627         }
01628         if (c_valid && c_f) {
01629             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
01630             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
01631         }
01632         v->mv_f[dir][xy + v->blocks_off] = 0;
01633         v->ref_field_type[dir] = v->cur_field_type;
01634     }
01635 
01636     if (a_valid) {
01637         px = field_predA[0];
01638         py = field_predA[1];
01639     } else if (c_valid) {
01640         px = field_predC[0];
01641         py = field_predC[1];
01642     } else if (b_valid) {
01643         px = field_predB[0];
01644         py = field_predB[1];
01645     } else {
01646         px = 0;
01647         py = 0;
01648     }
01649 
01650     if (num_samefield + num_oppfield > 1) {
01651         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
01652         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
01653     }
01654 
01655     /* Pullback MV as specified in 8.3.5.3.4 */
01656     if (!v->field_mode) {
01657         int qx, qy, X, Y;
01658         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
01659         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
01660         X  = (s->mb_width  << 6) - 4;
01661         Y  = (s->mb_height << 6) - 4;
01662         if (mv1) {
01663             if (qx + px < -60) px = -60 - qx;
01664             if (qy + py < -60) py = -60 - qy;
01665         } else {
01666             if (qx + px < -28) px = -28 - qx;
01667             if (qy + py < -28) py = -28 - qy;
01668         }
01669         if (qx + px > X) px = X - qx;
01670         if (qy + py > Y) py = Y - qy;
01671     }
01672 
01673     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
01674         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
01675         hybridmv_thresh = 32;
01676         if (a_valid && c_valid) {
01677             if (is_intra[xy - wrap])
01678                 sum = FFABS(px) + FFABS(py);
01679             else
01680                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
01681             if (sum > hybridmv_thresh) {
01682                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
01683                     px = field_predA[0];
01684                     py = field_predA[1];
01685                 } else {
01686                     px = field_predC[0];
01687                     py = field_predC[1];
01688                 }
01689             } else {
01690                 if (is_intra[xy - 1])
01691                     sum = FFABS(px) + FFABS(py);
01692                 else
01693                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
01694                 if (sum > hybridmv_thresh) {
01695                     if (get_bits1(&s->gb)) {
01696                         px = field_predA[0];
01697                         py = field_predA[1];
01698                     } else {
01699                         px = field_predC[0];
01700                         py = field_predC[1];
01701                     }
01702                 }
01703             }
01704         }
01705     }
01706 
01707     if (v->field_mode && !s->quarter_sample) {
01708         r_x <<= 1;
01709         r_y <<= 1;
01710     }
01711     if (v->field_mode && v->numref)
01712         r_y >>= 1;
01713     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
01714         y_bias = 1;
01715     /* store MV using signed modulus of MV range defined in 4.11 */
01716     s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
01717     s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
01718     if (mv1) { /* duplicate motion data for 1-MV block */
01719         s->current_picture.f.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01720         s->current_picture.f.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01721         s->current_picture.f.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01722         s->current_picture.f.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01723         s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
01724         s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
01725         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
01726         v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
01727     }
01728 }
01729 
01732 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
01733                                      int mvn, int r_x, int r_y, uint8_t* is_intra)
01734 {
01735     MpegEncContext *s = &v->s;
01736     int xy, wrap, off = 0;
01737     int A[2], B[2], C[2];
01738     int px, py;
01739     int a_valid = 0, b_valid = 0, c_valid = 0;
01740     int field_a, field_b, field_c; // 0: same, 1: opposit
01741     int total_valid, num_samefield, num_oppfield;
01742     int pos_c, pos_b, n_adj;
01743 
01744     wrap = s->b8_stride;
01745     xy = s->block_index[n];
01746 
01747     if (s->mb_intra) {
01748         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
01749         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
01750         s->current_picture.f.motion_val[1][xy][0] = 0;
01751         s->current_picture.f.motion_val[1][xy][1] = 0;
01752         if (mvn == 1) { /* duplicate motion data for 1-MV block */
01753             s->current_picture.f.motion_val[0][xy + 1][0]        = 0;
01754             s->current_picture.f.motion_val[0][xy + 1][1]        = 0;
01755             s->current_picture.f.motion_val[0][xy + wrap][0]     = 0;
01756             s->current_picture.f.motion_val[0][xy + wrap][1]     = 0;
01757             s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
01758             s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
01759             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
01760             s->current_picture.f.motion_val[1][xy + 1][0]        = 0;
01761             s->current_picture.f.motion_val[1][xy + 1][1]        = 0;
01762             s->current_picture.f.motion_val[1][xy + wrap][0]     = 0;
01763             s->current_picture.f.motion_val[1][xy + wrap][1]     = 0;
01764             s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
01765             s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
01766         }
01767         return;
01768     }
01769 
01770     off = ((n == 0) || (n == 1)) ? 1 : -1;
01771     /* predict A */
01772     if (s->mb_x || (n == 1) || (n == 3)) {
01773         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
01774             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
01775             A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
01776             A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
01777             a_valid = 1;
01778         } else { // current block has frame mv and cand. has field MV (so average)
01779             A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
01780                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
01781             A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
01782                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
01783             a_valid = 1;
01784         }
01785         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
01786             a_valid = 0;
01787             A[0] = A[1] = 0;
01788         }
01789     } else
01790         A[0] = A[1] = 0;
01791     /* Predict B and C */
01792     B[0] = B[1] = C[0] = C[1] = 0;
01793     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
01794         if (!s->first_slice_line) {
01795             if (!v->is_intra[s->mb_x - s->mb_stride]) {
01796                 b_valid = 1;
01797                 n_adj   = n | 2;
01798                 pos_b   = s->block_index[n_adj] - 2 * wrap;
01799                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
01800                     n_adj = (n & 2) | (n & 1);
01801                 }
01802                 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
01803                 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
01804                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
01805                     B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
01806                     B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
01807                 }
01808             }
01809             if (s->mb_width > 1) {
01810                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
01811                     c_valid = 1;
01812                     n_adj   = 2;
01813                     pos_c   = s->block_index[2] - 2 * wrap + 2;
01814                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
01815                         n_adj = n & 2;
01816                     }
01817                     C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
01818                     C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
01819                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
01820                         C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
01821                         C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
01822                     }
01823                     if (s->mb_x == s->mb_width - 1) {
01824                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
01825                             c_valid = 1;
01826                             n_adj   = 3;
01827                             pos_c   = s->block_index[3] - 2 * wrap - 2;
01828                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
01829                                 n_adj = n | 1;
01830                             }
01831                             C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
01832                             C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
01833                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
01834                                 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
01835                                 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
01836                             }
01837                         } else
01838                             c_valid = 0;
01839                     }
01840                 }
01841             }
01842         }
01843     } else {
01844         pos_b   = s->block_index[1];
01845         b_valid = 1;
01846         B[0]    = s->current_picture.f.motion_val[0][pos_b][0];
01847         B[1]    = s->current_picture.f.motion_val[0][pos_b][1];
01848         pos_c   = s->block_index[0];
01849         c_valid = 1;
01850         C[0]    = s->current_picture.f.motion_val[0][pos_c][0];
01851         C[1]    = s->current_picture.f.motion_val[0][pos_c][1];
01852     }
01853 
01854     total_valid = a_valid + b_valid + c_valid;
01855     // check if predictor A is out of bounds
01856     if (!s->mb_x && !(n == 1 || n == 3)) {
01857         A[0] = A[1] = 0;
01858     }
01859     // check if predictor B is out of bounds
01860     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
01861         B[0] = B[1] = C[0] = C[1] = 0;
01862     }
01863     if (!v->blk_mv_type[xy]) {
01864         if (s->mb_width == 1) {
01865             px = B[0];
01866             py = B[1];
01867         } else {
01868             if (total_valid >= 2) {
01869                 px = mid_pred(A[0], B[0], C[0]);
01870                 py = mid_pred(A[1], B[1], C[1]);
01871             } else if (total_valid) {
01872                 if (a_valid) { px = A[0]; py = A[1]; }
01873                 if (b_valid) { px = B[0]; py = B[1]; }
01874                 if (c_valid) { px = C[0]; py = C[1]; }
01875             } else
01876                 px = py = 0;
01877         }
01878     } else {
01879         if (a_valid)
01880             field_a = (A[1] & 4) ? 1 : 0;
01881         else
01882             field_a = 0;
01883         if (b_valid)
01884             field_b = (B[1] & 4) ? 1 : 0;
01885         else
01886             field_b = 0;
01887         if (c_valid)
01888             field_c = (C[1] & 4) ? 1 : 0;
01889         else
01890             field_c = 0;
01891 
01892         num_oppfield  = field_a + field_b + field_c;
01893         num_samefield = total_valid - num_oppfield;
01894         if (total_valid == 3) {
01895             if ((num_samefield == 3) || (num_oppfield == 3)) {
01896                 px = mid_pred(A[0], B[0], C[0]);
01897                 py = mid_pred(A[1], B[1], C[1]);
01898             } else if (num_samefield >= num_oppfield) {
01899                 /* take one MV from same field set depending on priority
01900                 the check for B may not be necessary */
01901                 px = !field_a ? A[0] : B[0];
01902                 py = !field_a ? A[1] : B[1];
01903             } else {
01904                 px =  field_a ? A[0] : B[0];
01905                 py =  field_a ? A[1] : B[1];
01906             }
01907         } else if (total_valid == 2) {
01908             if (num_samefield >= num_oppfield) {
01909                 if (!field_a && a_valid) {
01910                     px = A[0];
01911                     py = A[1];
01912                 } else if (!field_b && b_valid) {
01913                     px = B[0];
01914                     py = B[1];
01915                 } else if (c_valid) {
01916                     px = C[0];
01917                     py = C[1];
01918                 } else px = py = 0;
01919             } else {
01920                 if (field_a && a_valid) {
01921                     px = A[0];
01922                     py = A[1];
01923                 } else if (field_b && b_valid) {
01924                     px = B[0];
01925                     py = B[1];
01926                 } else if (c_valid) {
01927                     px = C[0];
01928                     py = C[1];
01929                 }
01930             }
01931         } else if (total_valid == 1) {
01932             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
01933             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
01934         } else
01935             px = py = 0;
01936     }
01937 
01938     /* store MV using signed modulus of MV range defined in 4.11 */
01939     s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
01940     s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
01941     if (mvn == 1) { /* duplicate motion data for 1-MV block */
01942         s->current_picture.f.motion_val[0][xy +    1    ][0] = s->current_picture.f.motion_val[0][xy][0];
01943         s->current_picture.f.motion_val[0][xy +    1    ][1] = s->current_picture.f.motion_val[0][xy][1];
01944         s->current_picture.f.motion_val[0][xy + wrap    ][0] = s->current_picture.f.motion_val[0][xy][0];
01945         s->current_picture.f.motion_val[0][xy + wrap    ][1] = s->current_picture.f.motion_val[0][xy][1];
01946         s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
01947         s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
01948     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
01949         s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
01950         s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
01951         s->mv[0][n + 1][0] = s->mv[0][n][0];
01952         s->mv[0][n + 1][1] = s->mv[0][n][1];
01953     }
01954 }
01955 
01958 static void vc1_interp_mc(VC1Context *v)
01959 {
01960     MpegEncContext *s = &v->s;
01961     DSPContext *dsp = &v->s.dsp;
01962     uint8_t *srcY, *srcU, *srcV;
01963     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
01964     int off, off_uv;
01965     int v_edge_pos = s->v_edge_pos >> v->field_mode;
01966 
01967     if (!v->field_mode && !v->s.next_picture.f.data[0])
01968         return;
01969 
01970     mx   = s->mv[1][0][0];
01971     my   = s->mv[1][0][1];
01972     uvmx = (mx + ((mx & 3) == 3)) >> 1;
01973     uvmy = (my + ((my & 3) == 3)) >> 1;
01974     if (v->field_mode) {
01975         if (v->cur_field_type != v->ref_field_type[1])
01976             my   = my   - 2 + 4 * v->cur_field_type;
01977             uvmy = uvmy - 2 + 4 * v->cur_field_type;
01978     }
01979     if (v->fastuvmc) {
01980         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
01981         uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
01982     }
01983     srcY = s->next_picture.f.data[0];
01984     srcU = s->next_picture.f.data[1];
01985     srcV = s->next_picture.f.data[2];
01986 
01987     src_x   = s->mb_x * 16 + (mx   >> 2);
01988     src_y   = s->mb_y * 16 + (my   >> 2);
01989     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
01990     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
01991 
01992     if (v->profile != PROFILE_ADVANCED) {
01993         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
01994         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
01995         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
01996         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
01997     } else {
01998         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
01999         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
02000         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
02001         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
02002     }
02003 
02004     srcY += src_y   * s->linesize   + src_x;
02005     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
02006     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
02007 
02008     if (v->field_mode && v->ref_field_type[1]) {
02009         srcY += s->current_picture_ptr->f.linesize[0];
02010         srcU += s->current_picture_ptr->f.linesize[1];
02011         srcV += s->current_picture_ptr->f.linesize[2];
02012     }
02013 
02014     /* for grayscale we should not try to read from unknown area */
02015     if (s->flags & CODEC_FLAG_GRAY) {
02016         srcU = s->edge_emu_buffer + 18 * s->linesize;
02017         srcV = s->edge_emu_buffer + 18 * s->linesize;
02018     }
02019 
02020     if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
02021         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
02022         || (unsigned)(src_y - s->mspel) > v_edge_pos    - (my & 3) - 16 - s->mspel * 3) {
02023         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
02024 
02025         srcY -= s->mspel * (1 + s->linesize);
02026         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
02027                                 17 + s->mspel * 2, 17 + s->mspel * 2,
02028                                 src_x - s->mspel, src_y - s->mspel,
02029                                 s->h_edge_pos, v_edge_pos);
02030         srcY = s->edge_emu_buffer;
02031         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
02032                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
02033         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
02034                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
02035         srcU = uvbuf;
02036         srcV = uvbuf + 16;
02037         /* if we deal with range reduction we need to scale source blocks */
02038         if (v->rangeredfrm) {
02039             int i, j;
02040             uint8_t *src, *src2;
02041 
02042             src = srcY;
02043             for (j = 0; j < 17 + s->mspel * 2; j++) {
02044                 for (i = 0; i < 17 + s->mspel * 2; i++)
02045                     src[i] = ((src[i] - 128) >> 1) + 128;
02046                 src += s->linesize;
02047             }
02048             src = srcU;
02049             src2 = srcV;
02050             for (j = 0; j < 9; j++) {
02051                 for (i = 0; i < 9; i++) {
02052                     src[i]  = ((src[i]  - 128) >> 1) + 128;
02053                     src2[i] = ((src2[i] - 128) >> 1) + 128;
02054                 }
02055                 src  += s->uvlinesize;
02056                 src2 += s->uvlinesize;
02057             }
02058         }
02059         srcY += s->mspel * (1 + s->linesize);
02060     }
02061 
02062     if (v->field_mode && v->cur_field_type) {
02063         off    = s->current_picture_ptr->f.linesize[0];
02064         off_uv = s->current_picture_ptr->f.linesize[1];
02065     } else {
02066         off    = 0;
02067         off_uv = 0;
02068     }
02069 
02070     if (s->mspel) {
02071         dxy = ((my & 3) << 2) | (mx & 3);
02072         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
02073         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
02074         srcY += s->linesize * 8;
02075         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
02076         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
02077     } else { // hpel mc
02078         dxy = (my & 2) | ((mx & 2) >> 1);
02079 
02080         if (!v->rnd)
02081             dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
02082         else
02083             dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
02084     }
02085 
02086     if (s->flags & CODEC_FLAG_GRAY) return;
02087     /* Chroma MC always uses qpel blilinear */
02088     uvmx = (uvmx & 3) << 1;
02089     uvmy = (uvmy & 3) << 1;
02090     if (!v->rnd) {
02091         dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
02092         dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
02093     } else {
02094         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
02095         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
02096     }
02097 }
02098 
02099 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
02100 {
02101     int n = bfrac;
02102 
02103 #if B_FRACTION_DEN==256
02104     if (inv)
02105         n -= 256;
02106     if (!qs)
02107         return 2 * ((value * n + 255) >> 9);
02108     return (value * n + 128) >> 8;
02109 #else
02110     if (inv)
02111         n -= B_FRACTION_DEN;
02112     if (!qs)
02113         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
02114     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
02115 #endif
02116 }
02117 
02118 static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
02119                                            int qs, int qs_last)
02120 {
02121     int n = bfrac;
02122 
02123     if (inv)
02124         n -= 256;
02125     n <<= !qs_last;
02126     if (!qs)
02127         return (value * n + 255) >> 9;
02128     else
02129         return (value * n + 128) >> 8;
02130 }
02131 
02134 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
02135                             int direct, int mode)
02136 {
02137     if (v->use_ic) {
02138         v->mv_mode2 = v->mv_mode;
02139         v->mv_mode  = MV_PMODE_INTENSITY_COMP;
02140     }
02141     if (direct) {
02142         vc1_mc_1mv(v, 0);
02143         vc1_interp_mc(v);
02144         if (v->use_ic)
02145             v->mv_mode = v->mv_mode2;
02146         return;
02147     }
02148     if (mode == BMV_TYPE_INTERPOLATED) {
02149         vc1_mc_1mv(v, 0);
02150         vc1_interp_mc(v);
02151         if (v->use_ic)
02152             v->mv_mode = v->mv_mode2;
02153         return;
02154     }
02155 
02156     if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
02157         v->mv_mode = v->mv_mode2;
02158     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
02159     if (v->use_ic)
02160         v->mv_mode = v->mv_mode2;
02161 }
02162 
02163 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
02164                                  int direct, int mvtype)
02165 {
02166     MpegEncContext *s = &v->s;
02167     int xy, wrap, off = 0;
02168     int16_t *A, *B, *C;
02169     int px, py;
02170     int sum;
02171     int r_x, r_y;
02172     const uint8_t *is_intra = v->mb_type[0];
02173 
02174     r_x = v->range_x;
02175     r_y = v->range_y;
02176     /* scale MV difference to be quad-pel */
02177     dmv_x[0] <<= 1 - s->quarter_sample;
02178     dmv_y[0] <<= 1 - s->quarter_sample;
02179     dmv_x[1] <<= 1 - s->quarter_sample;
02180     dmv_y[1] <<= 1 - s->quarter_sample;
02181 
02182     wrap = s->b8_stride;
02183     xy = s->block_index[0];
02184 
02185     if (s->mb_intra) {
02186         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
02187         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
02188         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
02189         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
02190         return;
02191     }
02192     if (!v->field_mode) {
02193         s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
02194         s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
02195         s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
02196         s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
02197 
02198         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
02199         s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width  << 6) - 4 - (s->mb_x << 6));
02200         s->mv[0][0][1] = av_clip(s->mv[0][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
02201         s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width  << 6) - 4 - (s->mb_x << 6));
02202         s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
02203     }
02204     if (direct) {
02205         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
02206         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
02207         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
02208         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
02209         return;
02210     }
02211 
02212     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
02213         C   = s->current_picture.f.motion_val[0][xy - 2];
02214         A   = s->current_picture.f.motion_val[0][xy - wrap * 2];
02215         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
02216         B   = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
02217 
02218         if (!s->mb_x) C[0] = C[1] = 0;
02219         if (!s->first_slice_line) { // predictor A is not out of bounds
02220             if (s->mb_width == 1) {
02221                 px = A[0];
02222                 py = A[1];
02223             } else {
02224                 px = mid_pred(A[0], B[0], C[0]);
02225                 py = mid_pred(A[1], B[1], C[1]);
02226             }
02227         } else if (s->mb_x) { // predictor C is not out of bounds
02228             px = C[0];
02229             py = C[1];
02230         } else {
02231             px = py = 0;
02232         }
02233         /* Pullback MV as specified in 8.3.5.3.4 */
02234         {
02235             int qx, qy, X, Y;
02236             if (v->profile < PROFILE_ADVANCED) {
02237                 qx = (s->mb_x << 5);
02238                 qy = (s->mb_y << 5);
02239                 X  = (s->mb_width  << 5) - 4;
02240                 Y  = (s->mb_height << 5) - 4;
02241                 if (qx + px < -28) px = -28 - qx;
02242                 if (qy + py < -28) py = -28 - qy;
02243                 if (qx + px > X) px = X - qx;
02244                 if (qy + py > Y) py = Y - qy;
02245             } else {
02246                 qx = (s->mb_x << 6);
02247                 qy = (s->mb_y << 6);
02248                 X  = (s->mb_width  << 6) - 4;
02249                 Y  = (s->mb_height << 6) - 4;
02250                 if (qx + px < -60) px = -60 - qx;
02251                 if (qy + py < -60) py = -60 - qy;
02252                 if (qx + px > X) px = X - qx;
02253                 if (qy + py > Y) py = Y - qy;
02254             }
02255         }
02256         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
02257         if (0 && !s->first_slice_line && s->mb_x) {
02258             if (is_intra[xy - wrap])
02259                 sum = FFABS(px) + FFABS(py);
02260             else
02261                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
02262             if (sum > 32) {
02263                 if (get_bits1(&s->gb)) {
02264                     px = A[0];
02265                     py = A[1];
02266                 } else {
02267                     px = C[0];
02268                     py = C[1];
02269                 }
02270             } else {
02271                 if (is_intra[xy - 2])
02272                     sum = FFABS(px) + FFABS(py);
02273                 else
02274                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
02275                 if (sum > 32) {
02276                     if (get_bits1(&s->gb)) {
02277                         px = A[0];
02278                         py = A[1];
02279                     } else {
02280                         px = C[0];
02281                         py = C[1];
02282                     }
02283                 }
02284             }
02285         }
02286         /* store MV using signed modulus of MV range defined in 4.11 */
02287         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
02288         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
02289     }
02290     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
02291         C   = s->current_picture.f.motion_val[1][xy - 2];
02292         A   = s->current_picture.f.motion_val[1][xy - wrap * 2];
02293         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
02294         B   = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
02295 
02296         if (!s->mb_x)
02297             C[0] = C[1] = 0;
02298         if (!s->first_slice_line) { // predictor A is not out of bounds
02299             if (s->mb_width == 1) {
02300                 px = A[0];
02301                 py = A[1];
02302             } else {
02303                 px = mid_pred(A[0], B[0], C[0]);
02304                 py = mid_pred(A[1], B[1], C[1]);
02305             }
02306         } else if (s->mb_x) { // predictor C is not out of bounds
02307             px = C[0];
02308             py = C[1];
02309         } else {
02310             px = py = 0;
02311         }
02312         /* Pullback MV as specified in 8.3.5.3.4 */
02313         {
02314             int qx, qy, X, Y;
02315             if (v->profile < PROFILE_ADVANCED) {
02316                 qx = (s->mb_x << 5);
02317                 qy = (s->mb_y << 5);
02318                 X  = (s->mb_width  << 5) - 4;
02319                 Y  = (s->mb_height << 5) - 4;
02320                 if (qx + px < -28) px = -28 - qx;
02321                 if (qy + py < -28) py = -28 - qy;
02322                 if (qx + px > X) px = X - qx;
02323                 if (qy + py > Y) py = Y - qy;
02324             } else {
02325                 qx = (s->mb_x << 6);
02326                 qy = (s->mb_y << 6);
02327                 X  = (s->mb_width  << 6) - 4;
02328                 Y  = (s->mb_height << 6) - 4;
02329                 if (qx + px < -60) px = -60 - qx;
02330                 if (qy + py < -60) py = -60 - qy;
02331                 if (qx + px > X) px = X - qx;
02332                 if (qy + py > Y) py = Y - qy;
02333             }
02334         }
02335         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
02336         if (0 && !s->first_slice_line && s->mb_x) {
02337             if (is_intra[xy - wrap])
02338                 sum = FFABS(px) + FFABS(py);
02339             else
02340                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
02341             if (sum > 32) {
02342                 if (get_bits1(&s->gb)) {
02343                     px = A[0];
02344                     py = A[1];
02345                 } else {
02346                     px = C[0];
02347                     py = C[1];
02348                 }
02349             } else {
02350                 if (is_intra[xy - 2])
02351                     sum = FFABS(px) + FFABS(py);
02352                 else
02353                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
02354                 if (sum > 32) {
02355                     if (get_bits1(&s->gb)) {
02356                         px = A[0];
02357                         py = A[1];
02358                     } else {
02359                         px = C[0];
02360                         py = C[1];
02361                     }
02362                 }
02363             }
02364         }
02365         /* store MV using signed modulus of MV range defined in 4.11 */
02366 
02367         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
02368         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
02369     }
02370     s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
02371     s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
02372     s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
02373     s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
02374 }
02375 
02376 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
02377 {
02378     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
02379     MpegEncContext *s = &v->s;
02380     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02381 
02382     if (v->bmvtype == BMV_TYPE_DIRECT) {
02383         int total_opp, k, f;
02384         if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
02385             s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
02386                                             v->bfraction, 0, s->quarter_sample, v->qs_last);
02387             s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
02388                                             v->bfraction, 0, s->quarter_sample, v->qs_last);
02389             s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
02390                                             v->bfraction, 1, s->quarter_sample, v->qs_last);
02391             s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
02392                                             v->bfraction, 1, s->quarter_sample, v->qs_last);
02393 
02394             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
02395                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
02396                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
02397                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
02398             f = (total_opp > 2) ? 1 : 0;
02399         } else {
02400             s->mv[0][0][0] = s->mv[0][0][1] = 0;
02401             s->mv[1][0][0] = s->mv[1][0][1] = 0;
02402             f = 0;
02403         }
02404         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
02405         for (k = 0; k < 4; k++) {
02406             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
02407             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
02408             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
02409             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
02410             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
02411             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
02412         }
02413         return;
02414     }
02415     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
02416         vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
02417         vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
02418         return;
02419     }
02420     if (dir) { // backward
02421         vc1_pred_mv(v, n, dmv_x[1], dmv_y[1], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
02422         if (n == 3 || mv1) {
02423             vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
02424         }
02425     } else { // forward
02426         vc1_pred_mv(v, n, dmv_x[0], dmv_y[0], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
02427         if (n == 3 || mv1) {
02428             vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
02429         }
02430     }
02431 }
02432 
02442 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02443                                 int16_t **dc_val_ptr, int *dir_ptr)
02444 {
02445     int a, b, c, wrap, pred, scale;
02446     int16_t *dc_val;
02447     static const uint16_t dcpred[32] = {
02448         -1, 1024,  512,  341,  256,  205,  171,  146,  128,
02449              114,  102,   93,   85,   79,   73,   68,   64,
02450               60,   57,   54,   51,   49,   47,   45,   43,
02451               41,   39,   38,   37,   35,   34,   33
02452     };
02453 
02454     /* find prediction - wmv3_dc_scale always used here in fact */
02455     if (n < 4) scale = s->y_dc_scale;
02456     else       scale = s->c_dc_scale;
02457 
02458     wrap   = s->block_wrap[n];
02459     dc_val = s->dc_val[0] + s->block_index[n];
02460 
02461     /* B A
02462      * C X
02463      */
02464     c = dc_val[ - 1];
02465     b = dc_val[ - 1 - wrap];
02466     a = dc_val[ - wrap];
02467 
02468     if (pq < 9 || !overlap) {
02469         /* Set outer values */
02470         if (s->first_slice_line && (n != 2 && n != 3))
02471             b = a = dcpred[scale];
02472         if (s->mb_x == 0 && (n != 1 && n != 3))
02473             b = c = dcpred[scale];
02474     } else {
02475         /* Set outer values */
02476         if (s->first_slice_line && (n != 2 && n != 3))
02477             b = a = 0;
02478         if (s->mb_x == 0 && (n != 1 && n != 3))
02479             b = c = 0;
02480     }
02481 
02482     if (abs(a - b) <= abs(b - c)) {
02483         pred     = c;
02484         *dir_ptr = 1; // left
02485     } else {
02486         pred     = a;
02487         *dir_ptr = 0; // top
02488     }
02489 
02490     /* update predictor */
02491     *dc_val_ptr = &dc_val[0];
02492     return pred;
02493 }
02494 
02495 
02507 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
02508                               int a_avail, int c_avail,
02509                               int16_t **dc_val_ptr, int *dir_ptr)
02510 {
02511     int a, b, c, wrap, pred;
02512     int16_t *dc_val;
02513     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02514     int q1, q2 = 0;
02515 
02516     wrap = s->block_wrap[n];
02517     dc_val = s->dc_val[0] + s->block_index[n];
02518 
02519     /* B A
02520      * C X
02521      */
02522     c = dc_val[ - 1];
02523     b = dc_val[ - 1 - wrap];
02524     a = dc_val[ - wrap];
02525     /* scale predictors if needed */
02526     q1 = s->current_picture.f.qscale_table[mb_pos];
02527     if (c_avail && (n != 1 && n != 3)) {
02528         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
02529         if (q2 && q2 != q1)
02530             c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02531     }
02532     if (a_avail && (n != 2 && n != 3)) {
02533         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
02534         if (q2 && q2 != q1)
02535             a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02536     }
02537     if (a_avail && c_avail && (n != 3)) {
02538         int off = mb_pos;
02539         if (n != 1)
02540             off--;
02541         if (n != 2)
02542             off -= s->mb_stride;
02543         q2 = s->current_picture.f.qscale_table[off];
02544         if (q2 && q2 != q1)
02545             b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
02546     }
02547 
02548     if (a_avail && c_avail) {
02549         if (abs(a - b) <= abs(b - c)) {
02550             pred     = c;
02551             *dir_ptr = 1; // left
02552         } else {
02553             pred     = a;
02554             *dir_ptr = 0; // top
02555         }
02556     } else if (a_avail) {
02557         pred     = a;
02558         *dir_ptr = 0; // top
02559     } else if (c_avail) {
02560         pred     = c;
02561         *dir_ptr = 1; // left
02562     } else {
02563         pred     = 0;
02564         *dir_ptr = 1; // left
02565     }
02566 
02567     /* update predictor */
02568     *dc_val_ptr = &dc_val[0];
02569     return pred;
02570 }
02571  // Block group
02573 
02580 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
02581                                        uint8_t **coded_block_ptr)
02582 {
02583     int xy, wrap, pred, a, b, c;
02584 
02585     xy   = s->block_index[n];
02586     wrap = s->b8_stride;
02587 
02588     /* B C
02589      * A X
02590      */
02591     a = s->coded_block[xy - 1       ];
02592     b = s->coded_block[xy - 1 - wrap];
02593     c = s->coded_block[xy     - wrap];
02594 
02595     if (b == c) {
02596         pred = a;
02597     } else {
02598         pred = c;
02599     }
02600 
02601     /* store value */
02602     *coded_block_ptr = &s->coded_block[xy];
02603 
02604     return pred;
02605 }
02606 
02616 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
02617                                 int *value, int codingset)
02618 {
02619     GetBitContext *gb = &v->s.gb;
02620     int index, escape, run = 0, level = 0, lst = 0;
02621 
02622     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02623     if (index != vc1_ac_sizes[codingset] - 1) {
02624         run   = vc1_index_decode_table[codingset][index][0];
02625         level = vc1_index_decode_table[codingset][index][1];
02626         lst   = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
02627         if (get_bits1(gb))
02628             level = -level;
02629     } else {
02630         escape = decode210(gb);
02631         if (escape != 2) {
02632             index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
02633             run   = vc1_index_decode_table[codingset][index][0];
02634             level = vc1_index_decode_table[codingset][index][1];
02635             lst   = index >= vc1_last_decode_table[codingset];
02636             if (escape == 0) {
02637                 if (lst)
02638                     level += vc1_last_delta_level_table[codingset][run];
02639                 else
02640                     level += vc1_delta_level_table[codingset][run];
02641             } else {
02642                 if (lst)
02643                     run += vc1_last_delta_run_table[codingset][level] + 1;
02644                 else
02645                     run += vc1_delta_run_table[codingset][level] + 1;
02646             }
02647             if (get_bits1(gb))
02648                 level = -level;
02649         } else {
02650             int sign;
02651             lst = get_bits1(gb);
02652             if (v->s.esc3_level_length == 0) {
02653                 if (v->pq < 8 || v->dquantfrm) { // table 59
02654                     v->s.esc3_level_length = get_bits(gb, 3);
02655                     if (!v->s.esc3_level_length)
02656                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
02657                 } else { // table 60
02658                     v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
02659                 }
02660                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
02661             }
02662             run   = get_bits(gb, v->s.esc3_run_length);
02663             sign  = get_bits1(gb);
02664             level = get_bits(gb, v->s.esc3_level_length);
02665             if (sign)
02666                 level = -level;
02667         }
02668     }
02669 
02670     *last  = lst;
02671     *skip  = run;
02672     *value = level;
02673 }
02674 
02682 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
02683                               int coded, int codingset)
02684 {
02685     GetBitContext *gb = &v->s.gb;
02686     MpegEncContext *s = &v->s;
02687     int dc_pred_dir = 0; /* Direction of the DC prediction used */
02688     int i;
02689     int16_t *dc_val;
02690     int16_t *ac_val, *ac_val2;
02691     int dcdiff;
02692 
02693     /* Get DC differential */
02694     if (n < 4) {
02695         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02696     } else {
02697         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02698     }
02699     if (dcdiff < 0) {
02700         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02701         return -1;
02702     }
02703     if (dcdiff) {
02704         if (dcdiff == 119 /* ESC index value */) {
02705             /* TODO: Optimize */
02706             if (v->pq == 1)      dcdiff = get_bits(gb, 10);
02707             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
02708             else                 dcdiff = get_bits(gb, 8);
02709         } else {
02710             if (v->pq == 1)
02711                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
02712             else if (v->pq == 2)
02713                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
02714         }
02715         if (get_bits1(gb))
02716             dcdiff = -dcdiff;
02717     }
02718 
02719     /* Prediction */
02720     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
02721     *dc_val = dcdiff;
02722 
02723     /* Store the quantized DC coeff, used for prediction */
02724     if (n < 4) {
02725         block[0] = dcdiff * s->y_dc_scale;
02726     } else {
02727         block[0] = dcdiff * s->c_dc_scale;
02728     }
02729     /* Skip ? */
02730     if (!coded) {
02731         goto not_coded;
02732     }
02733 
02734     // AC Decoding
02735     i = 1;
02736 
02737     {
02738         int last = 0, skip, value;
02739         const uint8_t *zz_table;
02740         int scale;
02741         int k;
02742 
02743         scale = v->pq * 2 + v->halfpq;
02744 
02745         if (v->s.ac_pred) {
02746             if (!dc_pred_dir)
02747                 zz_table = v->zz_8x8[2];
02748             else
02749                 zz_table = v->zz_8x8[3];
02750         } else
02751             zz_table = v->zz_8x8[1];
02752 
02753         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
02754         ac_val2 = ac_val;
02755         if (dc_pred_dir) // left
02756             ac_val -= 16;
02757         else // top
02758             ac_val -= 16 * s->block_wrap[n];
02759 
02760         while (!last) {
02761             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02762             i += skip;
02763             if (i > 63)
02764                 break;
02765             block[zz_table[i++]] = value;
02766         }
02767 
02768         /* apply AC prediction if needed */
02769         if (s->ac_pred) {
02770             if (dc_pred_dir) { // left
02771                 for (k = 1; k < 8; k++)
02772                     block[k << v->left_blk_sh] += ac_val[k];
02773             } else { // top
02774                 for (k = 1; k < 8; k++)
02775                     block[k << v->top_blk_sh] += ac_val[k + 8];
02776             }
02777         }
02778         /* save AC coeffs for further prediction */
02779         for (k = 1; k < 8; k++) {
02780             ac_val2[k]     = block[k << v->left_blk_sh];
02781             ac_val2[k + 8] = block[k << v->top_blk_sh];
02782         }
02783 
02784         /* scale AC coeffs */
02785         for (k = 1; k < 64; k++)
02786             if (block[k]) {
02787                 block[k] *= scale;
02788                 if (!v->pquantizer)
02789                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
02790             }
02791 
02792         if (s->ac_pred) i = 63;
02793     }
02794 
02795 not_coded:
02796     if (!coded) {
02797         int k, scale;
02798         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
02799         ac_val2 = ac_val;
02800 
02801         i = 0;
02802         scale = v->pq * 2 + v->halfpq;
02803         memset(ac_val2, 0, 16 * 2);
02804         if (dc_pred_dir) { // left
02805             ac_val -= 16;
02806             if (s->ac_pred)
02807                 memcpy(ac_val2, ac_val, 8 * 2);
02808         } else { // top
02809             ac_val -= 16 * s->block_wrap[n];
02810             if (s->ac_pred)
02811                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02812         }
02813 
02814         /* apply AC prediction if needed */
02815         if (s->ac_pred) {
02816             if (dc_pred_dir) { //left
02817                 for (k = 1; k < 8; k++) {
02818                     block[k << v->left_blk_sh] = ac_val[k] * scale;
02819                     if (!v->pquantizer && block[k << v->left_blk_sh])
02820                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
02821                 }
02822             } else { // top
02823                 for (k = 1; k < 8; k++) {
02824                     block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
02825                     if (!v->pquantizer && block[k << v->top_blk_sh])
02826                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
02827                 }
02828             }
02829             i = 63;
02830         }
02831     }
02832     s->block_last_index[n] = i;
02833 
02834     return 0;
02835 }
02836 
02845 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
02846                                   int coded, int codingset, int mquant)
02847 {
02848     GetBitContext *gb = &v->s.gb;
02849     MpegEncContext *s = &v->s;
02850     int dc_pred_dir = 0; /* Direction of the DC prediction used */
02851     int i;
02852     int16_t *dc_val;
02853     int16_t *ac_val, *ac_val2;
02854     int dcdiff;
02855     int a_avail = v->a_avail, c_avail = v->c_avail;
02856     int use_pred = s->ac_pred;
02857     int scale;
02858     int q1, q2 = 0;
02859     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02860 
02861     /* Get DC differential */
02862     if (n < 4) {
02863         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02864     } else {
02865         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02866     }
02867     if (dcdiff < 0) {
02868         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02869         return -1;
02870     }
02871     if (dcdiff) {
02872         if (dcdiff == 119 /* ESC index value */) {
02873             /* TODO: Optimize */
02874             if (mquant == 1)      dcdiff = get_bits(gb, 10);
02875             else if (mquant == 2) dcdiff = get_bits(gb, 9);
02876             else                  dcdiff = get_bits(gb, 8);
02877         } else {
02878             if (mquant == 1)
02879                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
02880             else if (mquant == 2)
02881                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
02882         }
02883         if (get_bits1(gb))
02884             dcdiff = -dcdiff;
02885     }
02886 
02887     /* Prediction */
02888     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
02889     *dc_val = dcdiff;
02890 
02891     /* Store the quantized DC coeff, used for prediction */
02892     if (n < 4) {
02893         block[0] = dcdiff * s->y_dc_scale;
02894     } else {
02895         block[0] = dcdiff * s->c_dc_scale;
02896     }
02897 
02898     //AC Decoding
02899     i = 1;
02900 
02901     /* check if AC is needed at all */
02902     if (!a_avail && !c_avail)
02903         use_pred = 0;
02904     ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
02905     ac_val2 = ac_val;
02906 
02907     scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
02908 
02909     if (dc_pred_dir) // left
02910         ac_val -= 16;
02911     else // top
02912         ac_val -= 16 * s->block_wrap[n];
02913 
02914     q1 = s->current_picture.f.qscale_table[mb_pos];
02915     if ( dc_pred_dir && c_avail && mb_pos)
02916         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
02917     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
02918         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
02919     if ( dc_pred_dir && n == 1)
02920         q2 = q1;
02921     if (!dc_pred_dir && n == 2)
02922         q2 = q1;
02923     if (n == 3)
02924         q2 = q1;
02925 
02926     if (coded) {
02927         int last = 0, skip, value;
02928         const uint8_t *zz_table;
02929         int k;
02930 
02931         if (v->s.ac_pred) {
02932             if (!use_pred && v->fcm == ILACE_FRAME) {
02933                 zz_table = v->zzi_8x8;
02934             } else {
02935                 if (!dc_pred_dir) // top
02936                     zz_table = v->zz_8x8[2];
02937                 else // left
02938                     zz_table = v->zz_8x8[3];
02939             }
02940         } else {
02941             if (v->fcm != ILACE_FRAME)
02942                 zz_table = v->zz_8x8[1];
02943             else
02944                 zz_table = v->zzi_8x8;
02945         }
02946 
02947         while (!last) {
02948             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02949             i += skip;
02950             if (i > 63)
02951                 break;
02952             block[zz_table[i++]] = value;
02953         }
02954 
02955         /* apply AC prediction if needed */
02956         if (use_pred) {
02957             /* scale predictors if needed*/
02958             if (q2 && q1 != q2) {
02959                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02960                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02961 
02962                 if (dc_pred_dir) { // left
02963                     for (k = 1; k < 8; k++)
02964                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02965                 } else { // top
02966                     for (k = 1; k < 8; k++)
02967                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02968                 }
02969             } else {
02970                 if (dc_pred_dir) { //left
02971                     for (k = 1; k < 8; k++)
02972                         block[k << v->left_blk_sh] += ac_val[k];
02973                 } else { //top
02974                     for (k = 1; k < 8; k++)
02975                         block[k << v->top_blk_sh] += ac_val[k + 8];
02976                 }
02977             }
02978         }
02979         /* save AC coeffs for further prediction */
02980         for (k = 1; k < 8; k++) {
02981             ac_val2[k    ] = block[k << v->left_blk_sh];
02982             ac_val2[k + 8] = block[k << v->top_blk_sh];
02983         }
02984 
02985         /* scale AC coeffs */
02986         for (k = 1; k < 64; k++)
02987             if (block[k]) {
02988                 block[k] *= scale;
02989                 if (!v->pquantizer)
02990                     block[k] += (block[k] < 0) ? -mquant : mquant;
02991             }
02992 
02993         if (use_pred) i = 63;
02994     } else { // no AC coeffs
02995         int k;
02996 
02997         memset(ac_val2, 0, 16 * 2);
02998         if (dc_pred_dir) { // left
02999             if (use_pred) {
03000                 memcpy(ac_val2, ac_val, 8 * 2);
03001                 if (q2 && q1 != q2) {
03002                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03003                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03004                     for (k = 1; k < 8; k++)
03005                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03006                 }
03007             }
03008         } else { // top
03009             if (use_pred) {
03010                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
03011                 if (q2 && q1 != q2) {
03012                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03013                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03014                     for (k = 1; k < 8; k++)
03015                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03016                 }
03017             }
03018         }
03019 
03020         /* apply AC prediction if needed */
03021         if (use_pred) {
03022             if (dc_pred_dir) { // left
03023                 for (k = 1; k < 8; k++) {
03024                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
03025                     if (!v->pquantizer && block[k << v->left_blk_sh])
03026                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
03027                 }
03028             } else { // top
03029                 for (k = 1; k < 8; k++) {
03030                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
03031                     if (!v->pquantizer && block[k << v->top_blk_sh])
03032                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
03033                 }
03034             }
03035             i = 63;
03036         }
03037     }
03038     s->block_last_index[n] = i;
03039 
03040     return 0;
03041 }
03042 
03051 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
03052                                   int coded, int mquant, int codingset)
03053 {
03054     GetBitContext *gb = &v->s.gb;
03055     MpegEncContext *s = &v->s;
03056     int dc_pred_dir = 0; /* Direction of the DC prediction used */
03057     int i;
03058     int16_t *dc_val;
03059     int16_t *ac_val, *ac_val2;
03060     int dcdiff;
03061     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03062     int a_avail = v->a_avail, c_avail = v->c_avail;
03063     int use_pred = s->ac_pred;
03064     int scale;
03065     int q1, q2 = 0;
03066 
03067     s->dsp.clear_block(block);
03068 
03069     /* XXX: Guard against dumb values of mquant */
03070     mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
03071 
03072     /* Set DC scale - y and c use the same */
03073     s->y_dc_scale = s->y_dc_scale_table[mquant];
03074     s->c_dc_scale = s->c_dc_scale_table[mquant];
03075 
03076     /* Get DC differential */
03077     if (n < 4) {
03078         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
03079     } else {
03080         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
03081     }
03082     if (dcdiff < 0) {
03083         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
03084         return -1;
03085     }
03086     if (dcdiff) {
03087         if (dcdiff == 119 /* ESC index value */) {
03088             /* TODO: Optimize */
03089             if (mquant == 1)      dcdiff = get_bits(gb, 10);
03090             else if (mquant == 2) dcdiff = get_bits(gb, 9);
03091             else                  dcdiff = get_bits(gb, 8);
03092         } else {
03093             if (mquant == 1)
03094                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
03095             else if (mquant == 2)
03096                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
03097         }
03098         if (get_bits1(gb))
03099             dcdiff = -dcdiff;
03100     }
03101 
03102     /* Prediction */
03103     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
03104     *dc_val = dcdiff;
03105 
03106     /* Store the quantized DC coeff, used for prediction */
03107 
03108     if (n < 4) {
03109         block[0] = dcdiff * s->y_dc_scale;
03110     } else {
03111         block[0] = dcdiff * s->c_dc_scale;
03112     }
03113 
03114     //AC Decoding
03115     i = 1;
03116 
03117     /* check if AC is needed at all and adjust direction if needed */
03118     if (!a_avail) dc_pred_dir = 1;
03119     if (!c_avail) dc_pred_dir = 0;
03120     if (!a_avail && !c_avail) use_pred = 0;
03121     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
03122     ac_val2 = ac_val;
03123 
03124     scale = mquant * 2 + v->halfpq;
03125 
03126     if (dc_pred_dir) //left
03127         ac_val -= 16;
03128     else //top
03129         ac_val -= 16 * s->block_wrap[n];
03130 
03131     q1 = s->current_picture.f.qscale_table[mb_pos];
03132     if (dc_pred_dir && c_avail && mb_pos)
03133         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
03134     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
03135         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
03136     if ( dc_pred_dir && n == 1)
03137         q2 = q1;
03138     if (!dc_pred_dir && n == 2)
03139         q2 = q1;
03140     if (n == 3) q2 = q1;
03141 
03142     if (coded) {
03143         int last = 0, skip, value;
03144         int k;
03145 
03146         while (!last) {
03147             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
03148             i += skip;
03149             if (i > 63)
03150                 break;
03151             if (v->fcm == PROGRESSIVE)
03152                 block[v->zz_8x8[0][i++]] = value;
03153             else {
03154                 if (use_pred && (v->fcm == ILACE_FRAME)) {
03155                     if (!dc_pred_dir) // top
03156                         block[v->zz_8x8[2][i++]] = value;
03157                     else // left
03158                         block[v->zz_8x8[3][i++]] = value;
03159                 } else {
03160                     block[v->zzi_8x8[i++]] = value;
03161                 }
03162             }
03163         }
03164 
03165         /* apply AC prediction if needed */
03166         if (use_pred) {
03167             /* scale predictors if needed*/
03168             if (q2 && q1 != q2) {
03169                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03170                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03171 
03172                 if (dc_pred_dir) { // left
03173                     for (k = 1; k < 8; k++)
03174                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03175                 } else { //top
03176                     for (k = 1; k < 8; k++)
03177                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03178                 }
03179             } else {
03180                 if (dc_pred_dir) { // left
03181                     for (k = 1; k < 8; k++)
03182                         block[k << v->left_blk_sh] += ac_val[k];
03183                 } else { // top
03184                     for (k = 1; k < 8; k++)
03185                         block[k << v->top_blk_sh] += ac_val[k + 8];
03186                 }
03187             }
03188         }
03189         /* save AC coeffs for further prediction */
03190         for (k = 1; k < 8; k++) {
03191             ac_val2[k    ] = block[k << v->left_blk_sh];
03192             ac_val2[k + 8] = block[k << v->top_blk_sh];
03193         }
03194 
03195         /* scale AC coeffs */
03196         for (k = 1; k < 64; k++)
03197             if (block[k]) {
03198                 block[k] *= scale;
03199                 if (!v->pquantizer)
03200                     block[k] += (block[k] < 0) ? -mquant : mquant;
03201             }
03202 
03203         if (use_pred) i = 63;
03204     } else { // no AC coeffs
03205         int k;
03206 
03207         memset(ac_val2, 0, 16 * 2);
03208         if (dc_pred_dir) { // left
03209             if (use_pred) {
03210                 memcpy(ac_val2, ac_val, 8 * 2);
03211                 if (q2 && q1 != q2) {
03212                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03213                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03214                     for (k = 1; k < 8; k++)
03215                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03216                 }
03217             }
03218         } else { // top
03219             if (use_pred) {
03220                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
03221                 if (q2 && q1 != q2) {
03222                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
03223                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
03224                     for (k = 1; k < 8; k++)
03225                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
03226                 }
03227             }
03228         }
03229 
03230         /* apply AC prediction if needed */
03231         if (use_pred) {
03232             if (dc_pred_dir) { // left
03233                 for (k = 1; k < 8; k++) {
03234                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
03235                     if (!v->pquantizer && block[k << v->left_blk_sh])
03236                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
03237                 }
03238             } else { // top
03239                 for (k = 1; k < 8; k++) {
03240                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
03241                     if (!v->pquantizer && block[k << v->top_blk_sh])
03242                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
03243                 }
03244             }
03245             i = 63;
03246         }
03247     }
03248     s->block_last_index[n] = i;
03249 
03250     return 0;
03251 }
03252 
03255 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
03256                               int mquant, int ttmb, int first_block,
03257                               uint8_t *dst, int linesize, int skip_block,
03258                               int *ttmb_out)
03259 {
03260     MpegEncContext *s = &v->s;
03261     GetBitContext *gb = &s->gb;
03262     int i, j;
03263     int subblkpat = 0;
03264     int scale, off, idx, last, skip, value;
03265     int ttblk = ttmb & 7;
03266     int pat = 0;
03267 
03268     s->dsp.clear_block(block);
03269 
03270     if (ttmb == -1) {
03271         ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
03272     }
03273     if (ttblk == TT_4X4) {
03274         subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
03275     }
03276     if ((ttblk != TT_8X8 && ttblk != TT_4X4)
03277         && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
03278             || (!v->res_rtm_flag && !first_block))) {
03279         subblkpat = decode012(gb);
03280         if (subblkpat)
03281             subblkpat ^= 3; // swap decoded pattern bits
03282         if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
03283             ttblk = TT_8X4;
03284         if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
03285             ttblk = TT_4X8;
03286     }
03287     scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
03288 
03289     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
03290     if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
03291         subblkpat = 2 - (ttblk == TT_8X4_TOP);
03292         ttblk     = TT_8X4;
03293     }
03294     if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
03295         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
03296         ttblk     = TT_4X8;
03297     }
03298     switch (ttblk) {
03299     case TT_8X8:
03300         pat  = 0xF;
03301         i    = 0;
03302         last = 0;
03303         while (!last) {
03304             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03305             i += skip;
03306             if (i > 63)
03307                 break;
03308             if (!v->fcm)
03309                 idx = v->zz_8x8[0][i++];
03310             else
03311                 idx = v->zzi_8x8[i++];
03312             block[idx] = value * scale;
03313             if (!v->pquantizer)
03314                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
03315         }
03316         if (!skip_block) {
03317             if (i == 1)
03318                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
03319             else {
03320                 v->vc1dsp.vc1_inv_trans_8x8(block);
03321                 s->dsp.add_pixels_clamped(block, dst, linesize);
03322             }
03323         }
03324         break;
03325     case TT_4X4:
03326         pat = ~subblkpat & 0xF;
03327         for (j = 0; j < 4; j++) {
03328             last = subblkpat & (1 << (3 - j));
03329             i    = 0;
03330             off  = (j & 1) * 4 + (j & 2) * 16;
03331             while (!last) {
03332                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03333                 i += skip;
03334                 if (i > 15)
03335                     break;
03336                 if (!v->fcm)
03337                     idx = ff_vc1_simple_progressive_4x4_zz[i++];
03338                 else
03339                     idx = ff_vc1_adv_interlaced_4x4_zz[i++];
03340                 block[idx + off] = value * scale;
03341                 if (!v->pquantizer)
03342                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
03343             }
03344             if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
03345                 if (i == 1)
03346                     v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
03347                 else
03348                     v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) *  2 * linesize, linesize, block + off);
03349             }
03350         }
03351         break;
03352     case TT_8X4:
03353         pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
03354         for (j = 0; j < 2; j++) {
03355             last = subblkpat & (1 << (1 - j));
03356             i    = 0;
03357             off  = j * 32;
03358             while (!last) {
03359                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03360                 i += skip;
03361                 if (i > 31)
03362                     break;
03363                 if (!v->fcm)
03364                     idx = v->zz_8x4[i++] + off;
03365                 else
03366                     idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
03367                 block[idx] = value * scale;
03368                 if (!v->pquantizer)
03369                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
03370             }
03371             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
03372                 if (i == 1)
03373                     v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
03374                 else
03375                     v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
03376             }
03377         }
03378         break;
03379     case TT_4X8:
03380         pat = ~(subblkpat * 5) & 0xF;
03381         for (j = 0; j < 2; j++) {
03382             last = subblkpat & (1 << (1 - j));
03383             i    = 0;
03384             off  = j * 4;
03385             while (!last) {
03386                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
03387                 i += skip;
03388                 if (i > 31)
03389                     break;
03390                 if (!v->fcm)
03391                     idx = v->zz_4x8[i++] + off;
03392                 else
03393                     idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
03394                 block[idx] = value * scale;
03395                 if (!v->pquantizer)
03396                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
03397             }
03398             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
03399                 if (i == 1)
03400                     v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
03401                 else
03402                     v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
03403             }
03404         }
03405         break;
03406     }
03407     if (ttmb_out)
03408         *ttmb_out |= ttblk << (n * 4);
03409     return pat;
03410 }
03411  // Macroblock group
03413 
03414 static const int size_table  [6] = { 0, 2, 3, 4,  5,  8 };
03415 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
03416 
03417 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
03418 {
03419     MpegEncContext *s  = &v->s;
03420     int mb_cbp         = v->cbp[s->mb_x - s->mb_stride],
03421         block_cbp      = mb_cbp      >> (block_num * 4), bottom_cbp,
03422         mb_is_intra    = v->is_intra[s->mb_x - s->mb_stride],
03423         block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
03424     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
03425     uint8_t *dst;
03426 
03427     if (block_num > 3) {
03428         dst      = s->dest[block_num - 3];
03429     } else {
03430         dst      = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
03431     }
03432     if (s->mb_y != s->end_mb_y || block_num < 2) {
03433         int16_t (*mv)[2];
03434         int mv_stride;
03435 
03436         if (block_num > 3) {
03437             bottom_cbp      = v->cbp[s->mb_x]      >> (block_num * 4);
03438             bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
03439             mv              = &v->luma_mv[s->mb_x - s->mb_stride];
03440             mv_stride       = s->mb_stride;
03441         } else {
03442             bottom_cbp      = (block_num < 2) ? (mb_cbp               >> ((block_num + 2) * 4))
03443                                               : (v->cbp[s->mb_x]      >> ((block_num - 2) * 4));
03444             bottom_is_intra = (block_num < 2) ? (mb_is_intra          >> ((block_num + 2) * 4))
03445                                               : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
03446             mv_stride       = s->b8_stride;
03447             mv              = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
03448         }
03449 
03450         if (bottom_is_intra & 1 || block_is_intra & 1 ||
03451             mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
03452             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03453         } else {
03454             idx = ((bottom_cbp >> 2) | block_cbp) & 3;
03455             if (idx == 3) {
03456                 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03457             } else if (idx) {
03458                 if (idx == 1)
03459                     v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
03460                 else
03461                     v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
03462             }
03463         }
03464     }
03465 
03466     dst -= 4 * linesize;
03467     ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
03468     if (ttblk == TT_4X4 || ttblk == TT_8X4) {
03469         idx = (block_cbp | (block_cbp >> 2)) & 3;
03470         if (idx == 3) {
03471             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
03472         } else if (idx) {
03473             if (idx == 1)
03474                 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
03475             else
03476                 v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
03477         }
03478     }
03479 }
03480 
03481 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
03482 {
03483     MpegEncContext *s  = &v->s;
03484     int mb_cbp         = v->cbp[s->mb_x - 1 - s->mb_stride],
03485         block_cbp      = mb_cbp      >> (block_num * 4), right_cbp,
03486         mb_is_intra    = v->is_intra[s->mb_x - 1 - s->mb_stride],
03487         block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
03488     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
03489     uint8_t *dst;
03490 
03491     if (block_num > 3) {
03492         dst = s->dest[block_num - 3] - 8 * linesize;
03493     } else {
03494         dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
03495     }
03496 
03497     if (s->mb_x != s->mb_width || !(block_num & 5)) {
03498         int16_t (*mv)[2];
03499 
03500         if (block_num > 3) {
03501             right_cbp      = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
03502             right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
03503             mv             = &v->luma_mv[s->mb_x - s->mb_stride - 1];
03504         } else {
03505             right_cbp      = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride]      >> ((block_num - 1) * 4))
03506                                              : (mb_cbp                              >> ((block_num + 1) * 4));
03507             right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
03508                                              : (mb_is_intra                         >> ((block_num + 1) * 4));
03509             mv             = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
03510         }
03511         if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
03512             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03513         } else {
03514             idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
03515             if (idx == 5) {
03516                 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03517             } else if (idx) {
03518                 if (idx == 1)
03519                     v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
03520                 else
03521                     v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
03522             }
03523         }
03524     }
03525 
03526     dst -= 4;
03527     ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
03528     if (ttblk == TT_4X4 || ttblk == TT_4X8) {
03529         idx = (block_cbp | (block_cbp >> 1)) & 5;
03530         if (idx == 5) {
03531             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
03532         } else if (idx) {
03533             if (idx == 1)
03534                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
03535             else
03536                 v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
03537         }
03538     }
03539 }
03540 
03541 static void vc1_apply_p_loop_filter(VC1Context *v)
03542 {
03543     MpegEncContext *s = &v->s;
03544     int i;
03545 
03546     for (i = 0; i < 6; i++) {
03547         vc1_apply_p_v_loop_filter(v, i);
03548     }
03549 
03550     /* V always precedes H, therefore we run H one MB before V;
03551      * at the end of a row, we catch up to complete the row */
03552     if (s->mb_x) {
03553         for (i = 0; i < 6; i++) {
03554             vc1_apply_p_h_loop_filter(v, i);
03555         }
03556         if (s->mb_x == s->mb_width - 1) {
03557             s->mb_x++;
03558             ff_update_block_index(s);
03559             for (i = 0; i < 6; i++) {
03560                 vc1_apply_p_h_loop_filter(v, i);
03561             }
03562         }
03563     }
03564 }
03565 
03568 static int vc1_decode_p_mb(VC1Context *v)
03569 {
03570     MpegEncContext *s = &v->s;
03571     GetBitContext *gb = &s->gb;
03572     int i, j;
03573     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03574     int cbp; /* cbp decoding stuff */
03575     int mqdiff, mquant; /* MB quantization */
03576     int ttmb = v->ttfrm; /* MB Transform type */
03577 
03578     int mb_has_coeffs = 1; /* last_flag */
03579     int dmv_x, dmv_y; /* Differential MV components */
03580     int index, index1; /* LUT indexes */
03581     int val, sign; /* temp values */
03582     int first_block = 1;
03583     int dst_idx, off;
03584     int skipped, fourmv;
03585     int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
03586 
03587     mquant = v->pq; /* lossy initialization */
03588 
03589     if (v->mv_type_is_raw)
03590         fourmv = get_bits1(gb);
03591     else
03592         fourmv = v->mv_type_mb_plane[mb_pos];
03593     if (v->skip_is_raw)
03594         skipped = get_bits1(gb);
03595     else
03596         skipped = v->s.mbskip_table[mb_pos];
03597 
03598     if (!fourmv) { /* 1MV mode */
03599         if (!skipped) {
03600             GET_MVDATA(dmv_x, dmv_y);
03601 
03602             if (s->mb_intra) {
03603                 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
03604                 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
03605             }
03606             s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
03607             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03608 
03609             /* FIXME Set DC val for inter block ? */
03610             if (s->mb_intra && !mb_has_coeffs) {
03611                 GET_MQUANT();
03612                 s->ac_pred = get_bits1(gb);
03613                 cbp        = 0;
03614             } else if (mb_has_coeffs) {
03615                 if (s->mb_intra)
03616                     s->ac_pred = get_bits1(gb);
03617                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03618                 GET_MQUANT();
03619             } else {
03620                 mquant = v->pq;
03621                 cbp    = 0;
03622             }
03623             s->current_picture.f.qscale_table[mb_pos] = mquant;
03624 
03625             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
03626                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
03627                                 VC1_TTMB_VLC_BITS, 2);
03628             if (!s->mb_intra) vc1_mc_1mv(v, 0);
03629             dst_idx = 0;
03630             for (i = 0; i < 6; i++) {
03631                 s->dc_val[0][s->block_index[i]] = 0;
03632                 dst_idx += i >> 2;
03633                 val = ((cbp >> (5 - i)) & 1);
03634                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03635                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03636                 if (s->mb_intra) {
03637                     /* check if prediction blocks A and C are available */
03638                     v->a_avail = v->c_avail = 0;
03639                     if (i == 2 || i == 3 || !s->first_slice_line)
03640                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03641                     if (i == 1 || i == 3 || s->mb_x)
03642                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03643 
03644                     vc1_decode_intra_block(v, s->block[i], i, val, mquant,
03645                                            (i & 4) ? v->codingset2 : v->codingset);
03646                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
03647                         continue;
03648                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03649                     if (v->rangeredfrm)
03650                         for (j = 0; j < 64; j++)
03651                             s->block[i][j] <<= 1;
03652                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03653                     if (v->pq >= 9 && v->overlap) {
03654                         if (v->c_avail)
03655                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03656                         if (v->a_avail)
03657                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03658                     }
03659                     block_cbp   |= 0xF << (i << 2);
03660                     block_intra |= 1 << i;
03661                 } else if (val) {
03662                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
03663                                              s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
03664                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
03665                     block_cbp |= pat << (i << 2);
03666                     if (!v->ttmbf && ttmb < 8)
03667                         ttmb = -1;
03668                     first_block = 0;
03669                 }
03670             }
03671         } else { // skipped
03672             s->mb_intra = 0;
03673             for (i = 0; i < 6; i++) {
03674                 v->mb_type[0][s->block_index[i]] = 0;
03675                 s->dc_val[0][s->block_index[i]]  = 0;
03676             }
03677             s->current_picture.f.mb_type[mb_pos]      = MB_TYPE_SKIP;
03678             s->current_picture.f.qscale_table[mb_pos] = 0;
03679             vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03680             vc1_mc_1mv(v, 0);
03681         }
03682     } else { // 4MV mode
03683         if (!skipped /* unskipped MB */) {
03684             int intra_count = 0, coded_inter = 0;
03685             int is_intra[6], is_coded[6];
03686             /* Get CBPCY */
03687             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03688             for (i = 0; i < 6; i++) {
03689                 val = ((cbp >> (5 - i)) & 1);
03690                 s->dc_val[0][s->block_index[i]] = 0;
03691                 s->mb_intra                     = 0;
03692                 if (i < 4) {
03693                     dmv_x = dmv_y = 0;
03694                     s->mb_intra   = 0;
03695                     mb_has_coeffs = 0;
03696                     if (val) {
03697                         GET_MVDATA(dmv_x, dmv_y);
03698                     }
03699                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03700                     if (!s->mb_intra)
03701                         vc1_mc_4mv_luma(v, i, 0);
03702                     intra_count += s->mb_intra;
03703                     is_intra[i]  = s->mb_intra;
03704                     is_coded[i]  = mb_has_coeffs;
03705                 }
03706                 if (i & 4) {
03707                     is_intra[i] = (intra_count >= 3);
03708                     is_coded[i] = val;
03709                 }
03710                 if (i == 4)
03711                     vc1_mc_4mv_chroma(v, 0);
03712                 v->mb_type[0][s->block_index[i]] = is_intra[i];
03713                 if (!coded_inter)
03714                     coded_inter = !is_intra[i] & is_coded[i];
03715             }
03716             // if there are no coded blocks then don't do anything more
03717             dst_idx = 0;
03718             if (!intra_count && !coded_inter)
03719                 goto end;
03720             GET_MQUANT();
03721             s->current_picture.f.qscale_table[mb_pos] = mquant;
03722             /* test if block is intra and has pred */
03723             {
03724                 int intrapred = 0;
03725                 for (i = 0; i < 6; i++)
03726                     if (is_intra[i]) {
03727                         if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
03728                             || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
03729                             intrapred = 1;
03730                             break;
03731                         }
03732                     }
03733                 if (intrapred)
03734                     s->ac_pred = get_bits1(gb);
03735                 else
03736                     s->ac_pred = 0;
03737             }
03738             if (!v->ttmbf && coded_inter)
03739                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03740             for (i = 0; i < 6; i++) {
03741                 dst_idx    += i >> 2;
03742                 off         = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03743                 s->mb_intra = is_intra[i];
03744                 if (is_intra[i]) {
03745                     /* check if prediction blocks A and C are available */
03746                     v->a_avail = v->c_avail = 0;
03747                     if (i == 2 || i == 3 || !s->first_slice_line)
03748                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03749                     if (i == 1 || i == 3 || s->mb_x)
03750                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03751 
03752                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
03753                                            (i & 4) ? v->codingset2 : v->codingset);
03754                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
03755                         continue;
03756                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03757                     if (v->rangeredfrm)
03758                         for (j = 0; j < 64; j++)
03759                             s->block[i][j] <<= 1;
03760                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
03761                                                      (i & 4) ? s->uvlinesize : s->linesize);
03762                     if (v->pq >= 9 && v->overlap) {
03763                         if (v->c_avail)
03764                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03765                         if (v->a_avail)
03766                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
03767                     }
03768                     block_cbp   |= 0xF << (i << 2);
03769                     block_intra |= 1 << i;
03770                 } else if (is_coded[i]) {
03771                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
03772                                              first_block, s->dest[dst_idx] + off,
03773                                              (i & 4) ? s->uvlinesize : s->linesize,
03774                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY),
03775                                              &block_tt);
03776                     block_cbp |= pat << (i << 2);
03777                     if (!v->ttmbf && ttmb < 8)
03778                         ttmb = -1;
03779                     first_block = 0;
03780                 }
03781             }
03782         } else { // skipped MB
03783             s->mb_intra                               = 0;
03784             s->current_picture.f.qscale_table[mb_pos] = 0;
03785             for (i = 0; i < 6; i++) {
03786                 v->mb_type[0][s->block_index[i]] = 0;
03787                 s->dc_val[0][s->block_index[i]]  = 0;
03788             }
03789             for (i = 0; i < 4; i++) {
03790                 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
03791                 vc1_mc_4mv_luma(v, i, 0);
03792             }
03793             vc1_mc_4mv_chroma(v, 0);
03794             s->current_picture.f.qscale_table[mb_pos] = 0;
03795         }
03796     }
03797 end:
03798     v->cbp[s->mb_x]      = block_cbp;
03799     v->ttblk[s->mb_x]    = block_tt;
03800     v->is_intra[s->mb_x] = block_intra;
03801 
03802     return 0;
03803 }
03804 
03805 /* Decode one macroblock in an interlaced frame p picture */
03806 
03807 static int vc1_decode_p_mb_intfr(VC1Context *v)
03808 {
03809     MpegEncContext *s = &v->s;
03810     GetBitContext *gb = &s->gb;
03811     int i;
03812     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03813     int cbp = 0; /* cbp decoding stuff */
03814     int mqdiff, mquant; /* MB quantization */
03815     int ttmb = v->ttfrm; /* MB Transform type */
03816 
03817     int mb_has_coeffs = 1; /* last_flag */
03818     int dmv_x, dmv_y; /* Differential MV components */
03819     int val; /* temp value */
03820     int first_block = 1;
03821     int dst_idx, off;
03822     int skipped, fourmv = 0, twomv = 0;
03823     int block_cbp = 0, pat, block_tt = 0;
03824     int idx_mbmode = 0, mvbp;
03825     int stride_y, fieldtx;
03826 
03827     mquant = v->pq; /* Loosy initialization */
03828 
03829     if (v->skip_is_raw)
03830         skipped = get_bits1(gb);
03831     else
03832         skipped = v->s.mbskip_table[mb_pos];
03833     if (!skipped) {
03834         if (v->fourmvswitch)
03835             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
03836         else
03837             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
03838         switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
03839         /* store the motion vector type in a flag (useful later) */
03840         case MV_PMODE_INTFR_4MV:
03841             fourmv = 1;
03842             v->blk_mv_type[s->block_index[0]] = 0;
03843             v->blk_mv_type[s->block_index[1]] = 0;
03844             v->blk_mv_type[s->block_index[2]] = 0;
03845             v->blk_mv_type[s->block_index[3]] = 0;
03846             break;
03847         case MV_PMODE_INTFR_4MV_FIELD:
03848             fourmv = 1;
03849             v->blk_mv_type[s->block_index[0]] = 1;
03850             v->blk_mv_type[s->block_index[1]] = 1;
03851             v->blk_mv_type[s->block_index[2]] = 1;
03852             v->blk_mv_type[s->block_index[3]] = 1;
03853             break;
03854         case MV_PMODE_INTFR_2MV_FIELD:
03855             twomv = 1;
03856             v->blk_mv_type[s->block_index[0]] = 1;
03857             v->blk_mv_type[s->block_index[1]] = 1;
03858             v->blk_mv_type[s->block_index[2]] = 1;
03859             v->blk_mv_type[s->block_index[3]] = 1;
03860             break;
03861         case MV_PMODE_INTFR_1MV:
03862             v->blk_mv_type[s->block_index[0]] = 0;
03863             v->blk_mv_type[s->block_index[1]] = 0;
03864             v->blk_mv_type[s->block_index[2]] = 0;
03865             v->blk_mv_type[s->block_index[3]] = 0;
03866             break;
03867         }
03868         if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
03869             s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
03870             s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
03871             s->current_picture.f.mb_type[mb_pos]                     = MB_TYPE_INTRA;
03872             s->mb_intra = v->is_intra[s->mb_x] = 1;
03873             for (i = 0; i < 6; i++)
03874                 v->mb_type[0][s->block_index[i]] = 1;
03875             fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
03876             mb_has_coeffs = get_bits1(gb);
03877             if (mb_has_coeffs)
03878                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03879             v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
03880             GET_MQUANT();
03881             s->current_picture.f.qscale_table[mb_pos] = mquant;
03882             /* Set DC scale - y and c use the same (not sure if necessary here) */
03883             s->y_dc_scale = s->y_dc_scale_table[mquant];
03884             s->c_dc_scale = s->c_dc_scale_table[mquant];
03885             dst_idx = 0;
03886             for (i = 0; i < 6; i++) {
03887                 s->dc_val[0][s->block_index[i]] = 0;
03888                 dst_idx += i >> 2;
03889                 val = ((cbp >> (5 - i)) & 1);
03890                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
03891                 v->a_avail = v->c_avail = 0;
03892                 if (i == 2 || i == 3 || !s->first_slice_line)
03893                     v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
03894                 if (i == 1 || i == 3 || s->mb_x)
03895                     v->c_avail = v->mb_type[0][s->block_index[i] - 1];
03896 
03897                 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
03898                                        (i & 4) ? v->codingset2 : v->codingset);
03899                 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
03900                 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
03901                 if (i < 4) {
03902                     stride_y = s->linesize << fieldtx;
03903                     off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
03904                 } else {
03905                     stride_y = s->uvlinesize;
03906                     off = 0;
03907                 }
03908                 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
03909                 //TODO: loop filter
03910             }
03911 
03912         } else { // inter MB
03913             mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
03914             if (mb_has_coeffs)
03915                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
03916             if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
03917                 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
03918             } else {
03919                 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
03920                     || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
03921                     v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
03922                 }
03923             }
03924             s->mb_intra = v->is_intra[s->mb_x] = 0;
03925             for (i = 0; i < 6; i++)
03926                 v->mb_type[0][s->block_index[i]] = 0;
03927             fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
03928             /* for all motion vector read MVDATA and motion compensate each block */
03929             dst_idx = 0;
03930             if (fourmv) {
03931                 mvbp = v->fourmvbp;
03932                 for (i = 0; i < 6; i++) {
03933                     if (i < 4) {
03934                         dmv_x = dmv_y = 0;
03935                         val   = ((mvbp >> (3 - i)) & 1);
03936                         if (val) {
03937                             get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03938                         }
03939                         vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
03940                         vc1_mc_4mv_luma(v, i, 0);
03941                     } else if (i == 4) {
03942                         vc1_mc_4mv_chroma4(v);
03943                     }
03944                 }
03945             } else if (twomv) {
03946                 mvbp  = v->twomvbp;
03947                 dmv_x = dmv_y = 0;
03948                 if (mvbp & 2) {
03949                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03950                 }
03951                 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
03952                 vc1_mc_4mv_luma(v, 0, 0);
03953                 vc1_mc_4mv_luma(v, 1, 0);
03954                 dmv_x = dmv_y = 0;
03955                 if (mvbp & 1) {
03956                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03957                 }
03958                 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
03959                 vc1_mc_4mv_luma(v, 2, 0);
03960                 vc1_mc_4mv_luma(v, 3, 0);
03961                 vc1_mc_4mv_chroma4(v);
03962             } else {
03963                 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
03964                 if (mvbp) {
03965                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
03966                 }
03967                 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
03968                 vc1_mc_1mv(v, 0);
03969             }
03970             if (cbp)
03971                 GET_MQUANT();  // p. 227
03972             s->current_picture.f.qscale_table[mb_pos] = mquant;
03973             if (!v->ttmbf && cbp)
03974                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
03975             for (i = 0; i < 6; i++) {
03976                 s->dc_val[0][s->block_index[i]] = 0;
03977                 dst_idx += i >> 2;
03978                 val = ((cbp >> (5 - i)) & 1);
03979                 if (!fieldtx)
03980                     off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
03981                 else
03982                     off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
03983                 if (val) {
03984                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
03985                                              first_block, s->dest[dst_idx] + off,
03986                                              (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
03987                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
03988                     block_cbp |= pat << (i << 2);
03989                     if (!v->ttmbf && ttmb < 8)
03990                         ttmb = -1;
03991                     first_block = 0;
03992                 }
03993             }
03994         }
03995     } else { // skipped
03996         s->mb_intra = v->is_intra[s->mb_x] = 0;
03997         for (i = 0; i < 6; i++) {
03998             v->mb_type[0][s->block_index[i]] = 0;
03999             s->dc_val[0][s->block_index[i]] = 0;
04000         }
04001         s->current_picture.f.mb_type[mb_pos]      = MB_TYPE_SKIP;
04002         s->current_picture.f.qscale_table[mb_pos] = 0;
04003         v->blk_mv_type[s->block_index[0]] = 0;
04004         v->blk_mv_type[s->block_index[1]] = 0;
04005         v->blk_mv_type[s->block_index[2]] = 0;
04006         v->blk_mv_type[s->block_index[3]] = 0;
04007         vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
04008         vc1_mc_1mv(v, 0);
04009     }
04010     if (s->mb_x == s->mb_width - 1)
04011         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
04012     return 0;
04013 }
04014 
04015 static int vc1_decode_p_mb_intfi(VC1Context *v)
04016 {
04017     MpegEncContext *s = &v->s;
04018     GetBitContext *gb = &s->gb;
04019     int i;
04020     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04021     int cbp = 0; /* cbp decoding stuff */
04022     int mqdiff, mquant; /* MB quantization */
04023     int ttmb = v->ttfrm; /* MB Transform type */
04024 
04025     int mb_has_coeffs = 1; /* last_flag */
04026     int dmv_x, dmv_y; /* Differential MV components */
04027     int val; /* temp values */
04028     int first_block = 1;
04029     int dst_idx, off;
04030     int pred_flag;
04031     int block_cbp = 0, pat, block_tt = 0;
04032     int idx_mbmode = 0;
04033 
04034     mquant = v->pq; /* Loosy initialization */
04035 
04036     idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
04037     if (idx_mbmode <= 1) { // intra MB
04038         s->mb_intra = v->is_intra[s->mb_x] = 1;
04039         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
04040         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
04041         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
04042         GET_MQUANT();
04043         s->current_picture.f.qscale_table[mb_pos] = mquant;
04044         /* Set DC scale - y and c use the same (not sure if necessary here) */
04045         s->y_dc_scale = s->y_dc_scale_table[mquant];
04046         s->c_dc_scale = s->c_dc_scale_table[mquant];
04047         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
04048         mb_has_coeffs = idx_mbmode & 1;
04049         if (mb_has_coeffs)
04050             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
04051         dst_idx = 0;
04052         for (i = 0; i < 6; i++) {
04053             s->dc_val[0][s->block_index[i]]  = 0;
04054             v->mb_type[0][s->block_index[i]] = 1;
04055             dst_idx += i >> 2;
04056             val = ((cbp >> (5 - i)) & 1);
04057             v->a_avail = v->c_avail = 0;
04058             if (i == 2 || i == 3 || !s->first_slice_line)
04059                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04060             if (i == 1 || i == 3 || s->mb_x)
04061                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04062 
04063             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04064                                    (i & 4) ? v->codingset2 : v->codingset);
04065             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04066                 continue;
04067             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04068             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04069             off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
04070             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
04071             // TODO: loop filter
04072         }
04073     } else {
04074         s->mb_intra = v->is_intra[s->mb_x] = 0;
04075         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
04076         for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
04077         if (idx_mbmode <= 5) { // 1-MV
04078             dmv_x = dmv_y = 0;
04079             if (idx_mbmode & 1) {
04080                 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
04081             }
04082             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
04083             vc1_mc_1mv(v, 0);
04084             mb_has_coeffs = !(idx_mbmode & 2);
04085         } else { // 4-MV
04086             v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
04087             for (i = 0; i < 6; i++) {
04088                 if (i < 4) {
04089                     dmv_x = dmv_y = pred_flag = 0;
04090                     val   = ((v->fourmvbp >> (3 - i)) & 1);
04091                     if (val) {
04092                         get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
04093                     }
04094                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
04095                     vc1_mc_4mv_luma(v, i, 0);
04096                 } else if (i == 4)
04097                     vc1_mc_4mv_chroma(v, 0);
04098             }
04099             mb_has_coeffs = idx_mbmode & 1;
04100         }
04101         if (mb_has_coeffs)
04102             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04103         if (cbp) {
04104             GET_MQUANT();
04105         }
04106         s->current_picture.f.qscale_table[mb_pos] = mquant;
04107         if (!v->ttmbf && cbp) {
04108             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04109         }
04110         dst_idx = 0;
04111         for (i = 0; i < 6; i++) {
04112             s->dc_val[0][s->block_index[i]] = 0;
04113             dst_idx += i >> 2;
04114             val = ((cbp >> (5 - i)) & 1);
04115             off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
04116             if (v->cur_field_type)
04117                 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
04118             if (val) {
04119                 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04120                                          first_block, s->dest[dst_idx] + off,
04121                                          (i & 4) ? s->uvlinesize : s->linesize,
04122                                          (i & 4) && (s->flags & CODEC_FLAG_GRAY),
04123                                          &block_tt);
04124                 block_cbp |= pat << (i << 2);
04125                 if (!v->ttmbf && ttmb < 8) ttmb = -1;
04126                 first_block = 0;
04127             }
04128         }
04129     }
04130     if (s->mb_x == s->mb_width - 1)
04131         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
04132     return 0;
04133 }
04134 
04137 static void vc1_decode_b_mb(VC1Context *v)
04138 {
04139     MpegEncContext *s = &v->s;
04140     GetBitContext *gb = &s->gb;
04141     int i, j;
04142     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04143     int cbp = 0; /* cbp decoding stuff */
04144     int mqdiff, mquant; /* MB quantization */
04145     int ttmb = v->ttfrm; /* MB Transform type */
04146     int mb_has_coeffs = 0; /* last_flag */
04147     int index, index1; /* LUT indexes */
04148     int val, sign; /* temp values */
04149     int first_block = 1;
04150     int dst_idx, off;
04151     int skipped, direct;
04152     int dmv_x[2], dmv_y[2];
04153     int bmvtype = BMV_TYPE_BACKWARD;
04154 
04155     mquant      = v->pq; /* lossy initialization */
04156     s->mb_intra = 0;
04157 
04158     if (v->dmb_is_raw)
04159         direct = get_bits1(gb);
04160     else
04161         direct = v->direct_mb_plane[mb_pos];
04162     if (v->skip_is_raw)
04163         skipped = get_bits1(gb);
04164     else
04165         skipped = v->s.mbskip_table[mb_pos];
04166 
04167     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
04168     for (i = 0; i < 6; i++) {
04169         v->mb_type[0][s->block_index[i]] = 0;
04170         s->dc_val[0][s->block_index[i]]  = 0;
04171     }
04172     s->current_picture.f.qscale_table[mb_pos] = 0;
04173 
04174     if (!direct) {
04175         if (!skipped) {
04176             GET_MVDATA(dmv_x[0], dmv_y[0]);
04177             dmv_x[1] = dmv_x[0];
04178             dmv_y[1] = dmv_y[0];
04179         }
04180         if (skipped || !s->mb_intra) {
04181             bmvtype = decode012(gb);
04182             switch (bmvtype) {
04183             case 0:
04184                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
04185                 break;
04186             case 1:
04187                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
04188                 break;
04189             case 2:
04190                 bmvtype  = BMV_TYPE_INTERPOLATED;
04191                 dmv_x[0] = dmv_y[0] = 0;
04192             }
04193         }
04194     }
04195     for (i = 0; i < 6; i++)
04196         v->mb_type[0][s->block_index[i]] = s->mb_intra;
04197 
04198     if (skipped) {
04199         if (direct)
04200             bmvtype = BMV_TYPE_INTERPOLATED;
04201         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04202         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04203         return;
04204     }
04205     if (direct) {
04206         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04207         GET_MQUANT();
04208         s->mb_intra = 0;
04209         s->current_picture.f.qscale_table[mb_pos] = mquant;
04210         if (!v->ttmbf)
04211             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04212         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
04213         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04214         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04215     } else {
04216         if (!mb_has_coeffs && !s->mb_intra) {
04217             /* no coded blocks - effectively skipped */
04218             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04219             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04220             return;
04221         }
04222         if (s->mb_intra && !mb_has_coeffs) {
04223             GET_MQUANT();
04224             s->current_picture.f.qscale_table[mb_pos] = mquant;
04225             s->ac_pred = get_bits1(gb);
04226             cbp = 0;
04227             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04228         } else {
04229             if (bmvtype == BMV_TYPE_INTERPOLATED) {
04230                 GET_MVDATA(dmv_x[0], dmv_y[0]);
04231                 if (!mb_has_coeffs) {
04232                     /* interpolated skipped block */
04233                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04234                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04235                     return;
04236                 }
04237             }
04238             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
04239             if (!s->mb_intra) {
04240                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
04241             }
04242             if (s->mb_intra)
04243                 s->ac_pred = get_bits1(gb);
04244             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04245             GET_MQUANT();
04246             s->current_picture.f.qscale_table[mb_pos] = mquant;
04247             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
04248                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04249         }
04250     }
04251     dst_idx = 0;
04252     for (i = 0; i < 6; i++) {
04253         s->dc_val[0][s->block_index[i]] = 0;
04254         dst_idx += i >> 2;
04255         val = ((cbp >> (5 - i)) & 1);
04256         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04257         v->mb_type[0][s->block_index[i]] = s->mb_intra;
04258         if (s->mb_intra) {
04259             /* check if prediction blocks A and C are available */
04260             v->a_avail = v->c_avail = 0;
04261             if (i == 2 || i == 3 || !s->first_slice_line)
04262                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04263             if (i == 1 || i == 3 || s->mb_x)
04264                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04265 
04266             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04267                                    (i & 4) ? v->codingset2 : v->codingset);
04268             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04269                 continue;
04270             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04271             if (v->rangeredfrm)
04272                 for (j = 0; j < 64; j++)
04273                     s->block[i][j] <<= 1;
04274             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
04275         } else if (val) {
04276             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04277                                first_block, s->dest[dst_idx] + off,
04278                                (i & 4) ? s->uvlinesize : s->linesize,
04279                                (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
04280             if (!v->ttmbf && ttmb < 8)
04281                 ttmb = -1;
04282             first_block = 0;
04283         }
04284     }
04285 }
04286 
04289 static void vc1_decode_b_mb_intfi(VC1Context *v)
04290 {
04291     MpegEncContext *s = &v->s;
04292     GetBitContext *gb = &s->gb;
04293     int i, j;
04294     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04295     int cbp = 0; /* cbp decoding stuff */
04296     int mqdiff, mquant; /* MB quantization */
04297     int ttmb = v->ttfrm; /* MB Transform type */
04298     int mb_has_coeffs = 0; /* last_flag */
04299     int val; /* temp value */
04300     int first_block = 1;
04301     int dst_idx, off;
04302     int fwd;
04303     int dmv_x[2], dmv_y[2], pred_flag[2];
04304     int bmvtype = BMV_TYPE_BACKWARD;
04305     int idx_mbmode, interpmvp;
04306 
04307     mquant      = v->pq; /* Loosy initialization */
04308     s->mb_intra = 0;
04309 
04310     idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
04311     if (idx_mbmode <= 1) { // intra MB
04312         s->mb_intra = v->is_intra[s->mb_x] = 1;
04313         s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
04314         s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
04315         s->current_picture.f.mb_type[mb_pos + v->mb_off]         = MB_TYPE_INTRA;
04316         GET_MQUANT();
04317         s->current_picture.f.qscale_table[mb_pos] = mquant;
04318         /* Set DC scale - y and c use the same (not sure if necessary here) */
04319         s->y_dc_scale = s->y_dc_scale_table[mquant];
04320         s->c_dc_scale = s->c_dc_scale_table[mquant];
04321         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
04322         mb_has_coeffs = idx_mbmode & 1;
04323         if (mb_has_coeffs)
04324             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
04325         dst_idx = 0;
04326         for (i = 0; i < 6; i++) {
04327             s->dc_val[0][s->block_index[i]] = 0;
04328             dst_idx += i >> 2;
04329             val = ((cbp >> (5 - i)) & 1);
04330             v->mb_type[0][s->block_index[i]] = s->mb_intra;
04331             v->a_avail                       = v->c_avail = 0;
04332             if (i == 2 || i == 3 || !s->first_slice_line)
04333                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
04334             if (i == 1 || i == 3 || s->mb_x)
04335                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
04336 
04337             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
04338                                    (i & 4) ? v->codingset2 : v->codingset);
04339             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
04340                 continue;
04341             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
04342             if (v->rangeredfrm)
04343                 for (j = 0; j < 64; j++)
04344                     s->block[i][j] <<= 1;
04345             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
04346             off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
04347             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
04348             // TODO: yet to perform loop filter
04349         }
04350     } else {
04351         s->mb_intra = v->is_intra[s->mb_x] = 0;
04352         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
04353         for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
04354         if (v->fmb_is_raw)
04355             fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
04356         else
04357             fwd = v->forward_mb_plane[mb_pos];
04358         if (idx_mbmode <= 5) { // 1-MV
04359             dmv_x[0]     = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
04360             pred_flag[0] = pred_flag[1] = 0;
04361             if (fwd)
04362                 bmvtype = BMV_TYPE_FORWARD;
04363             else {
04364                 bmvtype = decode012(gb);
04365                 switch (bmvtype) {
04366                 case 0:
04367                     bmvtype = BMV_TYPE_BACKWARD;
04368                     break;
04369                 case 1:
04370                     bmvtype = BMV_TYPE_DIRECT;
04371                     break;
04372                 case 2:
04373                     bmvtype   = BMV_TYPE_INTERPOLATED;
04374                     interpmvp = get_bits1(gb);
04375                 }
04376             }
04377             v->bmvtype = bmvtype;
04378             if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
04379                 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
04380             }
04381             if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
04382                 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
04383             }
04384             if (bmvtype == BMV_TYPE_DIRECT) {
04385                 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
04386                 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
04387             }
04388             vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
04389             vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
04390             mb_has_coeffs = !(idx_mbmode & 2);
04391         } else { // 4-MV
04392             if (fwd)
04393                 bmvtype = BMV_TYPE_FORWARD;
04394             v->bmvtype  = bmvtype;
04395             v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
04396             for (i = 0; i < 6; i++) {
04397                 if (i < 4) {
04398                     dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
04399                     dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
04400                     val = ((v->fourmvbp >> (3 - i)) & 1);
04401                     if (val) {
04402                         get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
04403                                                  &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
04404                                              &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
04405                     }
04406                     vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
04407                     vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
04408                 } else if (i == 4)
04409                     vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
04410             }
04411             mb_has_coeffs = idx_mbmode & 1;
04412         }
04413         if (mb_has_coeffs)
04414             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
04415         if (cbp) {
04416             GET_MQUANT();
04417         }
04418         s->current_picture.f.qscale_table[mb_pos] = mquant;
04419         if (!v->ttmbf && cbp) {
04420             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
04421         }
04422         dst_idx = 0;
04423         for (i = 0; i < 6; i++) {
04424             s->dc_val[0][s->block_index[i]] = 0;
04425             dst_idx += i >> 2;
04426             val = ((cbp >> (5 - i)) & 1);
04427             off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
04428             if (v->cur_field_type)
04429                 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
04430             if (val) {
04431                 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
04432                                    first_block, s->dest[dst_idx] + off,
04433                                    (i & 4) ? s->uvlinesize : s->linesize,
04434                                    (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
04435                 if (!v->ttmbf && ttmb < 8)
04436                     ttmb = -1;
04437                 first_block = 0;
04438             }
04439         }
04440     }
04441 }
04442 
04445 static void vc1_decode_i_blocks(VC1Context *v)
04446 {
04447     int k, j;
04448     MpegEncContext *s = &v->s;
04449     int cbp, val;
04450     uint8_t *coded_val;
04451     int mb_pos;
04452 
04453     /* select codingmode used for VLC tables selection */
04454     switch (v->y_ac_table_index) {
04455     case 0:
04456         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04457         break;
04458     case 1:
04459         v->codingset = CS_HIGH_MOT_INTRA;
04460         break;
04461     case 2:
04462         v->codingset = CS_MID_RATE_INTRA;
04463         break;
04464     }
04465 
04466     switch (v->c_ac_table_index) {
04467     case 0:
04468         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04469         break;
04470     case 1:
04471         v->codingset2 = CS_HIGH_MOT_INTER;
04472         break;
04473     case 2:
04474         v->codingset2 = CS_MID_RATE_INTER;
04475         break;
04476     }
04477 
04478     /* Set DC scale - y and c use the same */
04479     s->y_dc_scale = s->y_dc_scale_table[v->pq];
04480     s->c_dc_scale = s->c_dc_scale_table[v->pq];
04481 
04482     //do frame decode
04483     s->mb_x = s->mb_y = 0;
04484     s->mb_intra         = 1;
04485     s->first_slice_line = 1;
04486     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
04487         s->mb_x = 0;
04488         ff_init_block_index(s);
04489         for (; s->mb_x < s->mb_width; s->mb_x++) {
04490             uint8_t *dst[6];
04491             ff_update_block_index(s);
04492             dst[0] = s->dest[0];
04493             dst[1] = dst[0] + 8;
04494             dst[2] = s->dest[0] + s->linesize * 8;
04495             dst[3] = dst[2] + 8;
04496             dst[4] = s->dest[1];
04497             dst[5] = s->dest[2];
04498             s->dsp.clear_blocks(s->block[0]);
04499             mb_pos = s->mb_x + s->mb_y * s->mb_width;
04500             s->current_picture.f.mb_type[mb_pos]                     = MB_TYPE_INTRA;
04501             s->current_picture.f.qscale_table[mb_pos]                = v->pq;
04502             s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
04503             s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
04504 
04505             // do actual MB decoding and displaying
04506             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
04507             v->s.ac_pred = get_bits1(&v->s.gb);
04508 
04509             for (k = 0; k < 6; k++) {
04510                 val = ((cbp >> (5 - k)) & 1);
04511 
04512                 if (k < 4) {
04513                     int pred   = vc1_coded_block_pred(&v->s, k, &coded_val);
04514                     val        = val ^ pred;
04515                     *coded_val = val;
04516                 }
04517                 cbp |= val << (5 - k);
04518 
04519                 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
04520 
04521                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
04522                     continue;
04523                 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
04524                 if (v->pq >= 9 && v->overlap) {
04525                     if (v->rangeredfrm)
04526                         for (j = 0; j < 64; j++)
04527                             s->block[k][j] <<= 1;
04528                     s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
04529                 } else {
04530                     if (v->rangeredfrm)
04531                         for (j = 0; j < 64; j++)
04532                             s->block[k][j] = (s->block[k][j] - 64) << 1;
04533                     s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
04534                 }
04535             }
04536 
04537             if (v->pq >= 9 && v->overlap) {
04538                 if (s->mb_x) {
04539                     v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
04540                     v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
04541                     if (!(s->flags & CODEC_FLAG_GRAY)) {
04542                         v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
04543                         v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
04544                     }
04545                 }
04546                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
04547                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
04548                 if (!s->first_slice_line) {
04549                     v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
04550                     v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
04551                     if (!(s->flags & CODEC_FLAG_GRAY)) {
04552                         v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
04553                         v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
04554                     }
04555                 }
04556                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
04557                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
04558             }
04559             if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
04560 
04561             if (get_bits_count(&s->gb) > v->bits) {
04562                 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
04563                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
04564                        get_bits_count(&s->gb), v->bits);
04565                 return;
04566             }
04567         }
04568         if (!v->s.loop_filter)
04569             ff_draw_horiz_band(s, s->mb_y * 16, 16);
04570         else if (s->mb_y)
04571             ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04572 
04573         s->first_slice_line = 0;
04574     }
04575     if (v->s.loop_filter)
04576         ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
04577     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
04578 }
04579 
04582 static void vc1_decode_i_blocks_adv(VC1Context *v)
04583 {
04584     int k;
04585     MpegEncContext *s = &v->s;
04586     int cbp, val;
04587     uint8_t *coded_val;
04588     int mb_pos;
04589     int mquant = v->pq;
04590     int mqdiff;
04591     GetBitContext *gb = &s->gb;
04592 
04593     /* select codingmode used for VLC tables selection */
04594     switch (v->y_ac_table_index) {
04595     case 0:
04596         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04597         break;
04598     case 1:
04599         v->codingset = CS_HIGH_MOT_INTRA;
04600         break;
04601     case 2:
04602         v->codingset = CS_MID_RATE_INTRA;
04603         break;
04604     }
04605 
04606     switch (v->c_ac_table_index) {
04607     case 0:
04608         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04609         break;
04610     case 1:
04611         v->codingset2 = CS_HIGH_MOT_INTER;
04612         break;
04613     case 2:
04614         v->codingset2 = CS_MID_RATE_INTER;
04615         break;
04616     }
04617 
04618     // do frame decode
04619     s->mb_x             = s->mb_y = 0;
04620     s->mb_intra         = 1;
04621     s->first_slice_line = 1;
04622     s->mb_y             = s->start_mb_y;
04623     if (s->start_mb_y) {
04624         s->mb_x = 0;
04625         ff_init_block_index(s);
04626         memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
04627                (1 + s->b8_stride) * sizeof(*s->coded_block));
04628     }
04629     for (; s->mb_y < s->end_mb_y; s->mb_y++) {
04630         s->mb_x = 0;
04631         ff_init_block_index(s);
04632         for (;s->mb_x < s->mb_width; s->mb_x++) {
04633             DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
04634             ff_update_block_index(s);
04635             s->dsp.clear_blocks(block[0]);
04636             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
04637             s->current_picture.f.mb_type[mb_pos + v->mb_off]                         = MB_TYPE_INTRA;
04638             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
04639             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
04640 
04641             // do actual MB decoding and displaying
04642             if (v->fieldtx_is_raw)
04643                 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
04644             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
04645             if ( v->acpred_is_raw)
04646                 v->s.ac_pred = get_bits1(&v->s.gb);
04647             else
04648                 v->s.ac_pred = v->acpred_plane[mb_pos];
04649 
04650             if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
04651                 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
04652 
04653             GET_MQUANT();
04654 
04655             s->current_picture.f.qscale_table[mb_pos] = mquant;
04656             /* Set DC scale - y and c use the same */
04657             s->y_dc_scale = s->y_dc_scale_table[mquant];
04658             s->c_dc_scale = s->c_dc_scale_table[mquant];
04659 
04660             for (k = 0; k < 6; k++) {
04661                 val = ((cbp >> (5 - k)) & 1);
04662 
04663                 if (k < 4) {
04664                     int pred   = vc1_coded_block_pred(&v->s, k, &coded_val);
04665                     val        = val ^ pred;
04666                     *coded_val = val;
04667                 }
04668                 cbp |= val << (5 - k);
04669 
04670                 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
04671                 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
04672 
04673                 vc1_decode_i_block_adv(v, block[k], k, val,
04674                                        (k < 4) ? v->codingset : v->codingset2, mquant);
04675 
04676                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
04677                     continue;
04678                 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
04679             }
04680 
04681             vc1_smooth_overlap_filter_iblk(v);
04682             vc1_put_signed_blocks_clamped(v);
04683             if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
04684 
04685             if (get_bits_count(&s->gb) > v->bits) {
04686                 // TODO: may need modification to handle slice coding
04687                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04688                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
04689                        get_bits_count(&s->gb), v->bits);
04690                 return;
04691             }
04692         }
04693         if (!v->s.loop_filter)
04694             ff_draw_horiz_band(s, s->mb_y * 16, 16);
04695         else if (s->mb_y)
04696             ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
04697         s->first_slice_line = 0;
04698     }
04699 
04700     /* raw bottom MB row */
04701     s->mb_x = 0;
04702     ff_init_block_index(s);
04703     for (;s->mb_x < s->mb_width; s->mb_x++) {
04704         ff_update_block_index(s);
04705         vc1_put_signed_blocks_clamped(v);
04706         if (v->s.loop_filter)
04707             vc1_loop_filter_iblk_delayed(v, v->pq);
04708     }
04709     if (v->s.loop_filter)
04710         ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
04711     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04712                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04713 }
04714 
04715 static void vc1_decode_p_blocks(VC1Context *v)
04716 {
04717     MpegEncContext *s = &v->s;
04718     int apply_loop_filter;
04719 
04720     /* select codingmode used for VLC tables selection */
04721     switch (v->c_ac_table_index) {
04722     case 0:
04723         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04724         break;
04725     case 1:
04726         v->codingset = CS_HIGH_MOT_INTRA;
04727         break;
04728     case 2:
04729         v->codingset = CS_MID_RATE_INTRA;
04730         break;
04731     }
04732 
04733     switch (v->c_ac_table_index) {
04734     case 0:
04735         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04736         break;
04737     case 1:
04738         v->codingset2 = CS_HIGH_MOT_INTER;
04739         break;
04740     case 2:
04741         v->codingset2 = CS_MID_RATE_INTER;
04742         break;
04743     }
04744 
04745     apply_loop_filter   = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
04746     s->first_slice_line = 1;
04747     memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
04748     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04749         s->mb_x = 0;
04750         ff_init_block_index(s);
04751         for (; s->mb_x < s->mb_width; s->mb_x++) {
04752             ff_update_block_index(s);
04753 
04754             if (v->fcm == ILACE_FIELD)
04755                 vc1_decode_p_mb_intfi(v);
04756             else if (v->fcm == ILACE_FRAME)
04757                 vc1_decode_p_mb_intfr(v);
04758             else vc1_decode_p_mb(v);
04759             if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
04760                 vc1_apply_p_loop_filter(v);
04761             if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
04762                 // TODO: may need modification to handle slice coding
04763                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04764                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
04765                        get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
04766                 return;
04767             }
04768         }
04769         memmove(v->cbp_base,      v->cbp,      sizeof(v->cbp_base[0])      * s->mb_stride);
04770         memmove(v->ttblk_base,    v->ttblk,    sizeof(v->ttblk_base[0])    * s->mb_stride);
04771         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
04772         memmove(v->luma_mv_base,  v->luma_mv,  sizeof(v->luma_mv_base[0])  * s->mb_stride);
04773         if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04774         s->first_slice_line = 0;
04775     }
04776     if (apply_loop_filter) {
04777         s->mb_x = 0;
04778         ff_init_block_index(s);
04779         for (; s->mb_x < s->mb_width; s->mb_x++) {
04780             ff_update_block_index(s);
04781             vc1_apply_p_loop_filter(v);
04782         }
04783     }
04784     if (s->end_mb_y >= s->start_mb_y)
04785         ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
04786     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04787                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04788 }
04789 
04790 static void vc1_decode_b_blocks(VC1Context *v)
04791 {
04792     MpegEncContext *s = &v->s;
04793 
04794     /* select codingmode used for VLC tables selection */
04795     switch (v->c_ac_table_index) {
04796     case 0:
04797         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
04798         break;
04799     case 1:
04800         v->codingset = CS_HIGH_MOT_INTRA;
04801         break;
04802     case 2:
04803         v->codingset = CS_MID_RATE_INTRA;
04804         break;
04805     }
04806 
04807     switch (v->c_ac_table_index) {
04808     case 0:
04809         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
04810         break;
04811     case 1:
04812         v->codingset2 = CS_HIGH_MOT_INTER;
04813         break;
04814     case 2:
04815         v->codingset2 = CS_MID_RATE_INTER;
04816         break;
04817     }
04818 
04819     s->first_slice_line = 1;
04820     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04821         s->mb_x = 0;
04822         ff_init_block_index(s);
04823         for (; s->mb_x < s->mb_width; s->mb_x++) {
04824             ff_update_block_index(s);
04825 
04826             if (v->fcm == ILACE_FIELD)
04827                 vc1_decode_b_mb_intfi(v);
04828             else
04829                 vc1_decode_b_mb(v);
04830             if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
04831                 // TODO: may need modification to handle slice coding
04832                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
04833                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
04834                        get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
04835                 return;
04836             }
04837             if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
04838         }
04839         if (!v->s.loop_filter)
04840             ff_draw_horiz_band(s, s->mb_y * 16, 16);
04841         else if (s->mb_y)
04842             ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
04843         s->first_slice_line = 0;
04844     }
04845     if (v->s.loop_filter)
04846         ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
04847     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
04848                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
04849 }
04850 
04851 static void vc1_decode_skip_blocks(VC1Context *v)
04852 {
04853     MpegEncContext *s = &v->s;
04854 
04855     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
04856     s->first_slice_line = 1;
04857     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04858         s->mb_x = 0;
04859         ff_init_block_index(s);
04860         ff_update_block_index(s);
04861         memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize,   s->linesize   * 16);
04862         memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
04863         memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
04864         ff_draw_horiz_band(s, s->mb_y * 16, 16);
04865         s->first_slice_line = 0;
04866     }
04867     s->pict_type = AV_PICTURE_TYPE_P;
04868 }
04869 
04870 static void vc1_decode_blocks(VC1Context *v)
04871 {
04872 
04873     v->s.esc3_level_length = 0;
04874     if (v->x8_type) {
04875         ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
04876     } else {
04877         v->cur_blk_idx     =  0;
04878         v->left_blk_idx    = -1;
04879         v->topleft_blk_idx =  1;
04880         v->top_blk_idx     =  2;
04881         switch (v->s.pict_type) {
04882         case AV_PICTURE_TYPE_I:
04883             if (v->profile == PROFILE_ADVANCED)
04884                 vc1_decode_i_blocks_adv(v);
04885             else
04886                 vc1_decode_i_blocks(v);
04887             break;
04888         case AV_PICTURE_TYPE_P:
04889             if (v->p_frame_skipped)
04890                 vc1_decode_skip_blocks(v);
04891             else
04892                 vc1_decode_p_blocks(v);
04893             break;
04894         case AV_PICTURE_TYPE_B:
04895             if (v->bi_type) {
04896                 if (v->profile == PROFILE_ADVANCED)
04897                     vc1_decode_i_blocks_adv(v);
04898                 else
04899                     vc1_decode_i_blocks(v);
04900             } else
04901                 vc1_decode_b_blocks(v);
04902             break;
04903         }
04904     }
04905 }
04906 
04907 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
04908 
04909 typedef struct {
04921     int coefs[2][7];
04922 
04923     int effect_type, effect_flag;
04924     int effect_pcount1, effect_pcount2;   
04925     int effect_params1[15], effect_params2[10]; 
04926 } SpriteData;
04927 
04928 static inline int get_fp_val(GetBitContext* gb)
04929 {
04930     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
04931 }
04932 
04933 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
04934 {
04935     c[1] = c[3] = 0;
04936 
04937     switch (get_bits(gb, 2)) {
04938     case 0:
04939         c[0] = 1 << 16;
04940         c[2] = get_fp_val(gb);
04941         c[4] = 1 << 16;
04942         break;
04943     case 1:
04944         c[0] = c[4] = get_fp_val(gb);
04945         c[2] = get_fp_val(gb);
04946         break;
04947     case 2:
04948         c[0] = get_fp_val(gb);
04949         c[2] = get_fp_val(gb);
04950         c[4] = get_fp_val(gb);
04951         break;
04952     case 3:
04953         c[0] = get_fp_val(gb);
04954         c[1] = get_fp_val(gb);
04955         c[2] = get_fp_val(gb);
04956         c[3] = get_fp_val(gb);
04957         c[4] = get_fp_val(gb);
04958         break;
04959     }
04960     c[5] = get_fp_val(gb);
04961     if (get_bits1(gb))
04962         c[6] = get_fp_val(gb);
04963     else
04964         c[6] = 1 << 16;
04965 }
04966 
04967 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
04968 {
04969     AVCodecContext *avctx = v->s.avctx;
04970     int sprite, i;
04971 
04972     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
04973         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
04974         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
04975             av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
04976         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
04977         for (i = 0; i < 7; i++)
04978             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
04979                    sd->coefs[sprite][i] / (1<<16),
04980                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
04981         av_log(avctx, AV_LOG_DEBUG, "\n");
04982     }
04983 
04984     skip_bits(gb, 2);
04985     if (sd->effect_type = get_bits_long(gb, 30)) {
04986         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
04987         case 7:
04988             vc1_sprite_parse_transform(gb, sd->effect_params1);
04989             break;
04990         case 14:
04991             vc1_sprite_parse_transform(gb, sd->effect_params1);
04992             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
04993             break;
04994         default:
04995             for (i = 0; i < sd->effect_pcount1; i++)
04996                 sd->effect_params1[i] = get_fp_val(gb);
04997         }
04998         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
04999             // effect 13 is simple alpha blending and matches the opacity above
05000             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
05001             for (i = 0; i < sd->effect_pcount1; i++)
05002                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
05003                        sd->effect_params1[i] / (1 << 16),
05004                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
05005             av_log(avctx, AV_LOG_DEBUG, "\n");
05006         }
05007 
05008         sd->effect_pcount2 = get_bits(gb, 16);
05009         if (sd->effect_pcount2 > 10) {
05010             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
05011             return;
05012         } else if (sd->effect_pcount2) {
05013             i = -1;
05014             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
05015             while (++i < sd->effect_pcount2) {
05016                 sd->effect_params2[i] = get_fp_val(gb);
05017                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
05018                        sd->effect_params2[i] / (1 << 16),
05019                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
05020             }
05021             av_log(avctx, AV_LOG_DEBUG, "\n");
05022         }
05023     }
05024     if (sd->effect_flag = get_bits1(gb))
05025         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
05026 
05027     if (get_bits_count(gb) >= gb->size_in_bits +
05028        (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
05029         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
05030     if (get_bits_count(gb) < gb->size_in_bits - 8)
05031         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
05032 }
05033 
05034 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
05035 {
05036     int i, plane, row, sprite;
05037     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
05038     uint8_t* src_h[2][2];
05039     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
05040     int ysub[2];
05041     MpegEncContext *s = &v->s;
05042 
05043     for (i = 0; i < 2; i++) {
05044         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
05045         xadv[i] = sd->coefs[i][0];
05046         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
05047             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
05048 
05049         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
05050         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
05051     }
05052     alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
05053 
05054     for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
05055         int width = v->output_width>>!!plane;
05056 
05057         for (row = 0; row < v->output_height>>!!plane; row++) {
05058             uint8_t *dst = v->sprite_output_frame.data[plane] +
05059                            v->sprite_output_frame.linesize[plane] * row;
05060 
05061             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
05062                 uint8_t *iplane = s->current_picture.f.data[plane];
05063                 int      iline  = s->current_picture.f.linesize[plane];
05064                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
05065                 int      yline  = ycoord >> 16;
05066                 ysub[sprite] = ycoord & 0xFFFF;
05067                 if (sprite) {
05068                     iplane = s->last_picture.f.data[plane];
05069                     iline  = s->last_picture.f.linesize[plane];
05070                 }
05071                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
05072                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
05073                     if (ysub[sprite])
05074                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
05075                 } else {
05076                     if (sr_cache[sprite][0] != yline) {
05077                         if (sr_cache[sprite][1] == yline) {
05078                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
05079                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
05080                         } else {
05081                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
05082                             sr_cache[sprite][0] = yline;
05083                         }
05084                     }
05085                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
05086                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
05087                         sr_cache[sprite][1] = yline + 1;
05088                     }
05089                     src_h[sprite][0] = v->sr_rows[sprite][0];
05090                     src_h[sprite][1] = v->sr_rows[sprite][1];
05091                 }
05092             }
05093 
05094             if (!v->two_sprites) {
05095                 if (ysub[0]) {
05096                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
05097                 } else {
05098                     memcpy(dst, src_h[0][0], width);
05099                 }
05100             } else {
05101                 if (ysub[0] && ysub[1]) {
05102                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
05103                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
05104                 } else if (ysub[0]) {
05105                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
05106                                                        src_h[1][0], alpha, width);
05107                 } else if (ysub[1]) {
05108                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
05109                                                        src_h[0][0], (1<<16)-1-alpha, width);
05110                 } else {
05111                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
05112                 }
05113             }
05114         }
05115 
05116         if (!plane) {
05117             for (i = 0; i < 2; i++) {
05118                 xoff[i] >>= 1;
05119                 yoff[i] >>= 1;
05120             }
05121         }
05122 
05123     }
05124 }
05125 
05126 
05127 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
05128 {
05129     MpegEncContext *s     = &v->s;
05130     AVCodecContext *avctx = s->avctx;
05131     SpriteData sd;
05132 
05133     vc1_parse_sprites(v, gb, &sd);
05134 
05135     if (!s->current_picture.f.data[0]) {
05136         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
05137         return -1;
05138     }
05139 
05140     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
05141         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
05142         v->two_sprites = 0;
05143     }
05144 
05145     if (v->sprite_output_frame.data[0])
05146         avctx->release_buffer(avctx, &v->sprite_output_frame);
05147 
05148     v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
05149     v->sprite_output_frame.reference = 0;
05150     if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
05151         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
05152         return -1;
05153     }
05154 
05155     vc1_draw_sprites(v, &sd);
05156 
05157     return 0;
05158 }
05159 
05160 static void vc1_sprite_flush(AVCodecContext *avctx)
05161 {
05162     VC1Context *v     = avctx->priv_data;
05163     MpegEncContext *s = &v->s;
05164     AVFrame *f = &s->current_picture.f;
05165     int plane, i;
05166 
05167     /* Windows Media Image codecs have a convergence interval of two keyframes.
05168        Since we can't enforce it, clear to black the missing sprite. This is
05169        wrong but it looks better than doing nothing. */
05170 
05171     if (f->data[0])
05172         for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
05173             for (i = 0; i < v->sprite_height>>!!plane; i++)
05174                 memset(f->data[plane] + i * f->linesize[plane],
05175                        plane ? 128 : 0, f->linesize[plane]);
05176 }
05177 
05178 #endif
05179 
05180 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
05181 {
05182     MpegEncContext *s = &v->s;
05183     int i;
05184 
05185     /* Allocate mb bitplanes */
05186     v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05187     v->direct_mb_plane  = av_malloc (s->mb_stride * s->mb_height);
05188     v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05189     v->fieldtx_plane    = av_mallocz(s->mb_stride * s->mb_height);
05190     v->acpred_plane     = av_malloc (s->mb_stride * s->mb_height);
05191     v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
05192 
05193     v->n_allocated_blks = s->mb_width + 2;
05194     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
05195     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
05196     v->cbp              = v->cbp_base + s->mb_stride;
05197     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
05198     v->ttblk            = v->ttblk_base + s->mb_stride;
05199     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
05200     v->is_intra         = v->is_intra_base + s->mb_stride;
05201     v->luma_mv_base     = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
05202     v->luma_mv          = v->luma_mv_base + s->mb_stride;
05203 
05204     /* allocate block type info in that way so it could be used with s->block_index[] */
05205     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05206     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
05207     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
05208     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
05209 
05210     /* allocate memory to store block level MV info */
05211     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05212     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
05213     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05214     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
05215     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05216     v->mv_f_last_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05217     v->mv_f_last[0]     = v->mv_f_last_base + s->b8_stride + 1;
05218     v->mv_f_last[1]     = v->mv_f_last[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05219     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05220     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
05221     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05222 
05223     /* Init coded blocks info */
05224     if (v->profile == PROFILE_ADVANCED) {
05225 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
05226 //            return -1;
05227 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
05228 //            return -1;
05229     }
05230 
05231     ff_intrax8_common_init(&v->x8,s);
05232 
05233     if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
05234         for (i = 0; i < 4; i++)
05235             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
05236     }
05237 
05238     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
05239         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
05240         !v->mb_type_base)
05241             return -1;
05242 
05243     return 0;
05244 }
05245 
05250 static av_cold int vc1_decode_init(AVCodecContext *avctx)
05251 {
05252     VC1Context *v = avctx->priv_data;
05253     MpegEncContext *s = &v->s;
05254     GetBitContext gb;
05255     int i;
05256 
05257     /* save the container output size for WMImage */
05258     v->output_width  = avctx->width;
05259     v->output_height = avctx->height;
05260 
05261     if (!avctx->extradata_size || !avctx->extradata)
05262         return -1;
05263     if (!(avctx->flags & CODEC_FLAG_GRAY))
05264         avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
05265     else
05266         avctx->pix_fmt = PIX_FMT_GRAY8;
05267     avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
05268     v->s.avctx = avctx;
05269     avctx->flags |= CODEC_FLAG_EMU_EDGE;
05270     v->s.flags   |= CODEC_FLAG_EMU_EDGE;
05271 
05272     if (avctx->idct_algo == FF_IDCT_AUTO) {
05273         avctx->idct_algo = FF_IDCT_WMV2;
05274     }
05275 
05276     if (ff_vc1_init_common(v) < 0)
05277         return -1;
05278     ff_vc1dsp_init(&v->vc1dsp);
05279 
05280     if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
05281         int count = 0;
05282 
05283         // looks like WMV3 has a sequence header stored in the extradata
05284         // advanced sequence header may be before the first frame
05285         // the last byte of the extradata is a version number, 1 for the
05286         // samples we can decode
05287 
05288         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
05289 
05290         if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
05291           return -1;
05292 
05293         count = avctx->extradata_size*8 - get_bits_count(&gb);
05294         if (count > 0) {
05295             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
05296                    count, get_bits(&gb, count));
05297         } else if (count < 0) {
05298             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
05299         }
05300     } else { // VC1/WVC1/WVP2
05301         const uint8_t *start = avctx->extradata;
05302         uint8_t *end = avctx->extradata + avctx->extradata_size;
05303         const uint8_t *next;
05304         int size, buf2_size;
05305         uint8_t *buf2 = NULL;
05306         int seq_initialized = 0, ep_initialized = 0;
05307 
05308         if (avctx->extradata_size < 16) {
05309             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
05310             return -1;
05311         }
05312 
05313         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
05314         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
05315         next  = start;
05316         for (; next < end; start = next) {
05317             next = find_next_marker(start + 4, end);
05318             size = next - start - 4;
05319             if (size <= 0)
05320                 continue;
05321             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
05322             init_get_bits(&gb, buf2, buf2_size * 8);
05323             switch (AV_RB32(start)) {
05324             case VC1_CODE_SEQHDR:
05325                 if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
05326                     av_free(buf2);
05327                     return -1;
05328                 }
05329                 seq_initialized = 1;
05330                 break;
05331             case VC1_CODE_ENTRYPOINT:
05332                 if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
05333                     av_free(buf2);
05334                     return -1;
05335                 }
05336                 ep_initialized = 1;
05337                 break;
05338             }
05339         }
05340         av_free(buf2);
05341         if (!seq_initialized || !ep_initialized) {
05342             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
05343             return -1;
05344         }
05345         v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
05346     }
05347 
05348     avctx->profile = v->profile;
05349     if (v->profile == PROFILE_ADVANCED)
05350         avctx->level = v->level;
05351 
05352     avctx->has_b_frames = !!avctx->max_b_frames;
05353 
05354     s->mb_width  = (avctx->coded_width  + 15) >> 4;
05355     s->mb_height = (avctx->coded_height + 15) >> 4;
05356 
05357     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
05358         for (i = 0; i < 64; i++) {
05359 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
05360             v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
05361             v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
05362             v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
05363             v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
05364             v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
05365         }
05366         v->left_blk_sh = 0;
05367         v->top_blk_sh  = 3;
05368     } else {
05369         memcpy(v->zz_8x8, wmv1_scantable, 4*64);
05370         v->left_blk_sh = 3;
05371         v->top_blk_sh  = 0;
05372     }
05373 
05374     if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05375         v->sprite_width  = avctx->coded_width;
05376         v->sprite_height = avctx->coded_height;
05377 
05378         avctx->coded_width  = avctx->width  = v->output_width;
05379         avctx->coded_height = avctx->height = v->output_height;
05380 
05381         // prevent 16.16 overflows
05382         if (v->sprite_width  > 1 << 14 ||
05383             v->sprite_height > 1 << 14 ||
05384             v->output_width  > 1 << 14 ||
05385             v->output_height > 1 << 14) return -1;
05386     }
05387     return 0;
05388 }
05389 
05393 static av_cold int vc1_decode_end(AVCodecContext *avctx)
05394 {
05395     VC1Context *v = avctx->priv_data;
05396     int i;
05397 
05398     if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05399         && v->sprite_output_frame.data[0])
05400         avctx->release_buffer(avctx, &v->sprite_output_frame);
05401     for (i = 0; i < 4; i++)
05402         av_freep(&v->sr_rows[i >> 1][i & 1]);
05403     av_freep(&v->hrd_rate);
05404     av_freep(&v->hrd_buffer);
05405     MPV_common_end(&v->s);
05406     av_freep(&v->mv_type_mb_plane);
05407     av_freep(&v->direct_mb_plane);
05408     av_freep(&v->forward_mb_plane);
05409     av_freep(&v->fieldtx_plane);
05410     av_freep(&v->acpred_plane);
05411     av_freep(&v->over_flags_plane);
05412     av_freep(&v->mb_type_base);
05413     av_freep(&v->blk_mv_type_base);
05414     av_freep(&v->mv_f_base);
05415     av_freep(&v->mv_f_last_base);
05416     av_freep(&v->mv_f_next_base);
05417     av_freep(&v->block);
05418     av_freep(&v->cbp_base);
05419     av_freep(&v->ttblk_base);
05420     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
05421     av_freep(&v->luma_mv_base);
05422     ff_intrax8_common_end(&v->x8);
05423     return 0;
05424 }
05425 
05426 
05430 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
05431                             int *data_size, AVPacket *avpkt)
05432 {
05433     const uint8_t *buf = avpkt->data;
05434     int buf_size = avpkt->size, n_slices = 0, i;
05435     VC1Context *v = avctx->priv_data;
05436     MpegEncContext *s = &v->s;
05437     AVFrame *pict = data;
05438     uint8_t *buf2 = NULL;
05439     const uint8_t *buf_start = buf;
05440     int mb_height, n_slices1;
05441     struct {
05442         uint8_t *buf;
05443         GetBitContext gb;
05444         int mby_start;
05445     } *slices = NULL, *tmp;
05446 
05447     /* no supplementary picture */
05448     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
05449         /* special case for last picture */
05450         if (s->low_delay == 0 && s->next_picture_ptr) {
05451             *pict = *(AVFrame*)s->next_picture_ptr;
05452             s->next_picture_ptr = NULL;
05453 
05454             *data_size = sizeof(AVFrame);
05455         }
05456 
05457         return 0;
05458     }
05459 
05460     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
05461         if (v->profile < PROFILE_ADVANCED)
05462             avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
05463         else
05464             avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
05465     }
05466 
05467     //for advanced profile we may need to parse and unescape data
05468     if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05469         int buf_size2 = 0;
05470         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05471 
05472         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
05473             const uint8_t *start, *end, *next;
05474             int size;
05475 
05476             next = buf;
05477             for (start = buf, end = buf + buf_size; next < end; start = next) {
05478                 next = find_next_marker(start + 4, end);
05479                 size = next - start - 4;
05480                 if (size <= 0) continue;
05481                 switch (AV_RB32(start)) {
05482                 case VC1_CODE_FRAME:
05483                     if (avctx->hwaccel ||
05484                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05485                         buf_start = start;
05486                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05487                     break;
05488                 case VC1_CODE_FIELD: {
05489                     int buf_size3;
05490                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05491                     if (!slices)
05492                         goto err;
05493                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05494                     if (!slices[n_slices].buf)
05495                         goto err;
05496                     buf_size3 = vc1_unescape_buffer(start + 4, size,
05497                                                     slices[n_slices].buf);
05498                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05499                                   buf_size3 << 3);
05500                     /* assuming that the field marker is at the exact middle,
05501                        hope it's correct */
05502                     slices[n_slices].mby_start = s->mb_height >> 1;
05503                     n_slices1 = n_slices - 1; // index of the last slice of the first field
05504                     n_slices++;
05505                     break;
05506                 }
05507                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
05508                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05509                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
05510                     vc1_decode_entry_point(avctx, v, &s->gb);
05511                     break;
05512                 case VC1_CODE_SLICE: {
05513                     int buf_size3;
05514                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05515                     if (!slices)
05516                         goto err;
05517                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05518                     if (!slices[n_slices].buf)
05519                         goto err;
05520                     buf_size3 = vc1_unescape_buffer(start + 4, size,
05521                                                     slices[n_slices].buf);
05522                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05523                                   buf_size3 << 3);
05524                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
05525                     n_slices++;
05526                     break;
05527                 }
05528                 }
05529             }
05530         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
05531             const uint8_t *divider;
05532             int buf_size3;
05533 
05534             divider = find_next_marker(buf, buf + buf_size);
05535             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
05536                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
05537                 goto err;
05538             } else { // found field marker, unescape second field
05539                 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05540                 if (!tmp)
05541                     goto err;
05542                 slices = tmp;
05543                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05544                 if (!slices[n_slices].buf)
05545                     goto err;
05546                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
05547                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05548                               buf_size3 << 3);
05549                 slices[n_slices].mby_start = s->mb_height >> 1;
05550                 n_slices1 = n_slices - 1;
05551                 n_slices++;
05552             }
05553             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
05554         } else {
05555             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
05556         }
05557         init_get_bits(&s->gb, buf2, buf_size2*8);
05558     } else
05559         init_get_bits(&s->gb, buf, buf_size*8);
05560 
05561     if (v->res_sprite) {
05562         v->new_sprite  = !get_bits1(&s->gb);
05563         v->two_sprites =  get_bits1(&s->gb);
05564         /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
05565            we're using the sprite compositor. These are intentionally kept separate
05566            so you can get the raw sprites by using the wmv3 decoder for WMVP or
05567            the vc1 one for WVP2 */
05568         if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05569             if (v->new_sprite) {
05570                 // switch AVCodecContext parameters to those of the sprites
05571                 avctx->width  = avctx->coded_width  = v->sprite_width;
05572                 avctx->height = avctx->coded_height = v->sprite_height;
05573             } else {
05574                 goto image;
05575             }
05576         }
05577     }
05578 
05579     if (s->context_initialized &&
05580         (s->width  != avctx->coded_width ||
05581          s->height != avctx->coded_height)) {
05582         vc1_decode_end(avctx);
05583     }
05584 
05585     if (!s->context_initialized) {
05586         if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
05587             return -1;
05588 
05589         s->low_delay = !avctx->has_b_frames || v->res_sprite;
05590 
05591         if (v->profile == PROFILE_ADVANCED) {
05592             s->h_edge_pos = avctx->coded_width;
05593             s->v_edge_pos = avctx->coded_height;
05594         }
05595     }
05596 
05597     /* We need to set current_picture_ptr before reading the header,
05598      * otherwise we cannot store anything in there. */
05599     if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
05600         int i = ff_find_unused_picture(s, 0);
05601         if (i < 0)
05602             goto err;
05603         s->current_picture_ptr = &s->picture[i];
05604     }
05605 
05606     // do parse frame header
05607     v->pic_header_flag = 0;
05608     if (v->profile < PROFILE_ADVANCED) {
05609         if (vc1_parse_frame_header(v, &s->gb) == -1) {
05610             goto err;
05611         }
05612     } else {
05613         if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
05614             goto err;
05615         }
05616     }
05617 
05618     if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05619         && s->pict_type != AV_PICTURE_TYPE_I) {
05620         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
05621         goto err;
05622     }
05623 
05624     // process pulldown flags
05625     s->current_picture_ptr->f.repeat_pict = 0;
05626     // Pulldown flags are only valid when 'broadcast' has been set.
05627     // So ticks_per_frame will be 2
05628     if (v->rff) {
05629         // repeat field
05630         s->current_picture_ptr->f.repeat_pict = 1;
05631     } else if (v->rptfrm) {
05632         // repeat frames
05633         s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
05634     }
05635 
05636     // for skipping the frame
05637     s->current_picture.f.pict_type = s->pict_type;
05638     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
05639 
05640     /* skip B-frames if we don't have reference frames */
05641     if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
05642         goto err;
05643     }
05644     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
05645         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
05646          avctx->skip_frame >= AVDISCARD_ALL) {
05647         goto end;
05648     }
05649 
05650     if (s->next_p_frame_damaged) {
05651         if (s->pict_type == AV_PICTURE_TYPE_B)
05652             goto end;
05653         else
05654             s->next_p_frame_damaged = 0;
05655     }
05656 
05657     if (MPV_frame_start(s, avctx) < 0) {
05658         goto err;
05659     }
05660 
05661     s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
05662     s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
05663 
05664     if ((CONFIG_VC1_VDPAU_DECODER)
05665         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05666         ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
05667     else if (avctx->hwaccel) {
05668         if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
05669             goto err;
05670         if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
05671             goto err;
05672         if (avctx->hwaccel->end_frame(avctx) < 0)
05673             goto err;
05674     } else {
05675         ff_er_frame_start(s);
05676 
05677         v->bits = buf_size * 8;
05678         if (v->field_mode) {
05679             uint8_t *tmp[2];
05680             s->current_picture.f.linesize[0] <<= 1;
05681             s->current_picture.f.linesize[1] <<= 1;
05682             s->current_picture.f.linesize[2] <<= 1;
05683             s->linesize                      <<= 1;
05684             s->uvlinesize                    <<= 1;
05685             tmp[0]          = v->mv_f_last[0];
05686             tmp[1]          = v->mv_f_last[1];
05687             v->mv_f_last[0] = v->mv_f_next[0];
05688             v->mv_f_last[1] = v->mv_f_next[1];
05689             v->mv_f_next[0] = v->mv_f[0];
05690             v->mv_f_next[1] = v->mv_f[1];
05691             v->mv_f[0] = tmp[0];
05692             v->mv_f[1] = tmp[1];
05693         }
05694         mb_height = s->mb_height >> v->field_mode;
05695         for (i = 0; i <= n_slices; i++) {
05696             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
05697                 v->second_field = 1;
05698                 v->blocks_off   = s->mb_width  * s->mb_height << 1;
05699                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
05700             } else {
05701                 v->second_field = 0;
05702                 v->blocks_off   = 0;
05703                 v->mb_off       = 0;
05704             }
05705             if (i) {
05706                 v->pic_header_flag = 0;
05707                 if (v->field_mode && i == n_slices1 + 2)
05708                     vc1_parse_frame_header_adv(v, &s->gb);
05709                 else if (get_bits1(&s->gb)) {
05710                     v->pic_header_flag = 1;
05711                     vc1_parse_frame_header_adv(v, &s->gb);
05712                 }
05713             }
05714             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
05715             if (!v->field_mode || v->second_field)
05716                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05717             else
05718                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05719             vc1_decode_blocks(v);
05720             if (i != n_slices)
05721                 s->gb = slices[i].gb;
05722         }
05723         if (v->field_mode) {
05724             v->second_field = 0;
05725             if (s->pict_type == AV_PICTURE_TYPE_B) {
05726                 memcpy(v->mv_f_base, v->mv_f_next_base,
05727                        2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05728             }
05729             s->current_picture.f.linesize[0] >>= 1;
05730             s->current_picture.f.linesize[1] >>= 1;
05731             s->current_picture.f.linesize[2] >>= 1;
05732             s->linesize                      >>= 1;
05733             s->uvlinesize                    >>= 1;
05734         }
05735 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
05736 //  if (get_bits_count(&s->gb) > buf_size * 8)
05737 //      return -1;
05738         ff_er_frame_end(s);
05739     }
05740 
05741     MPV_frame_end(s);
05742 
05743     if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05744 image:
05745         avctx->width  = avctx->coded_width  = v->output_width;
05746         avctx->height = avctx->coded_height = v->output_height;
05747         if (avctx->skip_frame >= AVDISCARD_NONREF)
05748             goto end;
05749 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
05750         if (vc1_decode_sprites(v, &s->gb))
05751             goto err;
05752 #endif
05753         *pict      = v->sprite_output_frame;
05754         *data_size = sizeof(AVFrame);
05755     } else {
05756         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
05757             *pict = *(AVFrame*)s->current_picture_ptr;
05758         } else if (s->last_picture_ptr != NULL) {
05759             *pict = *(AVFrame*)s->last_picture_ptr;
05760         }
05761         if (s->last_picture_ptr || s->low_delay) {
05762             *data_size = sizeof(AVFrame);
05763             ff_print_debug_info(s, pict);
05764         }
05765     }
05766 
05767 end:
05768     av_free(buf2);
05769     for (i = 0; i < n_slices; i++)
05770         av_free(slices[i].buf);
05771     av_free(slices);
05772     return buf_size;
05773 
05774 err:
05775     av_free(buf2);
05776     for (i = 0; i < n_slices; i++)
05777         av_free(slices[i].buf);
05778     av_free(slices);
05779     return -1;
05780 }
05781 
05782 
05783 static const AVProfile profiles[] = {
05784     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
05785     { FF_PROFILE_VC1_MAIN,     "Main"     },
05786     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
05787     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
05788     { FF_PROFILE_UNKNOWN },
05789 };
05790 
05791 AVCodec ff_vc1_decoder = {
05792     .name           = "vc1",
05793     .type           = AVMEDIA_TYPE_VIDEO,
05794     .id             = CODEC_ID_VC1,
05795     .priv_data_size = sizeof(VC1Context),
05796     .init           = vc1_decode_init,
05797     .close          = vc1_decode_end,
05798     .decode         = vc1_decode_frame,
05799     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05800     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
05801     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
05802     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05803 };
05804 
05805 #if CONFIG_WMV3_DECODER
05806 AVCodec ff_wmv3_decoder = {
05807     .name           = "wmv3",
05808     .type           = AVMEDIA_TYPE_VIDEO,
05809     .id             = CODEC_ID_WMV3,
05810     .priv_data_size = sizeof(VC1Context),
05811     .init           = vc1_decode_init,
05812     .close          = vc1_decode_end,
05813     .decode         = vc1_decode_frame,
05814     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05815     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
05816     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
05817     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05818 };
05819 #endif
05820 
05821 #if CONFIG_WMV3_VDPAU_DECODER
05822 AVCodec ff_wmv3_vdpau_decoder = {
05823     .name           = "wmv3_vdpau",
05824     .type           = AVMEDIA_TYPE_VIDEO,
05825     .id             = CODEC_ID_WMV3,
05826     .priv_data_size = sizeof(VC1Context),
05827     .init           = vc1_decode_init,
05828     .close          = vc1_decode_end,
05829     .decode         = vc1_decode_frame,
05830     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05831     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
05832     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
05833     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05834 };
05835 #endif
05836 
05837 #if CONFIG_VC1_VDPAU_DECODER
05838 AVCodec ff_vc1_vdpau_decoder = {
05839     .name           = "vc1_vdpau",
05840     .type           = AVMEDIA_TYPE_VIDEO,
05841     .id             = CODEC_ID_VC1,
05842     .priv_data_size = sizeof(VC1Context),
05843     .init           = vc1_decode_init,
05844     .close          = vc1_decode_end,
05845     .decode         = vc1_decode_frame,
05846     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05847     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
05848     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
05849     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05850 };
05851 #endif
05852 
05853 #if CONFIG_WMV3IMAGE_DECODER
05854 AVCodec ff_wmv3image_decoder = {
05855     .name           = "wmv3image",
05856     .type           = AVMEDIA_TYPE_VIDEO,
05857     .id             = CODEC_ID_WMV3IMAGE,
05858     .priv_data_size = sizeof(VC1Context),
05859     .init           = vc1_decode_init,
05860     .close          = vc1_decode_end,
05861     .decode         = vc1_decode_frame,
05862     .capabilities   = CODEC_CAP_DR1,
05863     .flush          = vc1_sprite_flush,
05864     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
05865     .pix_fmts       = ff_pixfmt_list_420
05866 };
05867 #endif
05868 
05869 #if CONFIG_VC1IMAGE_DECODER
05870 AVCodec ff_vc1image_decoder = {
05871     .name           = "vc1image",
05872     .type           = AVMEDIA_TYPE_VIDEO,
05873     .id             = CODEC_ID_VC1IMAGE,
05874     .priv_data_size = sizeof(VC1Context),
05875     .init           = vc1_decode_init,
05876     .close          = vc1_decode_end,
05877     .decode         = vc1_decode_frame,
05878     .capabilities   = CODEC_CAP_DR1,
05879     .flush          = vc1_sprite_flush,
05880     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
05881     .pix_fmts       = ff_pixfmt_list_420
05882 };
05883 #endif