Libav 0.7.1
libavcodec/vc1dec.c
Go to the documentation of this file.
00001 /*
00002  * VC-1 and WMV3 decoder
00003  * Copyright (c) 2006-2007 Konstantin Shishkov
00004  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
00005  *
00006  * This file is part of Libav.
00007  *
00008  * Libav is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * Libav is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with Libav; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00028 #include "internal.h"
00029 #include "dsputil.h"
00030 #include "avcodec.h"
00031 #include "mpegvideo.h"
00032 #include "h263.h"
00033 #include "vc1.h"
00034 #include "vc1data.h"
00035 #include "vc1acdata.h"
00036 #include "msmpeg4data.h"
00037 #include "unary.h"
00038 #include "simple_idct.h"
00039 #include "mathops.h"
00040 #include "vdpau_internal.h"
00041 
00042 #undef NDEBUG
00043 #include <assert.h>
00044 
00045 #define MB_INTRA_VLC_BITS 9
00046 #define DC_VLC_BITS 9
00047 #define AC_VLC_BITS 9
00048 static const uint16_t table_mb_intra[64][2];
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, 8620,
00054     9262, 10202, 10756, 11310, 12228, 15078
00055 };
00056 
00062 static int vc1_init_common(VC1Context *v)
00063 {
00064     static int done = 0;
00065     int i = 0;
00066     static VLC_TYPE vlc_table[15078][2];
00067 
00068     v->hrd_rate = v->hrd_buffer = NULL;
00069 
00070     /* VLC tables */
00071     if(!done)
00072     {
00073         INIT_VLC_STATIC(&ff_vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
00074                  ff_vc1_bfraction_bits, 1, 1,
00075                  ff_vc1_bfraction_codes, 1, 1, 1 << VC1_BFRACTION_VLC_BITS);
00076         INIT_VLC_STATIC(&ff_vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
00077                  ff_vc1_norm2_bits, 1, 1,
00078                  ff_vc1_norm2_codes, 1, 1, 1 << VC1_NORM2_VLC_BITS);
00079         INIT_VLC_STATIC(&ff_vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
00080                  ff_vc1_norm6_bits, 1, 1,
00081                  ff_vc1_norm6_codes, 2, 2, 556);
00082         INIT_VLC_STATIC(&ff_vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
00083                  ff_vc1_imode_bits, 1, 1,
00084                  ff_vc1_imode_codes, 1, 1, 1 << VC1_IMODE_VLC_BITS);
00085         for (i=0; i<3; i++)
00086         {
00087             ff_vc1_ttmb_vlc[i].table = &vlc_table[vlc_offs[i*3+0]];
00088             ff_vc1_ttmb_vlc[i].table_allocated = vlc_offs[i*3+1] - vlc_offs[i*3+0];
00089             init_vlc(&ff_vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
00090                      ff_vc1_ttmb_bits[i], 1, 1,
00091                      ff_vc1_ttmb_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00092             ff_vc1_ttblk_vlc[i].table = &vlc_table[vlc_offs[i*3+1]];
00093             ff_vc1_ttblk_vlc[i].table_allocated = vlc_offs[i*3+2] - vlc_offs[i*3+1];
00094             init_vlc(&ff_vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
00095                      ff_vc1_ttblk_bits[i], 1, 1,
00096                      ff_vc1_ttblk_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00097             ff_vc1_subblkpat_vlc[i].table = &vlc_table[vlc_offs[i*3+2]];
00098             ff_vc1_subblkpat_vlc[i].table_allocated = vlc_offs[i*3+3] - vlc_offs[i*3+2];
00099             init_vlc(&ff_vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
00100                      ff_vc1_subblkpat_bits[i], 1, 1,
00101                      ff_vc1_subblkpat_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00102         }
00103         for(i=0; i<4; i++)
00104         {
00105             ff_vc1_4mv_block_pattern_vlc[i].table = &vlc_table[vlc_offs[i*3+9]];
00106             ff_vc1_4mv_block_pattern_vlc[i].table_allocated = vlc_offs[i*3+10] - vlc_offs[i*3+9];
00107             init_vlc(&ff_vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
00108                      ff_vc1_4mv_block_pattern_bits[i], 1, 1,
00109                      ff_vc1_4mv_block_pattern_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
00110             ff_vc1_cbpcy_p_vlc[i].table = &vlc_table[vlc_offs[i*3+10]];
00111             ff_vc1_cbpcy_p_vlc[i].table_allocated = vlc_offs[i*3+11] - vlc_offs[i*3+10];
00112             init_vlc(&ff_vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
00113                      ff_vc1_cbpcy_p_bits[i], 1, 1,
00114                      ff_vc1_cbpcy_p_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00115             ff_vc1_mv_diff_vlc[i].table = &vlc_table[vlc_offs[i*3+11]];
00116             ff_vc1_mv_diff_vlc[i].table_allocated = vlc_offs[i*3+12] - vlc_offs[i*3+11];
00117             init_vlc(&ff_vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
00118                      ff_vc1_mv_diff_bits[i], 1, 1,
00119                      ff_vc1_mv_diff_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00120         }
00121         for(i=0; i<8; i++){
00122             ff_vc1_ac_coeff_table[i].table = &vlc_table[vlc_offs[i+21]];
00123             ff_vc1_ac_coeff_table[i].table_allocated = vlc_offs[i+22] - vlc_offs[i+21];
00124             init_vlc(&ff_vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
00125                      &vc1_ac_tables[i][0][1], 8, 4,
00126                      &vc1_ac_tables[i][0][0], 8, 4, INIT_VLC_USE_NEW_STATIC);
00127         }
00128         done = 1;
00129     }
00130 
00131     /* Other defaults */
00132     v->pq = -1;
00133     v->mvrange = 0; /* 7.1.1.18, p80 */
00134 
00135     return 0;
00136 }
00137 
00138 /***********************************************************************/
00149 enum Imode {
00150     IMODE_RAW,
00151     IMODE_NORM2,
00152     IMODE_DIFF2,
00153     IMODE_NORM6,
00154     IMODE_DIFF6,
00155     IMODE_ROWSKIP,
00156     IMODE_COLSKIP
00157 }; //imode defines
00159 
00160  //Bitplane group
00162 
00163 static void vc1_put_signed_blocks_clamped(VC1Context *v)
00164 {
00165     MpegEncContext *s = &v->s;
00166 
00167     /* The put pixels loop is always one MB row behind the decoding loop,
00168      * because we can only put pixels when overlap filtering is done, and
00169      * for filtering of the bottom edge of a MB, we need the next MB row
00170      * present as well.
00171      * Within the row, the put pixels loop is also one MB col behind the
00172      * decoding loop. The reason for this is again, because for filtering
00173      * of the right MB edge, we need the next MB present. */
00174     if (!s->first_slice_line) {
00175         if (s->mb_x) {
00176             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
00177                                              s->dest[0] - 16 * s->linesize - 16,
00178                                              s->linesize);
00179             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
00180                                              s->dest[0] - 16 * s->linesize - 8,
00181                                              s->linesize);
00182             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
00183                                              s->dest[0] - 8 * s->linesize - 16,
00184                                              s->linesize);
00185             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
00186                                              s->dest[0] - 8 * s->linesize - 8,
00187                                              s->linesize);
00188             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
00189                                              s->dest[1] - 8 * s->uvlinesize - 8,
00190                                              s->uvlinesize);
00191             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
00192                                              s->dest[2] - 8 * s->uvlinesize - 8,
00193                                              s->uvlinesize);
00194         }
00195         if (s->mb_x == s->mb_width - 1) {
00196             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
00197                                              s->dest[0] - 16 * s->linesize,
00198                                              s->linesize);
00199             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
00200                                              s->dest[0] - 16 * s->linesize + 8,
00201                                              s->linesize);
00202             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
00203                                              s->dest[0] - 8 * s->linesize,
00204                                              s->linesize);
00205             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
00206                                              s->dest[0] - 8 * s->linesize + 8,
00207                                              s->linesize);
00208             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
00209                                              s->dest[1] - 8 * s->uvlinesize,
00210                                              s->uvlinesize);
00211             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
00212                                              s->dest[2] - 8 * s->uvlinesize,
00213                                              s->uvlinesize);
00214         }
00215     }
00216 
00217 #define inc_blk_idx(idx) do { \
00218         idx++; \
00219         if (idx >= v->n_allocated_blks) \
00220             idx = 0; \
00221     } while (0)
00222 
00223     inc_blk_idx(v->topleft_blk_idx);
00224     inc_blk_idx(v->top_blk_idx);
00225     inc_blk_idx(v->left_blk_idx);
00226     inc_blk_idx(v->cur_blk_idx);
00227 }
00228 
00229 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
00230 {
00231     MpegEncContext *s = &v->s;
00232     int j;
00233     if (!s->first_slice_line) {
00234         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
00235         if (s->mb_x)
00236             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize, s->linesize, pq);
00237         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16*s->linesize+8, s->linesize, pq);
00238         for(j = 0; j < 2; j++){
00239             v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1], s->uvlinesize, pq);
00240             if (s->mb_x)
00241                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1]-8*s->uvlinesize, s->uvlinesize, pq);
00242         }
00243     }
00244     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8*s->linesize, s->linesize, pq);
00245 
00246     if (s->mb_y == s->end_mb_y-1) {
00247         if (s->mb_x) {
00248             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
00249             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
00250             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
00251         }
00252         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
00253     }
00254 }
00255 
00256 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
00257 {
00258     MpegEncContext *s = &v->s;
00259     int j;
00260 
00261     /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
00262      * means it runs two rows/cols behind the decoding loop. */
00263     if (!s->first_slice_line) {
00264         if (s->mb_x) {
00265             if (s->mb_y >= s->start_mb_y + 2) {
00266                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00267 
00268                 if (s->mb_x >= 2)
00269                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
00270                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
00271                 for(j = 0; j < 2; j++) {
00272                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00273                     if (s->mb_x >= 2) {
00274                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
00275                     }
00276                 }
00277             }
00278             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
00279         }
00280 
00281         if (s->mb_x == s->mb_width - 1) {
00282             if (s->mb_y >= s->start_mb_y + 2) {
00283                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00284 
00285                 if (s->mb_x)
00286                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
00287                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
00288                 for(j = 0; j < 2; j++) {
00289                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00290                     if (s->mb_x >= 2) {
00291                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 16 * s->uvlinesize, s->uvlinesize, pq);
00292                     }
00293                 }
00294             }
00295             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
00296         }
00297 
00298         if (s->mb_y == s->end_mb_y) {
00299             if (s->mb_x) {
00300                 if (s->mb_x >= 2)
00301                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
00302                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
00303                 if (s->mb_x >= 2) {
00304                     for(j = 0; j < 2; j++) {
00305                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
00306                     }
00307                 }
00308             }
00309 
00310             if (s->mb_x == s->mb_width - 1) {
00311                 if (s->mb_x)
00312                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
00313                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
00314                 if (s->mb_x) {
00315                     for(j = 0; j < 2; j++) {
00316                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j+1] - 8 * s->uvlinesize, s->uvlinesize, pq);
00317                     }
00318                 }
00319             }
00320         }
00321     }
00322 }
00323 
00324 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
00325 {
00326     MpegEncContext *s = &v->s;
00327     int mb_pos;
00328 
00329     if (v->condover == CONDOVER_NONE)
00330         return;
00331 
00332     mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00333 
00334     /* Within a MB, the horizontal overlap always runs before the vertical.
00335      * To accomplish that, we run the H on left and internal borders of the
00336      * currently decoded MB. Then, we wait for the next overlap iteration
00337      * to do H overlap on the right edge of this MB, before moving over and
00338      * running the V overlap. Therefore, the V overlap makes us trail by one
00339      * MB col and the H overlap filter makes us trail by one MB row. This
00340      * is reflected in the time at which we run the put_pixels loop. */
00341     if(v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
00342         if(s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00343                        v->over_flags_plane[mb_pos - 1])) {
00344             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
00345                                       v->block[v->cur_blk_idx][0]);
00346             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
00347                                       v->block[v->cur_blk_idx][2]);
00348             if(!(s->flags & CODEC_FLAG_GRAY)) {
00349                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
00350                                           v->block[v->cur_blk_idx][4]);
00351                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
00352                                           v->block[v->cur_blk_idx][5]);
00353             }
00354         }
00355         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
00356                                   v->block[v->cur_blk_idx][1]);
00357         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
00358                                   v->block[v->cur_blk_idx][3]);
00359 
00360         if (s->mb_x == s->mb_width - 1) {
00361             if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00362                                         v->over_flags_plane[mb_pos - s->mb_stride])) {
00363                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
00364                                           v->block[v->cur_blk_idx][0]);
00365                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
00366                                           v->block[v->cur_blk_idx][1]);
00367                 if(!(s->flags & CODEC_FLAG_GRAY)) {
00368                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
00369                                               v->block[v->cur_blk_idx][4]);
00370                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
00371                                               v->block[v->cur_blk_idx][5]);
00372                 }
00373             }
00374             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
00375                                       v->block[v->cur_blk_idx][2]);
00376             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
00377                                       v->block[v->cur_blk_idx][3]);
00378         }
00379     }
00380     if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
00381         if(!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
00382                                     v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
00383             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
00384                                       v->block[v->left_blk_idx][0]);
00385             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
00386                                       v->block[v->left_blk_idx][1]);
00387             if(!(s->flags & CODEC_FLAG_GRAY)) {
00388                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
00389                                           v->block[v->left_blk_idx][4]);
00390                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
00391                                           v->block[v->left_blk_idx][5]);
00392             }
00393         }
00394         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
00395                                   v->block[v->left_blk_idx][2]);
00396         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
00397                                   v->block[v->left_blk_idx][3]);
00398     }
00399 }
00400 
00404 static void vc1_mc_1mv(VC1Context *v, int dir)
00405 {
00406     MpegEncContext *s = &v->s;
00407     DSPContext *dsp = &v->s.dsp;
00408     uint8_t *srcY, *srcU, *srcV;
00409     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00410 
00411     if(!v->s.last_picture.data[0])return;
00412 
00413     mx = s->mv[dir][0][0];
00414     my = s->mv[dir][0][1];
00415 
00416     // store motion vectors for further use in B frames
00417     if(s->pict_type == AV_PICTURE_TYPE_P) {
00418         s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
00419         s->current_picture.motion_val[1][s->block_index[0]][1] = my;
00420     }
00421     uvmx = (mx + ((mx & 3) == 3)) >> 1;
00422     uvmy = (my + ((my & 3) == 3)) >> 1;
00423     v->luma_mv[s->mb_x][0] = uvmx;
00424     v->luma_mv[s->mb_x][1] = uvmy;
00425     if(v->fastuvmc) {
00426         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00427         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00428     }
00429     if(!dir) {
00430         srcY = s->last_picture.data[0];
00431         srcU = s->last_picture.data[1];
00432         srcV = s->last_picture.data[2];
00433     } else {
00434         srcY = s->next_picture.data[0];
00435         srcU = s->next_picture.data[1];
00436         srcV = s->next_picture.data[2];
00437     }
00438 
00439     src_x = s->mb_x * 16 + (mx >> 2);
00440     src_y = s->mb_y * 16 + (my >> 2);
00441     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00442     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00443 
00444     if(v->profile != PROFILE_ADVANCED){
00445         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
00446         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
00447         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
00448         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
00449     }else{
00450         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
00451         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
00452         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
00453         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
00454     }
00455 
00456     srcY += src_y * s->linesize + src_x;
00457     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00458     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00459 
00460     /* for grayscale we should not try to read from unknown area */
00461     if(s->flags & CODEC_FLAG_GRAY) {
00462         srcU = s->edge_emu_buffer + 18 * s->linesize;
00463         srcV = s->edge_emu_buffer + 18 * s->linesize;
00464     }
00465 
00466     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00467        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
00468        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
00469         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
00470 
00471         srcY -= s->mspel * (1 + s->linesize);
00472         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
00473                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00474         srcY = s->edge_emu_buffer;
00475         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
00476                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00477         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
00478                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00479         srcU = uvbuf;
00480         srcV = uvbuf + 16;
00481         /* if we deal with range reduction we need to scale source blocks */
00482         if(v->rangeredfrm) {
00483             int i, j;
00484             uint8_t *src, *src2;
00485 
00486             src = srcY;
00487             for(j = 0; j < 17 + s->mspel*2; j++) {
00488                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00489                 src += s->linesize;
00490             }
00491             src = srcU; src2 = srcV;
00492             for(j = 0; j < 9; j++) {
00493                 for(i = 0; i < 9; i++) {
00494                     src[i] = ((src[i] - 128) >> 1) + 128;
00495                     src2[i] = ((src2[i] - 128) >> 1) + 128;
00496                 }
00497                 src += s->uvlinesize;
00498                 src2 += s->uvlinesize;
00499             }
00500         }
00501         /* if we deal with intensity compensation we need to scale source blocks */
00502         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00503             int i, j;
00504             uint8_t *src, *src2;
00505 
00506             src = srcY;
00507             for(j = 0; j < 17 + s->mspel*2; j++) {
00508                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00509                 src += s->linesize;
00510             }
00511             src = srcU; src2 = srcV;
00512             for(j = 0; j < 9; j++) {
00513                 for(i = 0; i < 9; i++) {
00514                     src[i] = v->lutuv[src[i]];
00515                     src2[i] = v->lutuv[src2[i]];
00516                 }
00517                 src += s->uvlinesize;
00518                 src2 += s->uvlinesize;
00519             }
00520         }
00521         srcY += s->mspel * (1 + s->linesize);
00522     }
00523 
00524     if(s->mspel) {
00525         dxy = ((my & 3) << 2) | (mx & 3);
00526         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
00527         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
00528         srcY += s->linesize * 8;
00529         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
00530         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
00531     } else { // hpel mc - always used for luma
00532         dxy = (my & 2) | ((mx & 2) >> 1);
00533 
00534         if(!v->rnd)
00535             dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00536         else
00537             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
00538     }
00539 
00540     if(s->flags & CODEC_FLAG_GRAY) return;
00541     /* Chroma MC always uses qpel bilinear */
00542     uvmx = (uvmx&3)<<1;
00543     uvmy = (uvmy&3)<<1;
00544     if(!v->rnd){
00545         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00546         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00547     }else{
00548         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00549         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00550     }
00551 }
00552 
00555 static void vc1_mc_4mv_luma(VC1Context *v, int n)
00556 {
00557     MpegEncContext *s = &v->s;
00558     DSPContext *dsp = &v->s.dsp;
00559     uint8_t *srcY;
00560     int dxy, mx, my, src_x, src_y;
00561     int off;
00562 
00563     if(!v->s.last_picture.data[0])return;
00564     mx = s->mv[0][n][0];
00565     my = s->mv[0][n][1];
00566     srcY = s->last_picture.data[0];
00567 
00568     off = s->linesize * 4 * (n&2) + (n&1) * 8;
00569 
00570     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
00571     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
00572 
00573     if(v->profile != PROFILE_ADVANCED){
00574         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
00575         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
00576     }else{
00577         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
00578         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
00579     }
00580 
00581     srcY += src_y * s->linesize + src_x;
00582 
00583     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00584        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
00585        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
00586         srcY -= s->mspel * (1 + s->linesize);
00587         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
00588                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
00589         srcY = s->edge_emu_buffer;
00590         /* if we deal with range reduction we need to scale source blocks */
00591         if(v->rangeredfrm) {
00592             int i, j;
00593             uint8_t *src;
00594 
00595             src = srcY;
00596             for(j = 0; j < 9 + s->mspel*2; j++) {
00597                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
00598                 src += s->linesize;
00599             }
00600         }
00601         /* if we deal with intensity compensation we need to scale source blocks */
00602         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00603             int i, j;
00604             uint8_t *src;
00605 
00606             src = srcY;
00607             for(j = 0; j < 9 + s->mspel*2; j++) {
00608                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
00609                 src += s->linesize;
00610             }
00611         }
00612         srcY += s->mspel * (1 + s->linesize);
00613     }
00614 
00615     if(s->mspel) {
00616         dxy = ((my & 3) << 2) | (mx & 3);
00617         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
00618     } else { // hpel mc - always used for luma
00619         dxy = (my & 2) | ((mx & 2) >> 1);
00620         if(!v->rnd)
00621             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00622         else
00623             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
00624     }
00625 }
00626 
00627 static inline int median4(int a, int b, int c, int d)
00628 {
00629     if(a < b) {
00630         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
00631         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
00632     } else {
00633         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
00634         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
00635     }
00636 }
00637 
00638 
00641 static void vc1_mc_4mv_chroma(VC1Context *v)
00642 {
00643     MpegEncContext *s = &v->s;
00644     DSPContext *dsp = &v->s.dsp;
00645     uint8_t *srcU, *srcV;
00646     int uvmx, uvmy, uvsrc_x, uvsrc_y;
00647     int i, idx, tx = 0, ty = 0;
00648     int mvx[4], mvy[4], intra[4];
00649     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
00650 
00651     if(!v->s.last_picture.data[0])return;
00652     if(s->flags & CODEC_FLAG_GRAY) return;
00653 
00654     for(i = 0; i < 4; i++) {
00655         mvx[i] = s->mv[0][i][0];
00656         mvy[i] = s->mv[0][i][1];
00657         intra[i] = v->mb_type[0][s->block_index[i]];
00658     }
00659 
00660     /* calculate chroma MV vector from four luma MVs */
00661     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
00662     if(!idx) { // all blocks are inter
00663         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
00664         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
00665     } else if(count[idx] == 1) { // 3 inter blocks
00666         switch(idx) {
00667         case 0x1:
00668             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
00669             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
00670             break;
00671         case 0x2:
00672             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
00673             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
00674             break;
00675         case 0x4:
00676             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
00677             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
00678             break;
00679         case 0x8:
00680             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
00681             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
00682             break;
00683         }
00684     } else if(count[idx] == 2) {
00685         int t1 = 0, t2 = 0;
00686         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
00687         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
00688         tx = (mvx[t1] + mvx[t2]) / 2;
00689         ty = (mvy[t1] + mvy[t2]) / 2;
00690     } else {
00691         s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
00692         s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
00693         v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
00694         return; //no need to do MC for inter blocks
00695     }
00696 
00697     s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
00698     s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
00699     uvmx = (tx + ((tx&3) == 3)) >> 1;
00700     uvmy = (ty + ((ty&3) == 3)) >> 1;
00701     v->luma_mv[s->mb_x][0] = uvmx;
00702     v->luma_mv[s->mb_x][1] = uvmy;
00703     if(v->fastuvmc) {
00704         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
00705         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
00706     }
00707 
00708     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
00709     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
00710 
00711     if(v->profile != PROFILE_ADVANCED){
00712         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
00713         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
00714     }else{
00715         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
00716         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
00717     }
00718 
00719     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
00720     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
00721     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
00722        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
00723        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
00724         s->dsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
00725                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00726         s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
00727                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00728         srcU = s->edge_emu_buffer;
00729         srcV = s->edge_emu_buffer + 16;
00730 
00731         /* if we deal with range reduction we need to scale source blocks */
00732         if(v->rangeredfrm) {
00733             int i, j;
00734             uint8_t *src, *src2;
00735 
00736             src = srcU; src2 = srcV;
00737             for(j = 0; j < 9; j++) {
00738                 for(i = 0; i < 9; i++) {
00739                     src[i] = ((src[i] - 128) >> 1) + 128;
00740                     src2[i] = ((src2[i] - 128) >> 1) + 128;
00741                 }
00742                 src += s->uvlinesize;
00743                 src2 += s->uvlinesize;
00744             }
00745         }
00746         /* if we deal with intensity compensation we need to scale source blocks */
00747         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
00748             int i, j;
00749             uint8_t *src, *src2;
00750 
00751             src = srcU; src2 = srcV;
00752             for(j = 0; j < 9; j++) {
00753                 for(i = 0; i < 9; i++) {
00754                     src[i] = v->lutuv[src[i]];
00755                     src2[i] = v->lutuv[src2[i]];
00756                 }
00757                 src += s->uvlinesize;
00758                 src2 += s->uvlinesize;
00759             }
00760         }
00761     }
00762 
00763     /* Chroma MC always uses qpel bilinear */
00764     uvmx = (uvmx&3)<<1;
00765     uvmy = (uvmy&3)<<1;
00766     if(!v->rnd){
00767         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00768         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00769     }else{
00770         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
00771         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
00772     }
00773 }
00774 
00775 /***********************************************************************/
00786 #define GET_MQUANT()                                           \
00787   if (v->dquantfrm)                                            \
00788   {                                                            \
00789     int edges = 0;                                             \
00790     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
00791     {                                                          \
00792       if (v->dqbilevel)                                        \
00793       {                                                        \
00794         mquant = (get_bits1(gb)) ? v->altpq : v->pq;           \
00795       }                                                        \
00796       else                                                     \
00797       {                                                        \
00798         mqdiff = get_bits(gb, 3);                              \
00799         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
00800         else mquant = get_bits(gb, 5);                         \
00801       }                                                        \
00802     }                                                          \
00803     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
00804         edges = 1 << v->dqsbedge;                              \
00805     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
00806         edges = (3 << v->dqsbedge) % 15;                       \
00807     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
00808         edges = 15;                                            \
00809     if((edges&1) && !s->mb_x)                                  \
00810         mquant = v->altpq;                                     \
00811     if((edges&2) && s->first_slice_line)                       \
00812         mquant = v->altpq;                                     \
00813     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
00814         mquant = v->altpq;                                     \
00815     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
00816         mquant = v->altpq;                                     \
00817   }
00818 
00826 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
00827   index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
00828                        VC1_MV_DIFF_VLC_BITS, 2);                    \
00829   if (index > 36)                                                   \
00830   {                                                                 \
00831     mb_has_coeffs = 1;                                              \
00832     index -= 37;                                                    \
00833   }                                                                 \
00834   else mb_has_coeffs = 0;                                           \
00835   s->mb_intra = 0;                                                  \
00836   if (!index) { _dmv_x = _dmv_y = 0; }                              \
00837   else if (index == 35)                                             \
00838   {                                                                 \
00839     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
00840     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
00841   }                                                                 \
00842   else if (index == 36)                                             \
00843   {                                                                 \
00844     _dmv_x = 0;                                                     \
00845     _dmv_y = 0;                                                     \
00846     s->mb_intra = 1;                                                \
00847   }                                                                 \
00848   else                                                              \
00849   {                                                                 \
00850     index1 = index%6;                                               \
00851     if (!s->quarter_sample && index1 == 5) val = 1;                 \
00852     else                                   val = 0;                 \
00853     if(size_table[index1] - val > 0)                                \
00854         val = get_bits(gb, size_table[index1] - val);               \
00855     else                                   val = 0;                 \
00856     sign = 0 - (val&1);                                             \
00857     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
00858                                                                     \
00859     index1 = index/6;                                               \
00860     if (!s->quarter_sample && index1 == 5) val = 1;                 \
00861     else                                   val = 0;                 \
00862     if(size_table[index1] - val > 0)                                \
00863         val = get_bits(gb, size_table[index1] - val);               \
00864     else                                   val = 0;                 \
00865     sign = 0 - (val&1);                                             \
00866     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
00867   }
00868 
00871 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
00872 {
00873     MpegEncContext *s = &v->s;
00874     int xy, wrap, off = 0;
00875     int16_t *A, *B, *C;
00876     int px, py;
00877     int sum;
00878 
00879     /* scale MV difference to be quad-pel */
00880     dmv_x <<= 1 - s->quarter_sample;
00881     dmv_y <<= 1 - s->quarter_sample;
00882 
00883     wrap = s->b8_stride;
00884     xy = s->block_index[n];
00885 
00886     if(s->mb_intra){
00887         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
00888         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
00889         s->current_picture.motion_val[1][xy][0] = 0;
00890         s->current_picture.motion_val[1][xy][1] = 0;
00891         if(mv1) { /* duplicate motion data for 1-MV block */
00892             s->current_picture.motion_val[0][xy + 1][0] = 0;
00893             s->current_picture.motion_val[0][xy + 1][1] = 0;
00894             s->current_picture.motion_val[0][xy + wrap][0] = 0;
00895             s->current_picture.motion_val[0][xy + wrap][1] = 0;
00896             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
00897             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
00898             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
00899             s->current_picture.motion_val[1][xy + 1][0] = 0;
00900             s->current_picture.motion_val[1][xy + 1][1] = 0;
00901             s->current_picture.motion_val[1][xy + wrap][0] = 0;
00902             s->current_picture.motion_val[1][xy + wrap][1] = 0;
00903             s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
00904             s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
00905         }
00906         return;
00907     }
00908 
00909     C = s->current_picture.motion_val[0][xy - 1];
00910     A = s->current_picture.motion_val[0][xy - wrap];
00911     if(mv1)
00912         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
00913     else {
00914         //in 4-MV mode different blocks have different B predictor position
00915         switch(n){
00916         case 0:
00917             off = (s->mb_x > 0) ? -1 : 1;
00918             break;
00919         case 1:
00920             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
00921             break;
00922         case 2:
00923             off = 1;
00924             break;
00925         case 3:
00926             off = -1;
00927         }
00928     }
00929     B = s->current_picture.motion_val[0][xy - wrap + off];
00930 
00931     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
00932         if(s->mb_width == 1) {
00933             px = A[0];
00934             py = A[1];
00935         } else {
00936             px = mid_pred(A[0], B[0], C[0]);
00937             py = mid_pred(A[1], B[1], C[1]);
00938         }
00939     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
00940         px = C[0];
00941         py = C[1];
00942     } else {
00943         px = py = 0;
00944     }
00945     /* Pullback MV as specified in 8.3.5.3.4 */
00946     {
00947         int qx, qy, X, Y;
00948         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
00949         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
00950         X = (s->mb_width << 6) - 4;
00951         Y = (s->mb_height << 6) - 4;
00952         if(mv1) {
00953             if(qx + px < -60) px = -60 - qx;
00954             if(qy + py < -60) py = -60 - qy;
00955         } else {
00956             if(qx + px < -28) px = -28 - qx;
00957             if(qy + py < -28) py = -28 - qy;
00958         }
00959         if(qx + px > X) px = X - qx;
00960         if(qy + py > Y) py = Y - qy;
00961     }
00962     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
00963     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
00964         if(is_intra[xy - wrap])
00965             sum = FFABS(px) + FFABS(py);
00966         else
00967             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
00968         if(sum > 32) {
00969             if(get_bits1(&s->gb)) {
00970                 px = A[0];
00971                 py = A[1];
00972             } else {
00973                 px = C[0];
00974                 py = C[1];
00975             }
00976         } else {
00977             if(is_intra[xy - 1])
00978                 sum = FFABS(px) + FFABS(py);
00979             else
00980                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
00981             if(sum > 32) {
00982                 if(get_bits1(&s->gb)) {
00983                     px = A[0];
00984                     py = A[1];
00985                 } else {
00986                     px = C[0];
00987                     py = C[1];
00988                 }
00989             }
00990         }
00991     }
00992     /* store MV using signed modulus of MV range defined in 4.11 */
00993     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
00994     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
00995     if(mv1) { /* duplicate motion data for 1-MV block */
00996         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
00997         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
00998         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
00999         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
01000         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
01001         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
01002     }
01003 }
01004 
01007 static void vc1_interp_mc(VC1Context *v)
01008 {
01009     MpegEncContext *s = &v->s;
01010     DSPContext *dsp = &v->s.dsp;
01011     uint8_t *srcY, *srcU, *srcV;
01012     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
01013 
01014     if(!v->s.next_picture.data[0])return;
01015 
01016     mx = s->mv[1][0][0];
01017     my = s->mv[1][0][1];
01018     uvmx = (mx + ((mx & 3) == 3)) >> 1;
01019     uvmy = (my + ((my & 3) == 3)) >> 1;
01020     if(v->fastuvmc) {
01021         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
01022         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
01023     }
01024     srcY = s->next_picture.data[0];
01025     srcU = s->next_picture.data[1];
01026     srcV = s->next_picture.data[2];
01027 
01028     src_x = s->mb_x * 16 + (mx >> 2);
01029     src_y = s->mb_y * 16 + (my >> 2);
01030     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
01031     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
01032 
01033     if(v->profile != PROFILE_ADVANCED){
01034         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
01035         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
01036         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
01037         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
01038     }else{
01039         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
01040         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
01041         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
01042         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
01043     }
01044 
01045     srcY += src_y * s->linesize + src_x;
01046     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
01047     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
01048 
01049     /* for grayscale we should not try to read from unknown area */
01050     if(s->flags & CODEC_FLAG_GRAY) {
01051         srcU = s->edge_emu_buffer + 18 * s->linesize;
01052         srcV = s->edge_emu_buffer + 18 * s->linesize;
01053     }
01054 
01055     if(v->rangeredfrm
01056        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
01057        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
01058         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
01059 
01060         srcY -= s->mspel * (1 + s->linesize);
01061         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
01062                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
01063         srcY = s->edge_emu_buffer;
01064         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
01065                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
01066         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
01067                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
01068         srcU = uvbuf;
01069         srcV = uvbuf + 16;
01070         /* if we deal with range reduction we need to scale source blocks */
01071         if(v->rangeredfrm) {
01072             int i, j;
01073             uint8_t *src, *src2;
01074 
01075             src = srcY;
01076             for(j = 0; j < 17 + s->mspel*2; j++) {
01077                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
01078                 src += s->linesize;
01079             }
01080             src = srcU; src2 = srcV;
01081             for(j = 0; j < 9; j++) {
01082                 for(i = 0; i < 9; i++) {
01083                     src[i] = ((src[i] - 128) >> 1) + 128;
01084                     src2[i] = ((src2[i] - 128) >> 1) + 128;
01085                 }
01086                 src += s->uvlinesize;
01087                 src2 += s->uvlinesize;
01088             }
01089         }
01090         srcY += s->mspel * (1 + s->linesize);
01091     }
01092 
01093     if(s->mspel) {
01094         dxy = ((my & 3) << 2) | (mx & 3);
01095         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
01096         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
01097         srcY += s->linesize * 8;
01098         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
01099         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
01100     } else { // hpel mc
01101         dxy = (my & 2) | ((mx & 2) >> 1);
01102 
01103         if(!v->rnd)
01104             dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
01105         else
01106             dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
01107     }
01108 
01109     if(s->flags & CODEC_FLAG_GRAY) return;
01110     /* Chroma MC always uses qpel blilinear */
01111     uvmx = (uvmx&3)<<1;
01112     uvmy = (uvmy&3)<<1;
01113     if(!v->rnd){
01114         dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
01115         dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
01116     }else{
01117         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
01118         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
01119     }
01120 }
01121 
01122 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
01123 {
01124     int n = bfrac;
01125 
01126 #if B_FRACTION_DEN==256
01127     if(inv)
01128         n -= 256;
01129     if(!qs)
01130         return 2 * ((value * n + 255) >> 9);
01131     return (value * n + 128) >> 8;
01132 #else
01133     if(inv)
01134         n -= B_FRACTION_DEN;
01135     if(!qs)
01136         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
01137     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
01138 #endif
01139 }
01140 
01143 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
01144 {
01145     if(v->use_ic) {
01146         v->mv_mode2 = v->mv_mode;
01147         v->mv_mode = MV_PMODE_INTENSITY_COMP;
01148     }
01149     if(direct) {
01150         vc1_mc_1mv(v, 0);
01151         vc1_interp_mc(v);
01152         if(v->use_ic) v->mv_mode = v->mv_mode2;
01153         return;
01154     }
01155     if(mode == BMV_TYPE_INTERPOLATED) {
01156         vc1_mc_1mv(v, 0);
01157         vc1_interp_mc(v);
01158         if(v->use_ic) v->mv_mode = v->mv_mode2;
01159         return;
01160     }
01161 
01162     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
01163     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
01164     if(v->use_ic) v->mv_mode = v->mv_mode2;
01165 }
01166 
01167 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
01168 {
01169     MpegEncContext *s = &v->s;
01170     int xy, wrap, off = 0;
01171     int16_t *A, *B, *C;
01172     int px, py;
01173     int sum;
01174     int r_x, r_y;
01175     const uint8_t *is_intra = v->mb_type[0];
01176 
01177     r_x = v->range_x;
01178     r_y = v->range_y;
01179     /* scale MV difference to be quad-pel */
01180     dmv_x[0] <<= 1 - s->quarter_sample;
01181     dmv_y[0] <<= 1 - s->quarter_sample;
01182     dmv_x[1] <<= 1 - s->quarter_sample;
01183     dmv_y[1] <<= 1 - s->quarter_sample;
01184 
01185     wrap = s->b8_stride;
01186     xy = s->block_index[0];
01187 
01188     if(s->mb_intra) {
01189         s->current_picture.motion_val[0][xy][0] =
01190         s->current_picture.motion_val[0][xy][1] =
01191         s->current_picture.motion_val[1][xy][0] =
01192         s->current_picture.motion_val[1][xy][1] = 0;
01193         return;
01194     }
01195     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
01196     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
01197     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
01198     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
01199 
01200     /* Pullback predicted motion vectors as specified in 8.4.5.4 */
01201     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));
01202     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));
01203     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));
01204     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));
01205     if(direct) {
01206         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01207         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01208         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01209         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01210         return;
01211     }
01212 
01213     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01214         C = s->current_picture.motion_val[0][xy - 2];
01215         A = s->current_picture.motion_val[0][xy - wrap*2];
01216         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01217         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
01218 
01219         if(!s->mb_x) C[0] = C[1] = 0;
01220         if(!s->first_slice_line) { // predictor A is not out of bounds
01221             if(s->mb_width == 1) {
01222                 px = A[0];
01223                 py = A[1];
01224             } else {
01225                 px = mid_pred(A[0], B[0], C[0]);
01226                 py = mid_pred(A[1], B[1], C[1]);
01227             }
01228         } else if(s->mb_x) { // predictor C is not out of bounds
01229             px = C[0];
01230             py = C[1];
01231         } else {
01232             px = py = 0;
01233         }
01234         /* Pullback MV as specified in 8.3.5.3.4 */
01235         {
01236             int qx, qy, X, Y;
01237             if(v->profile < PROFILE_ADVANCED) {
01238                 qx = (s->mb_x << 5);
01239                 qy = (s->mb_y << 5);
01240                 X = (s->mb_width << 5) - 4;
01241                 Y = (s->mb_height << 5) - 4;
01242                 if(qx + px < -28) px = -28 - qx;
01243                 if(qy + py < -28) py = -28 - qy;
01244                 if(qx + px > X) px = X - qx;
01245                 if(qy + py > Y) py = Y - qy;
01246             } else {
01247                 qx = (s->mb_x << 6);
01248                 qy = (s->mb_y << 6);
01249                 X = (s->mb_width << 6) - 4;
01250                 Y = (s->mb_height << 6) - 4;
01251                 if(qx + px < -60) px = -60 - qx;
01252                 if(qy + py < -60) py = -60 - qy;
01253                 if(qx + px > X) px = X - qx;
01254                 if(qy + py > Y) py = Y - qy;
01255             }
01256         }
01257         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
01258         if(0 && !s->first_slice_line && s->mb_x) {
01259             if(is_intra[xy - wrap])
01260                 sum = FFABS(px) + FFABS(py);
01261             else
01262                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01263             if(sum > 32) {
01264                 if(get_bits1(&s->gb)) {
01265                     px = A[0];
01266                     py = A[1];
01267                 } else {
01268                     px = C[0];
01269                     py = C[1];
01270                 }
01271             } else {
01272                 if(is_intra[xy - 2])
01273                     sum = FFABS(px) + FFABS(py);
01274                 else
01275                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01276                 if(sum > 32) {
01277                     if(get_bits1(&s->gb)) {
01278                         px = A[0];
01279                         py = A[1];
01280                     } else {
01281                         px = C[0];
01282                         py = C[1];
01283                     }
01284                 }
01285             }
01286         }
01287         /* store MV using signed modulus of MV range defined in 4.11 */
01288         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
01289         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
01290     }
01291     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
01292         C = s->current_picture.motion_val[1][xy - 2];
01293         A = s->current_picture.motion_val[1][xy - wrap*2];
01294         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
01295         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
01296 
01297         if(!s->mb_x) C[0] = C[1] = 0;
01298         if(!s->first_slice_line) { // predictor A is not out of bounds
01299             if(s->mb_width == 1) {
01300                 px = A[0];
01301                 py = A[1];
01302             } else {
01303                 px = mid_pred(A[0], B[0], C[0]);
01304                 py = mid_pred(A[1], B[1], C[1]);
01305             }
01306         } else if(s->mb_x) { // predictor C is not out of bounds
01307             px = C[0];
01308             py = C[1];
01309         } else {
01310             px = py = 0;
01311         }
01312         /* Pullback MV as specified in 8.3.5.3.4 */
01313         {
01314             int qx, qy, X, Y;
01315             if(v->profile < PROFILE_ADVANCED) {
01316                 qx = (s->mb_x << 5);
01317                 qy = (s->mb_y << 5);
01318                 X = (s->mb_width << 5) - 4;
01319                 Y = (s->mb_height << 5) - 4;
01320                 if(qx + px < -28) px = -28 - qx;
01321                 if(qy + py < -28) py = -28 - qy;
01322                 if(qx + px > X) px = X - qx;
01323                 if(qy + py > Y) py = Y - qy;
01324             } else {
01325                 qx = (s->mb_x << 6);
01326                 qy = (s->mb_y << 6);
01327                 X = (s->mb_width << 6) - 4;
01328                 Y = (s->mb_height << 6) - 4;
01329                 if(qx + px < -60) px = -60 - qx;
01330                 if(qy + py < -60) py = -60 - qy;
01331                 if(qx + px > X) px = X - qx;
01332                 if(qy + py > Y) py = Y - qy;
01333             }
01334         }
01335         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
01336         if(0 && !s->first_slice_line && s->mb_x) {
01337             if(is_intra[xy - wrap])
01338                 sum = FFABS(px) + FFABS(py);
01339             else
01340                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
01341             if(sum > 32) {
01342                 if(get_bits1(&s->gb)) {
01343                     px = A[0];
01344                     py = A[1];
01345                 } else {
01346                     px = C[0];
01347                     py = C[1];
01348                 }
01349             } else {
01350                 if(is_intra[xy - 2])
01351                     sum = FFABS(px) + FFABS(py);
01352                 else
01353                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
01354                 if(sum > 32) {
01355                     if(get_bits1(&s->gb)) {
01356                         px = A[0];
01357                         py = A[1];
01358                     } else {
01359                         px = C[0];
01360                         py = C[1];
01361                     }
01362                 }
01363             }
01364         }
01365         /* store MV using signed modulus of MV range defined in 4.11 */
01366 
01367         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
01368         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
01369     }
01370     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
01371     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
01372     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
01373     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
01374 }
01375 
01385 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01386                               int16_t **dc_val_ptr, int *dir_ptr)
01387 {
01388     int a, b, c, wrap, pred, scale;
01389     int16_t *dc_val;
01390     static const uint16_t dcpred[32] = {
01391     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
01392          114,  102,   93,   85,   79,   73,   68,   64,
01393           60,   57,   54,   51,   49,   47,   45,   43,
01394           41,   39,   38,   37,   35,   34,   33
01395     };
01396 
01397     /* find prediction - wmv3_dc_scale always used here in fact */
01398     if (n < 4)     scale = s->y_dc_scale;
01399     else           scale = s->c_dc_scale;
01400 
01401     wrap = s->block_wrap[n];
01402     dc_val= s->dc_val[0] + s->block_index[n];
01403 
01404     /* B A
01405      * C X
01406      */
01407     c = dc_val[ - 1];
01408     b = dc_val[ - 1 - wrap];
01409     a = dc_val[ - wrap];
01410 
01411     if (pq < 9 || !overlap)
01412     {
01413         /* Set outer values */
01414         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
01415         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
01416     }
01417     else
01418     {
01419         /* Set outer values */
01420         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
01421         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
01422     }
01423 
01424     if (abs(a - b) <= abs(b - c)) {
01425         pred = c;
01426         *dir_ptr = 1;//left
01427     } else {
01428         pred = a;
01429         *dir_ptr = 0;//top
01430     }
01431 
01432     /* update predictor */
01433     *dc_val_ptr = &dc_val[0];
01434     return pred;
01435 }
01436 
01437 
01449 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
01450                               int a_avail, int c_avail,
01451                               int16_t **dc_val_ptr, int *dir_ptr)
01452 {
01453     int a, b, c, wrap, pred;
01454     int16_t *dc_val;
01455     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01456     int q1, q2 = 0;
01457 
01458     wrap = s->block_wrap[n];
01459     dc_val= s->dc_val[0] + s->block_index[n];
01460 
01461     /* B A
01462      * C X
01463      */
01464     c = dc_val[ - 1];
01465     b = dc_val[ - 1 - wrap];
01466     a = dc_val[ - wrap];
01467     /* scale predictors if needed */
01468     q1 = s->current_picture.qscale_table[mb_pos];
01469     if(c_avail && (n!= 1 && n!=3)) {
01470         q2 = s->current_picture.qscale_table[mb_pos - 1];
01471         if(q2 && q2 != q1)
01472             c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01473     }
01474     if(a_avail && (n!= 2 && n!=3)) {
01475         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01476         if(q2 && q2 != q1)
01477             a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01478     }
01479     if(a_avail && c_avail && (n!=3)) {
01480         int off = mb_pos;
01481         if(n != 1) off--;
01482         if(n != 2) off -= s->mb_stride;
01483         q2 = s->current_picture.qscale_table[off];
01484         if(q2 && q2 != q1)
01485             b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
01486     }
01487 
01488     if(a_avail && c_avail) {
01489         if(abs(a - b) <= abs(b - c)) {
01490             pred = c;
01491             *dir_ptr = 1;//left
01492         } else {
01493             pred = a;
01494             *dir_ptr = 0;//top
01495         }
01496     } else if(a_avail) {
01497         pred = a;
01498         *dir_ptr = 0;//top
01499     } else if(c_avail) {
01500         pred = c;
01501         *dir_ptr = 1;//left
01502     } else {
01503         pred = 0;
01504         *dir_ptr = 1;//left
01505     }
01506 
01507     /* update predictor */
01508     *dc_val_ptr = &dc_val[0];
01509     return pred;
01510 }
01511  // Block group
01513 
01520 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
01521 {
01522     int xy, wrap, pred, a, b, c;
01523 
01524     xy = s->block_index[n];
01525     wrap = s->b8_stride;
01526 
01527     /* B C
01528      * A X
01529      */
01530     a = s->coded_block[xy - 1       ];
01531     b = s->coded_block[xy - 1 - wrap];
01532     c = s->coded_block[xy     - wrap];
01533 
01534     if (b == c) {
01535         pred = a;
01536     } else {
01537         pred = c;
01538     }
01539 
01540     /* store value */
01541     *coded_block_ptr = &s->coded_block[xy];
01542 
01543     return pred;
01544 }
01545 
01555 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
01556 {
01557     GetBitContext *gb = &v->s.gb;
01558     int index, escape, run = 0, level = 0, lst = 0;
01559 
01560     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01561     if (index != vc1_ac_sizes[codingset] - 1) {
01562         run = vc1_index_decode_table[codingset][index][0];
01563         level = vc1_index_decode_table[codingset][index][1];
01564         lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
01565         if(get_bits1(gb))
01566             level = -level;
01567     } else {
01568         escape = decode210(gb);
01569         if (escape != 2) {
01570             index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
01571             run = vc1_index_decode_table[codingset][index][0];
01572             level = vc1_index_decode_table[codingset][index][1];
01573             lst = index >= vc1_last_decode_table[codingset];
01574             if(escape == 0) {
01575                 if(lst)
01576                     level += vc1_last_delta_level_table[codingset][run];
01577                 else
01578                     level += vc1_delta_level_table[codingset][run];
01579             } else {
01580                 if(lst)
01581                     run += vc1_last_delta_run_table[codingset][level] + 1;
01582                 else
01583                     run += vc1_delta_run_table[codingset][level] + 1;
01584             }
01585             if(get_bits1(gb))
01586                 level = -level;
01587         } else {
01588             int sign;
01589             lst = get_bits1(gb);
01590             if(v->s.esc3_level_length == 0) {
01591                 if(v->pq < 8 || v->dquantfrm) { // table 59
01592                     v->s.esc3_level_length = get_bits(gb, 3);
01593                     if(!v->s.esc3_level_length)
01594                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
01595                 } else { //table 60
01596                     v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
01597                 }
01598                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
01599             }
01600             run = get_bits(gb, v->s.esc3_run_length);
01601             sign = get_bits1(gb);
01602             level = get_bits(gb, v->s.esc3_level_length);
01603             if(sign)
01604                 level = -level;
01605         }
01606     }
01607 
01608     *last = lst;
01609     *skip = run;
01610     *value = level;
01611 }
01612 
01620 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
01621 {
01622     GetBitContext *gb = &v->s.gb;
01623     MpegEncContext *s = &v->s;
01624     int dc_pred_dir = 0; /* Direction of the DC prediction used */
01625     int i;
01626     int16_t *dc_val;
01627     int16_t *ac_val, *ac_val2;
01628     int dcdiff;
01629 
01630     /* Get DC differential */
01631     if (n < 4) {
01632         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01633     } else {
01634         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01635     }
01636     if (dcdiff < 0){
01637         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01638         return -1;
01639     }
01640     if (dcdiff)
01641     {
01642         if (dcdiff == 119 /* ESC index value */)
01643         {
01644             /* TODO: Optimize */
01645             if (v->pq == 1) dcdiff = get_bits(gb, 10);
01646             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
01647             else dcdiff = get_bits(gb, 8);
01648         }
01649         else
01650         {
01651             if (v->pq == 1)
01652                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01653             else if (v->pq == 2)
01654                 dcdiff = (dcdiff<<1) + get_bits1(gb)   - 1;
01655         }
01656         if (get_bits1(gb))
01657             dcdiff = -dcdiff;
01658     }
01659 
01660     /* Prediction */
01661     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
01662     *dc_val = dcdiff;
01663 
01664     /* Store the quantized DC coeff, used for prediction */
01665     if (n < 4) {
01666         block[0] = dcdiff * s->y_dc_scale;
01667     } else {
01668         block[0] = dcdiff * s->c_dc_scale;
01669     }
01670     /* Skip ? */
01671     if (!coded) {
01672         goto not_coded;
01673     }
01674 
01675     //AC Decoding
01676     i = 1;
01677 
01678     {
01679         int last = 0, skip, value;
01680         const uint8_t *zz_table;
01681         int scale;
01682         int k;
01683 
01684         scale = v->pq * 2 + v->halfpq;
01685 
01686         if(v->s.ac_pred) {
01687             if(!dc_pred_dir)
01688                 zz_table = v->zz_8x8[2];
01689             else
01690                 zz_table = v->zz_8x8[3];
01691         } else
01692             zz_table = v->zz_8x8[1];
01693 
01694         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01695         ac_val2 = ac_val;
01696         if(dc_pred_dir) //left
01697             ac_val -= 16;
01698         else //top
01699             ac_val -= 16 * s->block_wrap[n];
01700 
01701         while (!last) {
01702             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01703             i += skip;
01704             if(i > 63)
01705                 break;
01706             block[zz_table[i++]] = value;
01707         }
01708 
01709         /* apply AC prediction if needed */
01710         if(s->ac_pred) {
01711             if(dc_pred_dir) { //left
01712                 for(k = 1; k < 8; k++)
01713                     block[k << v->left_blk_sh] += ac_val[k];
01714             } else { //top
01715                 for(k = 1; k < 8; k++)
01716                     block[k << v->top_blk_sh] += ac_val[k + 8];
01717             }
01718         }
01719         /* save AC coeffs for further prediction */
01720         for(k = 1; k < 8; k++) {
01721             ac_val2[k]     = block[k << v->left_blk_sh];
01722             ac_val2[k + 8] = block[k << v->top_blk_sh];
01723         }
01724 
01725         /* scale AC coeffs */
01726         for(k = 1; k < 64; k++)
01727             if(block[k]) {
01728                 block[k] *= scale;
01729                 if(!v->pquantizer)
01730                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
01731             }
01732 
01733         if(s->ac_pred) i = 63;
01734     }
01735 
01736 not_coded:
01737     if(!coded) {
01738         int k, scale;
01739         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01740         ac_val2 = ac_val;
01741 
01742         i = 0;
01743         scale = v->pq * 2 + v->halfpq;
01744         memset(ac_val2, 0, 16 * 2);
01745         if(dc_pred_dir) {//left
01746             ac_val -= 16;
01747             if(s->ac_pred)
01748                 memcpy(ac_val2, ac_val, 8 * 2);
01749         } else {//top
01750             ac_val -= 16 * s->block_wrap[n];
01751             if(s->ac_pred)
01752                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01753         }
01754 
01755         /* apply AC prediction if needed */
01756         if(s->ac_pred) {
01757             if(dc_pred_dir) { //left
01758                 for(k = 1; k < 8; k++) {
01759                     block[k << v->left_blk_sh] = ac_val[k] * scale;
01760                     if(!v->pquantizer && block[k << v->left_blk_sh])
01761                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
01762                 }
01763             } else { //top
01764                 for(k = 1; k < 8; k++) {
01765                     block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
01766                     if(!v->pquantizer && block[k << v->top_blk_sh])
01767                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
01768                 }
01769             }
01770             i = 63;
01771         }
01772     }
01773     s->block_last_index[n] = i;
01774 
01775     return 0;
01776 }
01777 
01786 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
01787 {
01788     GetBitContext *gb = &v->s.gb;
01789     MpegEncContext *s = &v->s;
01790     int dc_pred_dir = 0; /* Direction of the DC prediction used */
01791     int i;
01792     int16_t *dc_val;
01793     int16_t *ac_val, *ac_val2;
01794     int dcdiff;
01795     int a_avail = v->a_avail, c_avail = v->c_avail;
01796     int use_pred = s->ac_pred;
01797     int scale;
01798     int q1, q2 = 0;
01799     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01800 
01801     /* Get DC differential */
01802     if (n < 4) {
01803         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01804     } else {
01805         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
01806     }
01807     if (dcdiff < 0){
01808         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
01809         return -1;
01810     }
01811     if (dcdiff)
01812     {
01813         if (dcdiff == 119 /* ESC index value */)
01814         {
01815             /* TODO: Optimize */
01816             if (mquant == 1) dcdiff = get_bits(gb, 10);
01817             else if (mquant == 2) dcdiff = get_bits(gb, 9);
01818             else dcdiff = get_bits(gb, 8);
01819         }
01820         else
01821         {
01822             if (mquant == 1)
01823                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
01824             else if (mquant == 2)
01825                 dcdiff = (dcdiff<<1) + get_bits1(gb)   - 1;
01826         }
01827         if (get_bits1(gb))
01828             dcdiff = -dcdiff;
01829     }
01830 
01831     /* Prediction */
01832     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
01833     *dc_val = dcdiff;
01834 
01835     /* Store the quantized DC coeff, used for prediction */
01836     if (n < 4) {
01837         block[0] = dcdiff * s->y_dc_scale;
01838     } else {
01839         block[0] = dcdiff * s->c_dc_scale;
01840     }
01841 
01842     //AC Decoding
01843     i = 1;
01844 
01845     /* check if AC is needed at all */
01846     if(!a_avail && !c_avail) use_pred = 0;
01847     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
01848     ac_val2 = ac_val;
01849 
01850     scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
01851 
01852     if(dc_pred_dir) //left
01853         ac_val -= 16;
01854     else //top
01855         ac_val -= 16 * s->block_wrap[n];
01856 
01857     q1 = s->current_picture.qscale_table[mb_pos];
01858     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
01859     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
01860     if(dc_pred_dir && n==1) q2 = q1;
01861     if(!dc_pred_dir && n==2) q2 = q1;
01862     if(n==3) q2 = q1;
01863 
01864     if(coded) {
01865         int last = 0, skip, value;
01866         const uint8_t *zz_table;
01867         int k;
01868 
01869         if(v->s.ac_pred) {
01870             if(!dc_pred_dir)
01871                 zz_table = v->zz_8x8[2];
01872             else
01873                 zz_table = v->zz_8x8[3];
01874         } else
01875             zz_table = v->zz_8x8[1];
01876 
01877         while (!last) {
01878             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
01879             i += skip;
01880             if(i > 63)
01881                 break;
01882             block[zz_table[i++]] = value;
01883         }
01884 
01885         /* apply AC prediction if needed */
01886         if(use_pred) {
01887             /* scale predictors if needed*/
01888             if(q2 && q1!=q2) {
01889                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01890                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01891 
01892                 if(dc_pred_dir) { //left
01893                     for(k = 1; k < 8; k++)
01894                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01895                 } else { //top
01896                     for(k = 1; k < 8; k++)
01897                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01898                 }
01899             } else {
01900                 if(dc_pred_dir) { //left
01901                     for(k = 1; k < 8; k++)
01902                         block[k << v->left_blk_sh] += ac_val[k];
01903                 } else { //top
01904                     for(k = 1; k < 8; k++)
01905                         block[k << v->top_blk_sh] += ac_val[k + 8];
01906                 }
01907             }
01908         }
01909         /* save AC coeffs for further prediction */
01910         for(k = 1; k < 8; k++) {
01911             ac_val2[k    ] = block[k << v->left_blk_sh];
01912             ac_val2[k + 8] = block[k << v->top_blk_sh];
01913         }
01914 
01915         /* scale AC coeffs */
01916         for(k = 1; k < 64; k++)
01917             if(block[k]) {
01918                 block[k] *= scale;
01919                 if(!v->pquantizer)
01920                     block[k] += (block[k] < 0) ? -mquant : mquant;
01921             }
01922 
01923         if(use_pred) i = 63;
01924     } else { // no AC coeffs
01925         int k;
01926 
01927         memset(ac_val2, 0, 16 * 2);
01928         if(dc_pred_dir) {//left
01929             if(use_pred) {
01930                 memcpy(ac_val2, ac_val, 8 * 2);
01931                 if(q2 && q1!=q2) {
01932                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01933                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01934                     for(k = 1; k < 8; k++)
01935                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01936                 }
01937             }
01938         } else {//top
01939             if(use_pred) {
01940                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
01941                 if(q2 && q1!=q2) {
01942                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
01943                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
01944                     for(k = 1; k < 8; k++)
01945                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
01946                 }
01947             }
01948         }
01949 
01950         /* apply AC prediction if needed */
01951         if(use_pred) {
01952             if(dc_pred_dir) { //left
01953                 for(k = 1; k < 8; k++) {
01954                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
01955                     if(!v->pquantizer && block[k << v->left_blk_sh])
01956                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
01957                 }
01958             } else { //top
01959                 for(k = 1; k < 8; k++) {
01960                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
01961                     if(!v->pquantizer && block[k << v->top_blk_sh])
01962                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
01963                 }
01964             }
01965             i = 63;
01966         }
01967     }
01968     s->block_last_index[n] = i;
01969 
01970     return 0;
01971 }
01972 
01981 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
01982 {
01983     GetBitContext *gb = &v->s.gb;
01984     MpegEncContext *s = &v->s;
01985     int dc_pred_dir = 0; /* Direction of the DC prediction used */
01986     int i;
01987     int16_t *dc_val;
01988     int16_t *ac_val, *ac_val2;
01989     int dcdiff;
01990     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01991     int a_avail = v->a_avail, c_avail = v->c_avail;
01992     int use_pred = s->ac_pred;
01993     int scale;
01994     int q1, q2 = 0;
01995 
01996     s->dsp.clear_block(block);
01997 
01998     /* XXX: Guard against dumb values of mquant */
01999     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
02000 
02001     /* Set DC scale - y and c use the same */
02002     s->y_dc_scale = s->y_dc_scale_table[mquant];
02003     s->c_dc_scale = s->c_dc_scale_table[mquant];
02004 
02005     /* Get DC differential */
02006     if (n < 4) {
02007         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02008     } else {
02009         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
02010     }
02011     if (dcdiff < 0){
02012         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
02013         return -1;
02014     }
02015     if (dcdiff)
02016     {
02017         if (dcdiff == 119 /* ESC index value */)
02018         {
02019             /* TODO: Optimize */
02020             if (mquant == 1) dcdiff = get_bits(gb, 10);
02021             else if (mquant == 2) dcdiff = get_bits(gb, 9);
02022             else dcdiff = get_bits(gb, 8);
02023         }
02024         else
02025         {
02026             if (mquant == 1)
02027                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
02028             else if (mquant == 2)
02029                 dcdiff = (dcdiff<<1) + get_bits1(gb)   - 1;
02030         }
02031         if (get_bits1(gb))
02032             dcdiff = -dcdiff;
02033     }
02034 
02035     /* Prediction */
02036     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
02037     *dc_val = dcdiff;
02038 
02039     /* Store the quantized DC coeff, used for prediction */
02040 
02041     if (n < 4) {
02042         block[0] = dcdiff * s->y_dc_scale;
02043     } else {
02044         block[0] = dcdiff * s->c_dc_scale;
02045     }
02046 
02047     //AC Decoding
02048     i = 1;
02049 
02050     /* check if AC is needed at all and adjust direction if needed */
02051     if(!a_avail) dc_pred_dir = 1;
02052     if(!c_avail) dc_pred_dir = 0;
02053     if(!a_avail && !c_avail) use_pred = 0;
02054     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02055     ac_val2 = ac_val;
02056 
02057     scale = mquant * 2 + v->halfpq;
02058 
02059     if(dc_pred_dir) //left
02060         ac_val -= 16;
02061     else //top
02062         ac_val -= 16 * s->block_wrap[n];
02063 
02064     q1 = s->current_picture.qscale_table[mb_pos];
02065     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
02066     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
02067     if(dc_pred_dir && n==1) q2 = q1;
02068     if(!dc_pred_dir && n==2) q2 = q1;
02069     if(n==3) q2 = q1;
02070 
02071     if(coded) {
02072         int last = 0, skip, value;
02073         int k;
02074 
02075         while (!last) {
02076             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
02077             i += skip;
02078             if(i > 63)
02079                 break;
02080             block[v->zz_8x8[0][i++]] = value;
02081         }
02082 
02083         /* apply AC prediction if needed */
02084         if(use_pred) {
02085             /* scale predictors if needed*/
02086             if(q2 && q1!=q2) {
02087                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02088                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02089 
02090                 if(dc_pred_dir) { //left
02091                     for(k = 1; k < 8; k++)
02092                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02093                 } else { //top
02094                     for(k = 1; k < 8; k++)
02095                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02096                 }
02097             } else {
02098                 if(dc_pred_dir) { //left
02099                     for(k = 1; k < 8; k++)
02100                         block[k << v->left_blk_sh] += ac_val[k];
02101                 } else { //top
02102                     for(k = 1; k < 8; k++)
02103                         block[k << v->top_blk_sh] += ac_val[k + 8];
02104                 }
02105             }
02106         }
02107         /* save AC coeffs for further prediction */
02108         for(k = 1; k < 8; k++) {
02109             ac_val2[k    ] = block[k << v->left_blk_sh];
02110             ac_val2[k + 8] = block[k << v->top_blk_sh];
02111         }
02112 
02113         /* scale AC coeffs */
02114         for(k = 1; k < 64; k++)
02115             if(block[k]) {
02116                 block[k] *= scale;
02117                 if(!v->pquantizer)
02118                     block[k] += (block[k] < 0) ? -mquant : mquant;
02119             }
02120 
02121         if(use_pred) i = 63;
02122     } else { // no AC coeffs
02123         int k;
02124 
02125         memset(ac_val2, 0, 16 * 2);
02126         if(dc_pred_dir) {//left
02127             if(use_pred) {
02128                 memcpy(ac_val2, ac_val, 8 * 2);
02129                 if(q2 && q1!=q2) {
02130                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02131                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02132                     for(k = 1; k < 8; k++)
02133                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02134                 }
02135             }
02136         } else {//top
02137             if(use_pred) {
02138                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
02139                 if(q2 && q1!=q2) {
02140                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
02141                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
02142                     for(k = 1; k < 8; k++)
02143                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
02144                 }
02145             }
02146         }
02147 
02148         /* apply AC prediction if needed */
02149         if(use_pred) {
02150             if(dc_pred_dir) { //left
02151                 for(k = 1; k < 8; k++) {
02152                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
02153                     if(!v->pquantizer && block[k << v->left_blk_sh])
02154                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
02155                 }
02156             } else { //top
02157                 for(k = 1; k < 8; k++) {
02158                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
02159                     if(!v->pquantizer && block[k << v->top_blk_sh])
02160                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
02161                 }
02162             }
02163             i = 63;
02164         }
02165     }
02166     s->block_last_index[n] = i;
02167 
02168     return 0;
02169 }
02170 
02173 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
02174                               uint8_t *dst, int linesize, int skip_block, int *ttmb_out)
02175 {
02176     MpegEncContext *s = &v->s;
02177     GetBitContext *gb = &s->gb;
02178     int i, j;
02179     int subblkpat = 0;
02180     int scale, off, idx, last, skip, value;
02181     int ttblk = ttmb & 7;
02182     int pat = 0;
02183 
02184     s->dsp.clear_block(block);
02185 
02186     if(ttmb == -1) {
02187         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)];
02188     }
02189     if(ttblk == TT_4X4) {
02190         subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
02191     }
02192     if((ttblk != TT_8X8 && ttblk != TT_4X4)
02193         && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
02194             || (!v->res_rtm_flag && !first_block))) {
02195         subblkpat = decode012(gb);
02196         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
02197         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
02198         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
02199     }
02200     scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
02201 
02202     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
02203     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
02204         subblkpat = 2 - (ttblk == TT_8X4_TOP);
02205         ttblk = TT_8X4;
02206     }
02207     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
02208         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
02209         ttblk = TT_4X8;
02210     }
02211     switch(ttblk) {
02212     case TT_8X8:
02213         pat = 0xF;
02214         i = 0;
02215         last = 0;
02216         while (!last) {
02217             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02218             i += skip;
02219             if(i > 63)
02220                 break;
02221             idx = v->zz_8x8[0][i++];
02222             block[idx] = value * scale;
02223             if(!v->pquantizer)
02224                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
02225         }
02226         if(!skip_block){
02227             if(i==1)
02228                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
02229             else{
02230                 v->vc1dsp.vc1_inv_trans_8x8(block);
02231                 s->dsp.add_pixels_clamped(block, dst, linesize);
02232             }
02233         }
02234         break;
02235     case TT_4X4:
02236         pat = ~subblkpat & 0xF;
02237         for(j = 0; j < 4; j++) {
02238             last = subblkpat & (1 << (3 - j));
02239             i = 0;
02240             off = (j & 1) * 4 + (j & 2) * 16;
02241             while (!last) {
02242                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02243                 i += skip;
02244                 if(i > 15)
02245                     break;
02246                 idx = ff_vc1_simple_progressive_4x4_zz[i++];
02247                 block[idx + off] = value * scale;
02248                 if(!v->pquantizer)
02249                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
02250             }
02251             if(!(subblkpat & (1 << (3 - j))) && !skip_block){
02252                 if(i==1)
02253                     v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02254                 else
02255                     v->vc1dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
02256             }
02257         }
02258         break;
02259     case TT_8X4:
02260         pat = ~((subblkpat & 2)*6 + (subblkpat & 1)*3) & 0xF;
02261         for(j = 0; j < 2; j++) {
02262             last = subblkpat & (1 << (1 - j));
02263             i = 0;
02264             off = j * 32;
02265             while (!last) {
02266                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02267                 i += skip;
02268                 if(i > 31)
02269                     break;
02270                 idx = v->zz_8x4[i++]+off;
02271                 block[idx] = value * scale;
02272                 if(!v->pquantizer)
02273                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
02274             }
02275             if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02276                 if(i==1)
02277                     v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j*4*linesize, linesize, block + off);
02278                 else
02279                     v->vc1dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
02280             }
02281         }
02282         break;
02283     case TT_4X8:
02284         pat = ~(subblkpat*5) & 0xF;
02285         for(j = 0; j < 2; j++) {
02286             last = subblkpat & (1 << (1 - j));
02287             i = 0;
02288             off = j * 4;
02289             while (!last) {
02290                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
02291                 i += skip;
02292                 if(i > 31)
02293                     break;
02294                 idx = v->zz_4x8[i++]+off;
02295                 block[idx] = value * scale;
02296                 if(!v->pquantizer)
02297                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
02298             }
02299             if(!(subblkpat & (1 << (1 - j))) && !skip_block){
02300                 if(i==1)
02301                     v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j*4, linesize, block + off);
02302                 else
02303                     v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
02304             }
02305         }
02306         break;
02307     }
02308     if (ttmb_out)
02309         *ttmb_out |= ttblk << (n * 4);
02310     return pat;
02311 }
02312  // Macroblock group
02314 
02315 static const int size_table  [6] = { 0, 2, 3, 4,  5,  8 };
02316 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
02317 
02318 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
02319 {
02320     MpegEncContext *s = &v->s;
02321     int mb_cbp         = v->cbp[s->mb_x - s->mb_stride],
02322         block_cbp      = mb_cbp      >> (block_num * 4), bottom_cbp,
02323         mb_is_intra    = v->is_intra[s->mb_x - s->mb_stride],
02324         block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
02325     int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
02326     uint8_t *dst;
02327 
02328     if(block_num > 3) {
02329         dst      = s->dest[block_num - 3];
02330     } else {
02331         dst      = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
02332     }
02333     if (s->mb_y != s->end_mb_y || block_num < 2) {
02334         int16_t (*mv)[2];
02335         int mv_stride;
02336 
02337         if(block_num > 3) {
02338             bottom_cbp      = v->cbp[s->mb_x]      >> (block_num * 4);
02339             bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
02340             mv              = &v->luma_mv[s->mb_x - s->mb_stride];
02341             mv_stride       = s->mb_stride;
02342         } else {
02343             bottom_cbp      = (block_num < 2) ? (mb_cbp               >> ((block_num + 2) * 4)) :
02344                                                 (v->cbp[s->mb_x]      >> ((block_num - 2) * 4));
02345             bottom_is_intra = (block_num < 2) ? (mb_is_intra          >> ((block_num + 2) * 4)) :
02346                                                 (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
02347             mv_stride       = s->b8_stride;
02348             mv              = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
02349         }
02350 
02351         if (bottom_is_intra & 1 || block_is_intra & 1 ||
02352             mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
02353             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
02354         } else {
02355             idx = ((bottom_cbp >> 2) | block_cbp) & 3;
02356             if(idx == 3) {
02357                 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
02358             } else if (idx) {
02359                 if (idx == 1)
02360                     v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
02361                 else
02362                     v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
02363             }
02364         }
02365     }
02366 
02367     dst -= 4 * linesize;
02368     ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xf;
02369     if (ttblk == TT_4X4 || ttblk == TT_8X4) {
02370         idx = (block_cbp | (block_cbp >> 2)) & 3;
02371         if (idx == 3) {
02372             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
02373         } else if (idx) {
02374             if (idx == 1)
02375                 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
02376             else
02377                 v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
02378         }
02379     }
02380 }
02381 
02382 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
02383 {
02384     MpegEncContext *s = &v->s;
02385     int mb_cbp         = v->cbp[s->mb_x - 1 - s->mb_stride],
02386         block_cbp      = mb_cbp      >> (block_num * 4), right_cbp,
02387         mb_is_intra    = v->is_intra[s->mb_x - 1 - s->mb_stride],
02388         block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
02389     int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
02390     uint8_t *dst;
02391 
02392     if (block_num > 3) {
02393         dst = s->dest[block_num - 3] - 8 * linesize;
02394     } else {
02395         dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
02396     }
02397 
02398     if (s->mb_x != s->mb_width || !(block_num & 5)) {
02399         int16_t (*mv)[2];
02400 
02401         if(block_num > 3) {
02402             right_cbp      = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
02403             right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
02404             mv             = &v->luma_mv[s->mb_x - s->mb_stride - 1];
02405         }else{
02406             right_cbp      = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride]      >> ((block_num - 1) * 4)) :
02407                                                (mb_cbp                              >> ((block_num + 1) * 4));
02408             right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4)) :
02409                                                (mb_is_intra                         >> ((block_num + 1) * 4));
02410             mv             = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
02411         }
02412         if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
02413             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
02414         } else {
02415             idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
02416             if (idx == 5) {
02417                 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
02418             } else if (idx) {
02419                 if (idx == 1)
02420                     v->vc1dsp.vc1_h_loop_filter4(dst+4*linesize, linesize, v->pq);
02421                 else
02422                     v->vc1dsp.vc1_h_loop_filter4(dst,            linesize, v->pq);
02423             }
02424         }
02425     }
02426 
02427     dst -= 4;
02428     ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
02429     if (ttblk == TT_4X4 || ttblk == TT_4X8) {
02430         idx = (block_cbp | (block_cbp >> 1)) & 5;
02431         if (idx == 5) {
02432             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
02433         } else if (idx) {
02434             if (idx == 1)
02435                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize*4, linesize, v->pq);
02436             else
02437                 v->vc1dsp.vc1_h_loop_filter4(dst,              linesize, v->pq);
02438         }
02439     }
02440 }
02441 
02442 static void vc1_apply_p_loop_filter(VC1Context *v)
02443 {
02444     MpegEncContext *s = &v->s;
02445     int i;
02446 
02447     for (i = 0; i < 6; i++) {
02448         vc1_apply_p_v_loop_filter(v, i);
02449     }
02450 
02451     /* V always preceedes H, therefore we run H one MB before V;
02452      * at the end of a row, we catch up to complete the row */
02453     if (s->mb_x) {
02454         for (i = 0; i < 6; i++) {
02455             vc1_apply_p_h_loop_filter(v, i);
02456         }
02457         if (s->mb_x == s->mb_width - 1) {
02458             s->mb_x++;
02459             ff_update_block_index(s);
02460             for (i = 0; i < 6; i++) {
02461                 vc1_apply_p_h_loop_filter(v, i);
02462             }
02463         }
02464     }
02465 }
02466 
02469 static int vc1_decode_p_mb(VC1Context *v)
02470 {
02471     MpegEncContext *s = &v->s;
02472     GetBitContext *gb = &s->gb;
02473     int i, j;
02474     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02475     int cbp; /* cbp decoding stuff */
02476     int mqdiff, mquant; /* MB quantization */
02477     int ttmb = v->ttfrm; /* MB Transform type */
02478 
02479     int mb_has_coeffs = 1; /* last_flag */
02480     int dmv_x, dmv_y; /* Differential MV components */
02481     int index, index1; /* LUT indexes */
02482     int val, sign; /* temp values */
02483     int first_block = 1;
02484     int dst_idx, off;
02485     int skipped, fourmv;
02486     int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
02487 
02488     mquant = v->pq; /* Loosy initialization */
02489 
02490     if (v->mv_type_is_raw)
02491         fourmv = get_bits1(gb);
02492     else
02493         fourmv = v->mv_type_mb_plane[mb_pos];
02494     if (v->skip_is_raw)
02495         skipped = get_bits1(gb);
02496     else
02497         skipped = v->s.mbskip_table[mb_pos];
02498 
02499     if (!fourmv) /* 1MV mode */
02500     {
02501         if (!skipped)
02502         {
02503             GET_MVDATA(dmv_x, dmv_y);
02504 
02505             if (s->mb_intra) {
02506                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02507                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02508             }
02509             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
02510             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
02511 
02512             /* FIXME Set DC val for inter block ? */
02513             if (s->mb_intra && !mb_has_coeffs)
02514             {
02515                 GET_MQUANT();
02516                 s->ac_pred = get_bits1(gb);
02517                 cbp = 0;
02518             }
02519             else if (mb_has_coeffs)
02520             {
02521                 if (s->mb_intra) s->ac_pred = get_bits1(gb);
02522                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02523                 GET_MQUANT();
02524             }
02525             else
02526             {
02527                 mquant = v->pq;
02528                 cbp = 0;
02529             }
02530             s->current_picture.qscale_table[mb_pos] = mquant;
02531 
02532             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02533                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
02534                                 VC1_TTMB_VLC_BITS, 2);
02535             if(!s->mb_intra) vc1_mc_1mv(v, 0);
02536             dst_idx = 0;
02537             for (i=0; i<6; i++)
02538             {
02539                 s->dc_val[0][s->block_index[i]] = 0;
02540                 dst_idx += i >> 2;
02541                 val = ((cbp >> (5 - i)) & 1);
02542                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02543                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
02544                 if(s->mb_intra) {
02545                     /* check if prediction blocks A and C are available */
02546                     v->a_avail = v->c_avail = 0;
02547                     if(i == 2 || i == 3 || !s->first_slice_line)
02548                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02549                     if(i == 1 || i == 3 || s->mb_x)
02550                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02551 
02552                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02553                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02554                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
02555                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02556                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02557                     if(v->pq >= 9 && v->overlap) {
02558                         if(v->c_avail)
02559                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02560                         if(v->a_avail)
02561                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02562                     }
02563                     block_cbp |= 0xF << (i << 2);
02564                     block_intra |= 1 << i;
02565                 } else if(val) {
02566                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
02567                     block_cbp |= pat << (i << 2);
02568                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
02569                     first_block = 0;
02570                 }
02571             }
02572         }
02573         else //Skipped
02574         {
02575             s->mb_intra = 0;
02576             for(i = 0; i < 6; i++) {
02577                 v->mb_type[0][s->block_index[i]] = 0;
02578                 s->dc_val[0][s->block_index[i]] = 0;
02579             }
02580             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
02581             s->current_picture.qscale_table[mb_pos] = 0;
02582             vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
02583             vc1_mc_1mv(v, 0);
02584         }
02585     } //1MV mode
02586     else //4MV mode
02587     {
02588         if (!skipped /* unskipped MB */)
02589         {
02590             int intra_count = 0, coded_inter = 0;
02591             int is_intra[6], is_coded[6];
02592             /* Get CBPCY */
02593             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02594             for (i=0; i<6; i++)
02595             {
02596                 val = ((cbp >> (5 - i)) & 1);
02597                 s->dc_val[0][s->block_index[i]] = 0;
02598                 s->mb_intra = 0;
02599                 if(i < 4) {
02600                     dmv_x = dmv_y = 0;
02601                     s->mb_intra = 0;
02602                     mb_has_coeffs = 0;
02603                     if(val) {
02604                         GET_MVDATA(dmv_x, dmv_y);
02605                     }
02606                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
02607                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
02608                     intra_count += s->mb_intra;
02609                     is_intra[i] = s->mb_intra;
02610                     is_coded[i] = mb_has_coeffs;
02611                 }
02612                 if(i&4){
02613                     is_intra[i] = (intra_count >= 3);
02614                     is_coded[i] = val;
02615                 }
02616                 if(i == 4) vc1_mc_4mv_chroma(v);
02617                 v->mb_type[0][s->block_index[i]] = is_intra[i];
02618                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
02619             }
02620             // if there are no coded blocks then don't do anything more
02621             dst_idx = 0;
02622             if(!intra_count && !coded_inter)
02623                 goto end;
02624             GET_MQUANT();
02625             s->current_picture.qscale_table[mb_pos] = mquant;
02626             /* test if block is intra and has pred */
02627             {
02628                 int intrapred = 0;
02629                 for(i=0; i<6; i++)
02630                     if(is_intra[i]) {
02631                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
02632                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
02633                             intrapred = 1;
02634                             break;
02635                         }
02636                     }
02637                 if(intrapred)s->ac_pred = get_bits1(gb);
02638                 else s->ac_pred = 0;
02639             }
02640             if (!v->ttmbf && coded_inter)
02641                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02642             for (i=0; i<6; i++)
02643             {
02644                 dst_idx += i >> 2;
02645                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02646                 s->mb_intra = is_intra[i];
02647                 if (is_intra[i]) {
02648                     /* check if prediction blocks A and C are available */
02649                     v->a_avail = v->c_avail = 0;
02650                     if(i == 2 || i == 3 || !s->first_slice_line)
02651                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02652                     if(i == 1 || i == 3 || s->mb_x)
02653                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02654 
02655                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
02656                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02657                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
02658                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02659                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
02660                     if(v->pq >= 9 && v->overlap) {
02661                         if(v->c_avail)
02662                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02663                         if(v->a_avail)
02664                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02665                     }
02666                     block_cbp |= 0xF << (i << 2);
02667                     block_intra |= 1 << i;
02668                 } else if(is_coded[i]) {
02669                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
02670                     block_cbp |= pat << (i << 2);
02671                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
02672                     first_block = 0;
02673                 }
02674             }
02675         }
02676         else //Skipped MB
02677         {
02678             s->mb_intra = 0;
02679             s->current_picture.qscale_table[mb_pos] = 0;
02680             for (i=0; i<6; i++) {
02681                 v->mb_type[0][s->block_index[i]] = 0;
02682                 s->dc_val[0][s->block_index[i]] = 0;
02683             }
02684             for (i=0; i<4; i++)
02685             {
02686                 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
02687                 vc1_mc_4mv_luma(v, i);
02688             }
02689             vc1_mc_4mv_chroma(v);
02690             s->current_picture.qscale_table[mb_pos] = 0;
02691         }
02692     }
02693 end:
02694     v->cbp[s->mb_x] = block_cbp;
02695     v->ttblk[s->mb_x] = block_tt;
02696     v->is_intra[s->mb_x] = block_intra;
02697 
02698     return 0;
02699 }
02700 
02703 static void vc1_decode_b_mb(VC1Context *v)
02704 {
02705     MpegEncContext *s = &v->s;
02706     GetBitContext *gb = &s->gb;
02707     int i, j;
02708     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
02709     int cbp = 0; /* cbp decoding stuff */
02710     int mqdiff, mquant; /* MB quantization */
02711     int ttmb = v->ttfrm; /* MB Transform type */
02712     int mb_has_coeffs = 0; /* last_flag */
02713     int index, index1; /* LUT indexes */
02714     int val, sign; /* temp values */
02715     int first_block = 1;
02716     int dst_idx, off;
02717     int skipped, direct;
02718     int dmv_x[2], dmv_y[2];
02719     int bmvtype = BMV_TYPE_BACKWARD;
02720 
02721     mquant = v->pq; /* Loosy initialization */
02722     s->mb_intra = 0;
02723 
02724     if (v->dmb_is_raw)
02725         direct = get_bits1(gb);
02726     else
02727         direct = v->direct_mb_plane[mb_pos];
02728     if (v->skip_is_raw)
02729         skipped = get_bits1(gb);
02730     else
02731         skipped = v->s.mbskip_table[mb_pos];
02732 
02733     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
02734     for(i = 0; i < 6; i++) {
02735         v->mb_type[0][s->block_index[i]] = 0;
02736         s->dc_val[0][s->block_index[i]] = 0;
02737     }
02738     s->current_picture.qscale_table[mb_pos] = 0;
02739 
02740     if (!direct) {
02741         if (!skipped) {
02742             GET_MVDATA(dmv_x[0], dmv_y[0]);
02743             dmv_x[1] = dmv_x[0];
02744             dmv_y[1] = dmv_y[0];
02745         }
02746         if(skipped || !s->mb_intra) {
02747             bmvtype = decode012(gb);
02748             switch(bmvtype) {
02749             case 0:
02750                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
02751                 break;
02752             case 1:
02753                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
02754                 break;
02755             case 2:
02756                 bmvtype = BMV_TYPE_INTERPOLATED;
02757                 dmv_x[0] = dmv_y[0] = 0;
02758             }
02759         }
02760     }
02761     for(i = 0; i < 6; i++)
02762         v->mb_type[0][s->block_index[i]] = s->mb_intra;
02763 
02764     if (skipped) {
02765         if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
02766         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02767         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02768         return;
02769     }
02770     if (direct) {
02771         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02772         GET_MQUANT();
02773         s->mb_intra = 0;
02774         s->current_picture.qscale_table[mb_pos] = mquant;
02775         if(!v->ttmbf)
02776             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02777         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
02778         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02779         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02780     } else {
02781         if(!mb_has_coeffs && !s->mb_intra) {
02782             /* no coded blocks - effectively skipped */
02783             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02784             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02785             return;
02786         }
02787         if(s->mb_intra && !mb_has_coeffs) {
02788             GET_MQUANT();
02789             s->current_picture.qscale_table[mb_pos] = mquant;
02790             s->ac_pred = get_bits1(gb);
02791             cbp = 0;
02792             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02793         } else {
02794             if(bmvtype == BMV_TYPE_INTERPOLATED) {
02795                 GET_MVDATA(dmv_x[0], dmv_y[0]);
02796                 if(!mb_has_coeffs) {
02797                     /* interpolated skipped block */
02798                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02799                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02800                     return;
02801                 }
02802             }
02803             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
02804             if(!s->mb_intra) {
02805                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
02806             }
02807             if(s->mb_intra)
02808                 s->ac_pred = get_bits1(gb);
02809             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
02810             GET_MQUANT();
02811             s->current_picture.qscale_table[mb_pos] = mquant;
02812             if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
02813                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
02814         }
02815     }
02816     dst_idx = 0;
02817     for (i=0; i<6; i++)
02818     {
02819         s->dc_val[0][s->block_index[i]] = 0;
02820         dst_idx += i >> 2;
02821         val = ((cbp >> (5 - i)) & 1);
02822         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
02823         v->mb_type[0][s->block_index[i]] = s->mb_intra;
02824         if(s->mb_intra) {
02825             /* check if prediction blocks A and C are available */
02826             v->a_avail = v->c_avail = 0;
02827             if(i == 2 || i == 3 || !s->first_slice_line)
02828                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
02829             if(i == 1 || i == 3 || s->mb_x)
02830                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
02831 
02832             vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
02833             if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
02834             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
02835             if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
02836             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
02837         } else if(val) {
02838             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), NULL);
02839             if(!v->ttmbf && ttmb < 8) ttmb = -1;
02840             first_block = 0;
02841         }
02842     }
02843 }
02844 
02847 static void vc1_decode_i_blocks(VC1Context *v)
02848 {
02849     int k, j;
02850     MpegEncContext *s = &v->s;
02851     int cbp, val;
02852     uint8_t *coded_val;
02853     int mb_pos;
02854 
02855     /* select codingmode used for VLC tables selection */
02856     switch(v->y_ac_table_index){
02857     case 0:
02858         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02859         break;
02860     case 1:
02861         v->codingset = CS_HIGH_MOT_INTRA;
02862         break;
02863     case 2:
02864         v->codingset = CS_MID_RATE_INTRA;
02865         break;
02866     }
02867 
02868     switch(v->c_ac_table_index){
02869     case 0:
02870         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
02871         break;
02872     case 1:
02873         v->codingset2 = CS_HIGH_MOT_INTER;
02874         break;
02875     case 2:
02876         v->codingset2 = CS_MID_RATE_INTER;
02877         break;
02878     }
02879 
02880     /* Set DC scale - y and c use the same */
02881     s->y_dc_scale = s->y_dc_scale_table[v->pq];
02882     s->c_dc_scale = s->c_dc_scale_table[v->pq];
02883 
02884     //do frame decode
02885     s->mb_x = s->mb_y = 0;
02886     s->mb_intra = 1;
02887     s->first_slice_line = 1;
02888     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
02889         s->mb_x = 0;
02890         ff_init_block_index(s);
02891         for(; s->mb_x < s->mb_width; s->mb_x++) {
02892             uint8_t *dst[6];
02893             ff_update_block_index(s);
02894             dst[0] = s->dest[0];
02895             dst[1] = dst[0] + 8;
02896             dst[2] = s->dest[0] + s->linesize * 8;
02897             dst[3] = dst[2] + 8;
02898             dst[4] = s->dest[1];
02899             dst[5] = s->dest[2];
02900             s->dsp.clear_blocks(s->block[0]);
02901             mb_pos = s->mb_x + s->mb_y * s->mb_width;
02902             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
02903             s->current_picture.qscale_table[mb_pos] = v->pq;
02904             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
02905             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
02906 
02907             // do actual MB decoding and displaying
02908             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
02909             v->s.ac_pred = get_bits1(&v->s.gb);
02910 
02911             for(k = 0; k < 6; k++) {
02912                 val = ((cbp >> (5 - k)) & 1);
02913 
02914                 if (k < 4) {
02915                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
02916                     val = val ^ pred;
02917                     *coded_val = val;
02918                 }
02919                 cbp |= val << (5 - k);
02920 
02921                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
02922 
02923                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
02924                 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
02925                 if(v->pq >= 9 && v->overlap) {
02926                     if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] <<= 1;
02927                     s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
02928                 } else {
02929                     if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] = (s->block[k][j] - 64) << 1;
02930                     s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
02931                 }
02932             }
02933 
02934             if(v->pq >= 9 && v->overlap) {
02935                 if(s->mb_x) {
02936                     v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
02937                     v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02938                     if(!(s->flags & CODEC_FLAG_GRAY)) {
02939                         v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
02940                         v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
02941                     }
02942                 }
02943                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
02944                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02945                 if(!s->first_slice_line) {
02946                     v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
02947                     v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
02948                     if(!(s->flags & CODEC_FLAG_GRAY)) {
02949                         v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
02950                         v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
02951                     }
02952                 }
02953                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
02954                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
02955             }
02956             if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
02957 
02958             if(get_bits_count(&s->gb) > v->bits) {
02959                 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
02960                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
02961                 return;
02962             }
02963         }
02964         if (!v->s.loop_filter)
02965             ff_draw_horiz_band(s, s->mb_y * 16, 16);
02966         else if (s->mb_y)
02967             ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
02968 
02969         s->first_slice_line = 0;
02970     }
02971     if (v->s.loop_filter)
02972         ff_draw_horiz_band(s, (s->mb_height-1)*16, 16);
02973     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
02974 }
02975 
02978 static void vc1_decode_i_blocks_adv(VC1Context *v)
02979 {
02980     int k;
02981     MpegEncContext *s = &v->s;
02982     int cbp, val;
02983     uint8_t *coded_val;
02984     int mb_pos;
02985     int mquant = v->pq;
02986     int mqdiff;
02987     GetBitContext *gb = &s->gb;
02988 
02989     /* select codingmode used for VLC tables selection */
02990     switch(v->y_ac_table_index){
02991     case 0:
02992         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
02993         break;
02994     case 1:
02995         v->codingset = CS_HIGH_MOT_INTRA;
02996         break;
02997     case 2:
02998         v->codingset = CS_MID_RATE_INTRA;
02999         break;
03000     }
03001 
03002     switch(v->c_ac_table_index){
03003     case 0:
03004         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03005         break;
03006     case 1:
03007         v->codingset2 = CS_HIGH_MOT_INTER;
03008         break;
03009     case 2:
03010         v->codingset2 = CS_MID_RATE_INTER;
03011         break;
03012     }
03013 
03014     //do frame decode
03015     s->mb_x = s->mb_y = 0;
03016     s->mb_intra = 1;
03017     s->first_slice_line = 1;
03018     s->mb_y = s->start_mb_y;
03019     if (s->start_mb_y) {
03020         s->mb_x = 0;
03021         ff_init_block_index(s);
03022         memset(&s->coded_block[s->block_index[0]-s->b8_stride], 0,
03023                (1 + s->b8_stride) * sizeof(*s->coded_block));
03024     }
03025     for(; s->mb_y < s->end_mb_y; s->mb_y++) {
03026         s->mb_x = 0;
03027         ff_init_block_index(s);
03028         for(;s->mb_x < s->mb_width; s->mb_x++) {
03029             DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
03030             ff_update_block_index(s);
03031             s->dsp.clear_blocks(block[0]);
03032             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
03033             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
03034             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
03035             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
03036 
03037             // do actual MB decoding and displaying
03038             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
03039             if(v->acpred_is_raw)
03040                 v->s.ac_pred = get_bits1(&v->s.gb);
03041             else
03042                 v->s.ac_pred = v->acpred_plane[mb_pos];
03043 
03044             if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
03045                 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
03046 
03047             GET_MQUANT();
03048 
03049             s->current_picture.qscale_table[mb_pos] = mquant;
03050             /* Set DC scale - y and c use the same */
03051             s->y_dc_scale = s->y_dc_scale_table[mquant];
03052             s->c_dc_scale = s->c_dc_scale_table[mquant];
03053 
03054             for(k = 0; k < 6; k++) {
03055                 val = ((cbp >> (5 - k)) & 1);
03056 
03057                 if (k < 4) {
03058                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
03059                     val = val ^ pred;
03060                     *coded_val = val;
03061                 }
03062                 cbp |= val << (5 - k);
03063 
03064                 v->a_avail = !s->first_slice_line || (k==2 || k==3);
03065                 v->c_avail = !!s->mb_x || (k==1 || k==3);
03066 
03067                 vc1_decode_i_block_adv(v, block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
03068 
03069                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
03070                 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
03071             }
03072 
03073             vc1_smooth_overlap_filter_iblk(v);
03074             vc1_put_signed_blocks_clamped(v);
03075             if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
03076 
03077             if(get_bits_count(&s->gb) > v->bits) {
03078                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03079                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
03080                 return;
03081             }
03082         }
03083         if (!v->s.loop_filter)
03084             ff_draw_horiz_band(s, s->mb_y * 16, 16);
03085         else if (s->mb_y)
03086             ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
03087         s->first_slice_line = 0;
03088     }
03089 
03090     /* raw bottom MB row */
03091     s->mb_x = 0;
03092     ff_init_block_index(s);
03093     for(;s->mb_x < s->mb_width; s->mb_x++) {
03094         ff_update_block_index(s);
03095         vc1_put_signed_blocks_clamped(v);
03096         if(v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
03097     }
03098     if (v->s.loop_filter)
03099         ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
03100     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
03101 }
03102 
03103 static void vc1_decode_p_blocks(VC1Context *v)
03104 {
03105     MpegEncContext *s = &v->s;
03106     int apply_loop_filter;
03107 
03108     /* select codingmode used for VLC tables selection */
03109     switch(v->c_ac_table_index){
03110     case 0:
03111         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03112         break;
03113     case 1:
03114         v->codingset = CS_HIGH_MOT_INTRA;
03115         break;
03116     case 2:
03117         v->codingset = CS_MID_RATE_INTRA;
03118         break;
03119     }
03120 
03121     switch(v->c_ac_table_index){
03122     case 0:
03123         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03124         break;
03125     case 1:
03126         v->codingset2 = CS_HIGH_MOT_INTER;
03127         break;
03128     case 2:
03129         v->codingset2 = CS_MID_RATE_INTER;
03130         break;
03131     }
03132 
03133     apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
03134     s->first_slice_line = 1;
03135     memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
03136     for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
03137         s->mb_x = 0;
03138         ff_init_block_index(s);
03139         for(; s->mb_x < s->mb_width; s->mb_x++) {
03140             ff_update_block_index(s);
03141 
03142             vc1_decode_p_mb(v);
03143             if (s->mb_y != s->start_mb_y && apply_loop_filter)
03144                 vc1_apply_p_loop_filter(v);
03145             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
03146                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03147                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
03148                 return;
03149             }
03150         }
03151         memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0])*s->mb_stride);
03152         memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0])*s->mb_stride);
03153         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
03154         memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0])*s->mb_stride);
03155         if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
03156         s->first_slice_line = 0;
03157     }
03158     if (apply_loop_filter) {
03159         s->mb_x = 0;
03160         ff_init_block_index(s);
03161         for (; s->mb_x < s->mb_width; s->mb_x++) {
03162             ff_update_block_index(s);
03163             vc1_apply_p_loop_filter(v);
03164         }
03165     }
03166     if (s->end_mb_y >= s->start_mb_y)
03167         ff_draw_horiz_band(s, (s->end_mb_y-1) * 16, 16);
03168     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
03169 }
03170 
03171 static void vc1_decode_b_blocks(VC1Context *v)
03172 {
03173     MpegEncContext *s = &v->s;
03174 
03175     /* select codingmode used for VLC tables selection */
03176     switch(v->c_ac_table_index){
03177     case 0:
03178         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
03179         break;
03180     case 1:
03181         v->codingset = CS_HIGH_MOT_INTRA;
03182         break;
03183     case 2:
03184         v->codingset = CS_MID_RATE_INTRA;
03185         break;
03186     }
03187 
03188     switch(v->c_ac_table_index){
03189     case 0:
03190         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
03191         break;
03192     case 1:
03193         v->codingset2 = CS_HIGH_MOT_INTER;
03194         break;
03195     case 2:
03196         v->codingset2 = CS_MID_RATE_INTER;
03197         break;
03198     }
03199 
03200     s->first_slice_line = 1;
03201     for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
03202         s->mb_x = 0;
03203         ff_init_block_index(s);
03204         for(; s->mb_x < s->mb_width; s->mb_x++) {
03205             ff_update_block_index(s);
03206 
03207             vc1_decode_b_mb(v);
03208             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
03209                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
03210                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
03211                 return;
03212             }
03213             if(v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
03214         }
03215         if (!v->s.loop_filter)
03216             ff_draw_horiz_band(s, s->mb_y * 16, 16);
03217         else if (s->mb_y)
03218             ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
03219         s->first_slice_line = 0;
03220     }
03221     if (v->s.loop_filter)
03222         ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
03223     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
03224 }
03225 
03226 static void vc1_decode_skip_blocks(VC1Context *v)
03227 {
03228     MpegEncContext *s = &v->s;
03229 
03230     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, (AC_END|DC_END|MV_END));
03231     s->first_slice_line = 1;
03232     for(s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
03233         s->mb_x = 0;
03234         ff_init_block_index(s);
03235         ff_update_block_index(s);
03236         memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
03237         memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
03238         memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
03239         ff_draw_horiz_band(s, s->mb_y * 16, 16);
03240         s->first_slice_line = 0;
03241     }
03242     s->pict_type = AV_PICTURE_TYPE_P;
03243 }
03244 
03245 static void vc1_decode_blocks(VC1Context *v)
03246 {
03247 
03248     v->s.esc3_level_length = 0;
03249     if(v->x8_type){
03250         ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
03251     }else{
03252         v->cur_blk_idx = 0;
03253         v->left_blk_idx = -1;
03254         v->topleft_blk_idx = 1;
03255         v->top_blk_idx = 2;
03256         switch(v->s.pict_type) {
03257         case AV_PICTURE_TYPE_I:
03258             if(v->profile == PROFILE_ADVANCED)
03259                 vc1_decode_i_blocks_adv(v);
03260             else
03261                 vc1_decode_i_blocks(v);
03262             break;
03263         case AV_PICTURE_TYPE_P:
03264             if(v->p_frame_skipped)
03265                 vc1_decode_skip_blocks(v);
03266             else
03267                 vc1_decode_p_blocks(v);
03268             break;
03269         case AV_PICTURE_TYPE_B:
03270             if(v->bi_type){
03271                 if(v->profile == PROFILE_ADVANCED)
03272                     vc1_decode_i_blocks_adv(v);
03273                 else
03274                     vc1_decode_i_blocks(v);
03275             }else
03276                 vc1_decode_b_blocks(v);
03277             break;
03278         }
03279     }
03280 }
03281 
03282 static inline float get_float_val(GetBitContext* gb)
03283 {
03284     return (float)get_bits_long(gb, 30) / (1<<15) - (1<<14);
03285 }
03286 
03287 static void vc1_sprite_parse_transform(VC1Context *v, GetBitContext* gb, float c[7])
03288 {
03289     c[1] = c[3] = 0.0f;
03290 
03291     switch (get_bits(gb, 2)) {
03292     case 0:
03293         c[0] = 1.0f;
03294         c[2] = get_float_val(gb);
03295         c[4] = 1.0f;
03296         break;
03297     case 1:
03298         c[0] = c[4] = get_float_val(gb);
03299         c[2] = get_float_val(gb);
03300         break;
03301     case 2:
03302         c[0] = get_float_val(gb);
03303         c[2] = get_float_val(gb);
03304         c[4] = get_float_val(gb);
03305         break;
03306     case 3:
03307         av_log_ask_for_sample(v->s.avctx, NULL);
03308         c[0] = get_float_val(gb);
03309         c[1] = get_float_val(gb);
03310         c[2] = get_float_val(gb);
03311         c[3] = get_float_val(gb);
03312         c[4] = get_float_val(gb);
03313         break;
03314     }
03315     c[5] = get_float_val(gb);
03316     if (get_bits1(gb))
03317         c[6] = get_float_val(gb);
03318     else
03319         c[6] = 1.0f;
03320 }
03321 
03322 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb)
03323 {
03324     int effect_type, effect_flag, effect_pcount1, effect_pcount2, i;
03325     float effect_params1[14], effect_params2[10];
03326 
03327     float coefs[2][7];
03328     vc1_sprite_parse_transform(v, gb, coefs[0]);
03329     av_log(v->s.avctx, AV_LOG_DEBUG, "S1:");
03330     for (i = 0; i < 7; i++)
03331         av_log(v->s.avctx, AV_LOG_DEBUG, " %.3f", coefs[0][i]);
03332     av_log(v->s.avctx, AV_LOG_DEBUG, "\n");
03333 
03334     if (v->two_sprites) {
03335         vc1_sprite_parse_transform(v, gb, coefs[1]);
03336         av_log(v->s.avctx, AV_LOG_DEBUG, "S2:");
03337         for (i = 0; i < 7; i++)
03338             av_log(v->s.avctx, AV_LOG_DEBUG, " %.3f", coefs[1][i]);
03339         av_log(v->s.avctx, AV_LOG_DEBUG, "\n");
03340     }
03341     skip_bits(gb, 2);
03342     if (effect_type = get_bits_long(gb, 30)){
03343         switch (effect_pcount1 = get_bits(gb, 4)) {
03344         case 2:
03345             effect_params1[0] = get_float_val(gb);
03346             effect_params1[1] = get_float_val(gb);
03347             break;
03348         case 7:
03349             vc1_sprite_parse_transform(v, gb, effect_params1);
03350             break;
03351         case 14:
03352             vc1_sprite_parse_transform(v, gb, effect_params1);
03353             vc1_sprite_parse_transform(v, gb, &effect_params1[7]);
03354             break;
03355         default:
03356             av_log_ask_for_sample(v->s.avctx, NULL);
03357             return;
03358         }
03359         if (effect_type != 13 || effect_params1[0] != coefs[0][6]) {
03360             // effect 13 is simple alpha blending and matches the opacity above
03361             av_log(v->s.avctx, AV_LOG_DEBUG, "Effect: %d; params: ", effect_type);
03362             for (i = 0; i < effect_pcount1; i++)
03363                 av_log(v->s.avctx, AV_LOG_DEBUG, " %.3f", effect_params1[i]);
03364             av_log(v->s.avctx, AV_LOG_DEBUG, "\n");
03365         }
03366 
03367         effect_pcount2 = get_bits(gb, 16);
03368         if (effect_pcount2 > 10) {
03369             av_log(v->s.avctx, AV_LOG_ERROR, "Too many effect parameters\n");
03370             return;
03371         } else if (effect_pcount2) {
03372             i = 0;
03373             av_log(v->s.avctx, AV_LOG_DEBUG, "Effect params 2: ");
03374             while (i < effect_pcount2){
03375                 effect_params2[i] = get_float_val(gb);
03376                 av_log(v->s.avctx, AV_LOG_DEBUG, " %.3f", effect_params2[i]);
03377                 i++;
03378             }
03379             av_log(v->s.avctx, AV_LOG_DEBUG, "\n");
03380         }
03381     }
03382     if (effect_flag = get_bits1(gb))
03383         av_log(v->s.avctx, AV_LOG_DEBUG, "Effect flag set\n");
03384 
03385     if (get_bits_count(gb) >= gb->size_in_bits +
03386        (v->s.avctx->codec_id == CODEC_ID_WMV3 ? 64 : 0))
03387         av_log(v->s.avctx, AV_LOG_ERROR, "Buffer overrun\n");
03388     if (get_bits_count(gb) < gb->size_in_bits - 8)
03389         av_log(v->s.avctx, AV_LOG_WARNING, "Buffer not fully read\n");
03390 }
03391 
03396 static av_cold int vc1_decode_init(AVCodecContext *avctx)
03397 {
03398     VC1Context *v = avctx->priv_data;
03399     MpegEncContext *s = &v->s;
03400     GetBitContext gb;
03401     int i, cur_width, cur_height;
03402 
03403     if (!avctx->extradata_size || !avctx->extradata) return -1;
03404     if (!(avctx->flags & CODEC_FLAG_GRAY))
03405         avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
03406     else
03407         avctx->pix_fmt = PIX_FMT_GRAY8;
03408     avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
03409     v->s.avctx = avctx;
03410     avctx->flags |= CODEC_FLAG_EMU_EDGE;
03411     v->s.flags |= CODEC_FLAG_EMU_EDGE;
03412 
03413     if(avctx->idct_algo==FF_IDCT_AUTO){
03414         avctx->idct_algo=FF_IDCT_WMV2;
03415     }
03416 
03417     if(ff_msmpeg4_decode_init(avctx) < 0)
03418         return -1;
03419     if (vc1_init_common(v) < 0) return -1;
03420     ff_vc1dsp_init(&v->vc1dsp);
03421 
03422     cur_width = avctx->coded_width = avctx->width;
03423     cur_height = avctx->coded_height = avctx->height;
03424     if (avctx->codec_id == CODEC_ID_WMV3)
03425     {
03426         int count = 0;
03427 
03428         // looks like WMV3 has a sequence header stored in the extradata
03429         // advanced sequence header may be before the first frame
03430         // the last byte of the extradata is a version number, 1 for the
03431         // samples we can decode
03432 
03433         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
03434 
03435         if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
03436           return -1;
03437 
03438         count = avctx->extradata_size*8 - get_bits_count(&gb);
03439         if (count>0)
03440         {
03441             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
03442                    count, get_bits(&gb, count));
03443         }
03444         else if (count < 0)
03445         {
03446             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
03447         }
03448     } else { // VC1/WVC1/WVP2
03449         const uint8_t *start = avctx->extradata;
03450         uint8_t *end = avctx->extradata + avctx->extradata_size;
03451         const uint8_t *next;
03452         int size, buf2_size;
03453         uint8_t *buf2 = NULL;
03454         int seq_initialized = 0, ep_initialized = 0;
03455 
03456         if(avctx->extradata_size < 16) {
03457             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
03458             return -1;
03459         }
03460 
03461         buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
03462         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
03463         next = start;
03464         for(; next < end; start = next){
03465             next = find_next_marker(start + 4, end);
03466             size = next - start - 4;
03467             if(size <= 0) continue;
03468             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
03469             init_get_bits(&gb, buf2, buf2_size * 8);
03470             switch(AV_RB32(start)){
03471             case VC1_CODE_SEQHDR:
03472                 if(vc1_decode_sequence_header(avctx, v, &gb) < 0){
03473                     av_free(buf2);
03474                     return -1;
03475                 }
03476                 seq_initialized = 1;
03477                 break;
03478             case VC1_CODE_ENTRYPOINT:
03479                 if(vc1_decode_entry_point(avctx, v, &gb) < 0){
03480                     av_free(buf2);
03481                     return -1;
03482                 }
03483                 ep_initialized = 1;
03484                 break;
03485             }
03486         }
03487         av_free(buf2);
03488         if(!seq_initialized || !ep_initialized){
03489             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
03490             return -1;
03491         }
03492         v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
03493     }
03494     // Sequence header information may not have been parsed
03495     // yet when ff_msmpeg4_decode_init was called the fist time
03496     // above.  If sequence information changes, we need to call
03497     // it again.
03498     if (cur_width != avctx->width ||
03499         cur_height != avctx->height) {
03500         MPV_common_end(s);
03501         if(ff_msmpeg4_decode_init(avctx) < 0)
03502             return -1;
03503         avctx->coded_width = avctx->width;
03504         avctx->coded_height = avctx->height;
03505     }
03506 
03507     avctx->profile = v->profile;
03508     if (v->profile == PROFILE_ADVANCED)
03509         avctx->level = v->level;
03510 
03511     avctx->has_b_frames= !!(avctx->max_b_frames);
03512     s->low_delay = !avctx->has_b_frames;
03513 
03514     s->mb_width = (avctx->coded_width+15)>>4;
03515     s->mb_height = (avctx->coded_height+15)>>4;
03516 
03517     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
03518         for (i = 0; i < 64;  i++) {
03519 #define transpose(x) ((x>>3) | ((x&7)<<3))
03520             v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
03521             v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
03522             v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
03523             v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
03524         }
03525         v->left_blk_sh = 0;
03526         v->top_blk_sh  = 3;
03527     } else {
03528         memcpy(v->zz_8x8, wmv1_scantable, 4*64);
03529         v->left_blk_sh = 3;
03530         v->top_blk_sh  = 0;
03531     }
03532 
03533     /* Allocate mb bitplanes */
03534     v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03535     v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
03536     v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
03537     v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
03538 
03539     v->n_allocated_blks = s->mb_width + 2;
03540     v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
03541     v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
03542     v->cbp = v->cbp_base + s->mb_stride;
03543     v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
03544     v->ttblk = v->ttblk_base + s->mb_stride;
03545     v->is_intra_base = av_malloc(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
03546     v->is_intra = v->is_intra_base + s->mb_stride;
03547     v->luma_mv_base = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
03548     v->luma_mv = v->luma_mv_base + s->mb_stride;
03549 
03550     /* allocate block type info in that way so it could be used with s->block_index[] */
03551     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
03552     v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
03553     v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
03554     v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
03555 
03556     /* Init coded blocks info */
03557     if (v->profile == PROFILE_ADVANCED)
03558     {
03559 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
03560 //            return -1;
03561 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
03562 //            return -1;
03563     }
03564 
03565     ff_intrax8_common_init(&v->x8,s);
03566     return 0;
03567 }
03568 
03569 
03573 static int vc1_decode_frame(AVCodecContext *avctx,
03574                             void *data, int *data_size,
03575                             AVPacket *avpkt)
03576 {
03577     const uint8_t *buf = avpkt->data;
03578     int buf_size = avpkt->size, n_slices = 0, i;
03579     VC1Context *v = avctx->priv_data;
03580     MpegEncContext *s = &v->s;
03581     AVFrame *pict = data;
03582     uint8_t *buf2 = NULL;
03583     const uint8_t *buf_start = buf;
03584     struct {
03585         uint8_t *buf;
03586         GetBitContext gb;
03587         int mby_start;
03588     } *slices = NULL;
03589 
03590     /* no supplementary picture */
03591     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
03592         /* special case for last picture */
03593         if (s->low_delay==0 && s->next_picture_ptr) {
03594             *pict= *(AVFrame*)s->next_picture_ptr;
03595             s->next_picture_ptr= NULL;
03596 
03597             *data_size = sizeof(AVFrame);
03598         }
03599 
03600         return 0;
03601     }
03602 
03603     /* We need to set current_picture_ptr before reading the header,
03604      * otherwise we cannot store anything in there. */
03605     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
03606         int i= ff_find_unused_picture(s, 0);
03607         s->current_picture_ptr= &s->picture[i];
03608     }
03609 
03610     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
03611         if (v->profile < PROFILE_ADVANCED)
03612             avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
03613         else
03614             avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
03615     }
03616 
03617     //for advanced profile we may need to parse and unescape data
03618     if (avctx->codec_id == CODEC_ID_VC1) {
03619         int buf_size2 = 0;
03620         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
03621 
03622         if(IS_MARKER(AV_RB32(buf))){ /* frame starts with marker and needs to be parsed */
03623             const uint8_t *start, *end, *next;
03624             int size;
03625 
03626             next = buf;
03627             for(start = buf, end = buf + buf_size; next < end; start = next){
03628                 next = find_next_marker(start + 4, end);
03629                 size = next - start - 4;
03630                 if(size <= 0) continue;
03631                 switch(AV_RB32(start)){
03632                 case VC1_CODE_FRAME:
03633                     if (avctx->hwaccel ||
03634                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
03635                         buf_start = start;
03636                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03637                     break;
03638                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
03639                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
03640                     init_get_bits(&s->gb, buf2, buf_size2*8);
03641                     vc1_decode_entry_point(avctx, v, &s->gb);
03642                     break;
03643                 case VC1_CODE_SLICE: {
03644                     int buf_size3;
03645                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
03646                     if (!slices) goto err;
03647                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
03648                     if (!slices[n_slices].buf) goto err;
03649                     buf_size3 = vc1_unescape_buffer(start + 4, size,
03650                                                     slices[n_slices].buf);
03651                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
03652                                   buf_size3 << 3);
03653                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
03654                     n_slices++;
03655                     break;
03656                 }
03657                 }
03658             }
03659         }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
03660             const uint8_t *divider;
03661 
03662             divider = find_next_marker(buf, buf + buf_size);
03663             if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
03664                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
03665                 goto err;
03666             }
03667 
03668             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
03669             // TODO
03670             if(!v->warn_interlaced++)
03671                 av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced WVC1 support is not implemented\n");
03672             goto err;
03673         }else{
03674             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
03675         }
03676         init_get_bits(&s->gb, buf2, buf_size2*8);
03677     } else
03678         init_get_bits(&s->gb, buf, buf_size*8);
03679 
03680     if (v->res_sprite) {
03681         v->new_sprite = !get_bits1(&s->gb);
03682         v->two_sprites = get_bits1(&s->gb);
03683         if (!v->new_sprite)
03684             goto end;
03685     }
03686 
03687     // do parse frame header
03688     if(v->profile < PROFILE_ADVANCED) {
03689         if(vc1_parse_frame_header(v, &s->gb) == -1) {
03690             goto err;
03691         }
03692     } else {
03693         if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
03694             goto err;
03695         }
03696     }
03697 
03698     if (v->res_sprite && s->pict_type!=AV_PICTURE_TYPE_I) {
03699         av_log(v->s.avctx, AV_LOG_WARNING, "Sprite decoder: expected I-frame\n");
03700     }
03701 
03702     // for skipping the frame
03703     s->current_picture.pict_type= s->pict_type;
03704     s->current_picture.key_frame= s->pict_type == AV_PICTURE_TYPE_I;
03705 
03706     /* skip B-frames if we don't have reference frames */
03707     if(s->last_picture_ptr==NULL && (s->pict_type==AV_PICTURE_TYPE_B || s->dropable)){
03708         goto err;
03709     }
03710     if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
03711        || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
03712        ||  avctx->skip_frame >= AVDISCARD_ALL) {
03713         goto end;
03714     }
03715 
03716     if(s->next_p_frame_damaged){
03717         if(s->pict_type==AV_PICTURE_TYPE_B)
03718             goto end;
03719         else
03720             s->next_p_frame_damaged=0;
03721     }
03722 
03723     if(MPV_frame_start(s, avctx) < 0) {
03724         goto err;
03725     }
03726 
03727     s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
03728     s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
03729 
03730     if ((CONFIG_VC1_VDPAU_DECODER)
03731         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
03732         ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
03733     else if (avctx->hwaccel) {
03734         if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
03735             goto err;
03736         if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
03737             goto err;
03738         if (avctx->hwaccel->end_frame(avctx) < 0)
03739             goto err;
03740     } else {
03741         ff_er_frame_start(s);
03742 
03743         v->bits = buf_size * 8;
03744         for (i = 0; i <= n_slices; i++) {
03745             if (i && get_bits1(&s->gb))
03746                 vc1_parse_frame_header_adv(v, &s->gb);
03747             s->start_mb_y = (i == 0)        ? 0 : FFMAX(0, slices[i-1].mby_start);
03748             s->end_mb_y   = (i == n_slices) ? s->mb_height : FFMIN(s->mb_height, slices[i].mby_start);
03749             vc1_decode_blocks(v);
03750             if (i != n_slices) s->gb = slices[i].gb;
03751         }
03752 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
03753 //  if(get_bits_count(&s->gb) > buf_size * 8)
03754 //      return -1;
03755         ff_er_frame_end(s);
03756     }
03757 
03758     MPV_frame_end(s);
03759 
03760 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
03761 assert(s->current_picture.pict_type == s->pict_type);
03762     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
03763         *pict= *(AVFrame*)s->current_picture_ptr;
03764     } else if (s->last_picture_ptr != NULL) {
03765         *pict= *(AVFrame*)s->last_picture_ptr;
03766     }
03767 
03768     if(s->last_picture_ptr || s->low_delay){
03769         *data_size = sizeof(AVFrame);
03770         ff_print_debug_info(s, pict);
03771     }
03772 
03773 end:
03774     if (v->res_sprite)
03775         vc1_parse_sprites(v, &s->gb);
03776     av_free(buf2);
03777     for (i = 0; i < n_slices; i++)
03778         av_free(slices[i].buf);
03779     av_free(slices);
03780     return buf_size;
03781 
03782 err:
03783     av_free(buf2);
03784     for (i = 0; i < n_slices; i++)
03785         av_free(slices[i].buf);
03786     av_free(slices);
03787     return -1;
03788 }
03789 
03790 
03794 static av_cold int vc1_decode_end(AVCodecContext *avctx)
03795 {
03796     VC1Context *v = avctx->priv_data;
03797 
03798     av_freep(&v->hrd_rate);
03799     av_freep(&v->hrd_buffer);
03800     MPV_common_end(&v->s);
03801     av_freep(&v->mv_type_mb_plane);
03802     av_freep(&v->direct_mb_plane);
03803     av_freep(&v->acpred_plane);
03804     av_freep(&v->over_flags_plane);
03805     av_freep(&v->mb_type_base);
03806     av_freep(&v->block);
03807     av_freep(&v->cbp_base);
03808     av_freep(&v->ttblk_base);
03809     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
03810     av_freep(&v->luma_mv_base);
03811     ff_intrax8_common_end(&v->x8);
03812     return 0;
03813 }
03814 
03815 static const AVProfile profiles[] = {
03816     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
03817     { FF_PROFILE_VC1_MAIN,     "Main"     },
03818     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
03819     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
03820     { FF_PROFILE_UNKNOWN },
03821 };
03822 
03823 AVCodec ff_vc1_decoder = {
03824     "vc1",
03825     AVMEDIA_TYPE_VIDEO,
03826     CODEC_ID_VC1,
03827     sizeof(VC1Context),
03828     vc1_decode_init,
03829     NULL,
03830     vc1_decode_end,
03831     vc1_decode_frame,
03832     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
03833     NULL,
03834     .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
03835     .pix_fmts = ff_hwaccel_pixfmt_list_420,
03836     .profiles = NULL_IF_CONFIG_SMALL(profiles)
03837 };
03838 
03839 #if CONFIG_WMV3_DECODER
03840 AVCodec ff_wmv3_decoder = {
03841     "wmv3",
03842     AVMEDIA_TYPE_VIDEO,
03843     CODEC_ID_WMV3,
03844     sizeof(VC1Context),
03845     vc1_decode_init,
03846     NULL,
03847     vc1_decode_end,
03848     vc1_decode_frame,
03849     CODEC_CAP_DR1 | CODEC_CAP_DELAY,
03850     NULL,
03851     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
03852     .pix_fmts = ff_hwaccel_pixfmt_list_420,
03853     .profiles = NULL_IF_CONFIG_SMALL(profiles)
03854 };
03855 #endif
03856 
03857 #if CONFIG_WMV3_VDPAU_DECODER
03858 AVCodec ff_wmv3_vdpau_decoder = {
03859     "wmv3_vdpau",
03860     AVMEDIA_TYPE_VIDEO,
03861     CODEC_ID_WMV3,
03862     sizeof(VC1Context),
03863     vc1_decode_init,
03864     NULL,
03865     vc1_decode_end,
03866     vc1_decode_frame,
03867     CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
03868     NULL,
03869     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
03870     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
03871     .profiles = NULL_IF_CONFIG_SMALL(profiles)
03872 };
03873 #endif
03874 
03875 #if CONFIG_VC1_VDPAU_DECODER
03876 AVCodec ff_vc1_vdpau_decoder = {
03877     "vc1_vdpau",
03878     AVMEDIA_TYPE_VIDEO,
03879     CODEC_ID_VC1,
03880     sizeof(VC1Context),
03881     vc1_decode_init,
03882     NULL,
03883     vc1_decode_end,
03884     vc1_decode_frame,
03885     CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
03886     NULL,
03887     .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
03888     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
03889     .profiles = NULL_IF_CONFIG_SMALL(profiles)
03890 };
03891 #endif