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