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