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     if (!v->s.last_picture.f.data[0])
04745         return;
04746 
04747     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
04748     s->first_slice_line = 1;
04749     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
04750         s->mb_x = 0;
04751         ff_init_block_index(s);
04752         ff_update_block_index(s);
04753         memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize,   s->linesize   * 16);
04754         memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
04755         memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
04756         ff_draw_horiz_band(s, s->mb_y * 16, 16);
04757         s->first_slice_line = 0;
04758     }
04759     s->pict_type = AV_PICTURE_TYPE_P;
04760 }
04761 
04762 static void vc1_decode_blocks(VC1Context *v)
04763 {
04764 
04765     v->s.esc3_level_length = 0;
04766     if (v->x8_type) {
04767         ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
04768     } else {
04769         v->cur_blk_idx     =  0;
04770         v->left_blk_idx    = -1;
04771         v->topleft_blk_idx =  1;
04772         v->top_blk_idx     =  2;
04773         switch (v->s.pict_type) {
04774         case AV_PICTURE_TYPE_I:
04775             if (v->profile == PROFILE_ADVANCED)
04776                 vc1_decode_i_blocks_adv(v);
04777             else
04778                 vc1_decode_i_blocks(v);
04779             break;
04780         case AV_PICTURE_TYPE_P:
04781             if (v->p_frame_skipped)
04782                 vc1_decode_skip_blocks(v);
04783             else
04784                 vc1_decode_p_blocks(v);
04785             break;
04786         case AV_PICTURE_TYPE_B:
04787             if (v->bi_type) {
04788                 if (v->profile == PROFILE_ADVANCED)
04789                     vc1_decode_i_blocks_adv(v);
04790                 else
04791                     vc1_decode_i_blocks(v);
04792             } else
04793                 vc1_decode_b_blocks(v);
04794             break;
04795         }
04796     }
04797 }
04798 
04799 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
04800 
04801 typedef struct {
04813     int coefs[2][7];
04814 
04815     int effect_type, effect_flag;
04816     int effect_pcount1, effect_pcount2;   
04817     int effect_params1[15], effect_params2[10]; 
04818 } SpriteData;
04819 
04820 static inline int get_fp_val(GetBitContext* gb)
04821 {
04822     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
04823 }
04824 
04825 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
04826 {
04827     c[1] = c[3] = 0;
04828 
04829     switch (get_bits(gb, 2)) {
04830     case 0:
04831         c[0] = 1 << 16;
04832         c[2] = get_fp_val(gb);
04833         c[4] = 1 << 16;
04834         break;
04835     case 1:
04836         c[0] = c[4] = get_fp_val(gb);
04837         c[2] = get_fp_val(gb);
04838         break;
04839     case 2:
04840         c[0] = get_fp_val(gb);
04841         c[2] = get_fp_val(gb);
04842         c[4] = get_fp_val(gb);
04843         break;
04844     case 3:
04845         c[0] = get_fp_val(gb);
04846         c[1] = get_fp_val(gb);
04847         c[2] = get_fp_val(gb);
04848         c[3] = get_fp_val(gb);
04849         c[4] = get_fp_val(gb);
04850         break;
04851     }
04852     c[5] = get_fp_val(gb);
04853     if (get_bits1(gb))
04854         c[6] = get_fp_val(gb);
04855     else
04856         c[6] = 1 << 16;
04857 }
04858 
04859 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
04860 {
04861     AVCodecContext *avctx = v->s.avctx;
04862     int sprite, i;
04863 
04864     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
04865         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
04866         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
04867             av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
04868         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
04869         for (i = 0; i < 7; i++)
04870             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
04871                    sd->coefs[sprite][i] / (1<<16),
04872                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
04873         av_log(avctx, AV_LOG_DEBUG, "\n");
04874     }
04875 
04876     skip_bits(gb, 2);
04877     if (sd->effect_type = get_bits_long(gb, 30)) {
04878         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
04879         case 7:
04880             vc1_sprite_parse_transform(gb, sd->effect_params1);
04881             break;
04882         case 14:
04883             vc1_sprite_parse_transform(gb, sd->effect_params1);
04884             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
04885             break;
04886         default:
04887             for (i = 0; i < sd->effect_pcount1; i++)
04888                 sd->effect_params1[i] = get_fp_val(gb);
04889         }
04890         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
04891             // effect 13 is simple alpha blending and matches the opacity above
04892             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
04893             for (i = 0; i < sd->effect_pcount1; i++)
04894                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
04895                        sd->effect_params1[i] / (1 << 16),
04896                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
04897             av_log(avctx, AV_LOG_DEBUG, "\n");
04898         }
04899 
04900         sd->effect_pcount2 = get_bits(gb, 16);
04901         if (sd->effect_pcount2 > 10) {
04902             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
04903             return;
04904         } else if (sd->effect_pcount2) {
04905             i = -1;
04906             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
04907             while (++i < sd->effect_pcount2) {
04908                 sd->effect_params2[i] = get_fp_val(gb);
04909                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
04910                        sd->effect_params2[i] / (1 << 16),
04911                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
04912             }
04913             av_log(avctx, AV_LOG_DEBUG, "\n");
04914         }
04915     }
04916     if (sd->effect_flag = get_bits1(gb))
04917         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
04918 
04919     if (get_bits_count(gb) >= gb->size_in_bits +
04920        (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
04921         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
04922     if (get_bits_count(gb) < gb->size_in_bits - 8)
04923         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
04924 }
04925 
04926 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
04927 {
04928     int i, plane, row, sprite;
04929     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
04930     uint8_t* src_h[2][2];
04931     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
04932     int ysub[2];
04933     MpegEncContext *s = &v->s;
04934 
04935     for (i = 0; i < 2; i++) {
04936         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
04937         xadv[i] = sd->coefs[i][0];
04938         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
04939             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
04940 
04941         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
04942         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
04943     }
04944     alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
04945 
04946     for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
04947         int width = v->output_width>>!!plane;
04948 
04949         for (row = 0; row < v->output_height>>!!plane; row++) {
04950             uint8_t *dst = v->sprite_output_frame.data[plane] +
04951                            v->sprite_output_frame.linesize[plane] * row;
04952 
04953             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
04954                 uint8_t *iplane = s->current_picture.f.data[plane];
04955                 int      iline  = s->current_picture.f.linesize[plane];
04956                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
04957                 int      yline  = ycoord >> 16;
04958                 ysub[sprite] = ycoord & 0xFFFF;
04959                 if (sprite) {
04960                     iplane = s->last_picture.f.data[plane];
04961                     iline  = s->last_picture.f.linesize[plane];
04962                 }
04963                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
04964                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
04965                     if (ysub[sprite])
04966                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
04967                 } else {
04968                     if (sr_cache[sprite][0] != yline) {
04969                         if (sr_cache[sprite][1] == yline) {
04970                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
04971                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
04972                         } else {
04973                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
04974                             sr_cache[sprite][0] = yline;
04975                         }
04976                     }
04977                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
04978                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
04979                         sr_cache[sprite][1] = yline + 1;
04980                     }
04981                     src_h[sprite][0] = v->sr_rows[sprite][0];
04982                     src_h[sprite][1] = v->sr_rows[sprite][1];
04983                 }
04984             }
04985 
04986             if (!v->two_sprites) {
04987                 if (ysub[0]) {
04988                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
04989                 } else {
04990                     memcpy(dst, src_h[0][0], width);
04991                 }
04992             } else {
04993                 if (ysub[0] && ysub[1]) {
04994                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
04995                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
04996                 } else if (ysub[0]) {
04997                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
04998                                                        src_h[1][0], alpha, width);
04999                 } else if (ysub[1]) {
05000                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
05001                                                        src_h[0][0], (1<<16)-1-alpha, width);
05002                 } else {
05003                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
05004                 }
05005             }
05006         }
05007 
05008         if (!plane) {
05009             for (i = 0; i < 2; i++) {
05010                 xoff[i] >>= 1;
05011                 yoff[i] >>= 1;
05012             }
05013         }
05014 
05015     }
05016 }
05017 
05018 
05019 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
05020 {
05021     MpegEncContext *s     = &v->s;
05022     AVCodecContext *avctx = s->avctx;
05023     SpriteData sd;
05024 
05025     vc1_parse_sprites(v, gb, &sd);
05026 
05027     if (!s->current_picture.f.data[0]) {
05028         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
05029         return -1;
05030     }
05031 
05032     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
05033         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
05034         v->two_sprites = 0;
05035     }
05036 
05037     if (v->sprite_output_frame.data[0])
05038         avctx->release_buffer(avctx, &v->sprite_output_frame);
05039 
05040     v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
05041     v->sprite_output_frame.reference = 0;
05042     if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
05043         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
05044         return -1;
05045     }
05046 
05047     vc1_draw_sprites(v, &sd);
05048 
05049     return 0;
05050 }
05051 
05052 static void vc1_sprite_flush(AVCodecContext *avctx)
05053 {
05054     VC1Context *v     = avctx->priv_data;
05055     MpegEncContext *s = &v->s;
05056     AVFrame *f = &s->current_picture.f;
05057     int plane, i;
05058 
05059     /* Windows Media Image codecs have a convergence interval of two keyframes.
05060        Since we can't enforce it, clear to black the missing sprite. This is
05061        wrong but it looks better than doing nothing. */
05062 
05063     if (f->data[0])
05064         for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
05065             for (i = 0; i < v->sprite_height>>!!plane; i++)
05066                 memset(f->data[plane] + i * f->linesize[plane],
05067                        plane ? 128 : 0, f->linesize[plane]);
05068 }
05069 
05070 #endif
05071 
05072 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
05073 {
05074     MpegEncContext *s = &v->s;
05075     int i;
05076 
05077     /* Allocate mb bitplanes */
05078     v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05079     v->direct_mb_plane  = av_malloc (s->mb_stride * s->mb_height);
05080     v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
05081     v->fieldtx_plane    = av_mallocz(s->mb_stride * s->mb_height);
05082     v->acpred_plane     = av_malloc (s->mb_stride * s->mb_height);
05083     v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
05084 
05085     v->n_allocated_blks = s->mb_width + 2;
05086     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
05087     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
05088     v->cbp              = v->cbp_base + s->mb_stride;
05089     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
05090     v->ttblk            = v->ttblk_base + s->mb_stride;
05091     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
05092     v->is_intra         = v->is_intra_base + s->mb_stride;
05093     v->luma_mv_base     = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
05094     v->luma_mv          = v->luma_mv_base + s->mb_stride;
05095 
05096     /* allocate block type info in that way so it could be used with s->block_index[] */
05097     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05098     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
05099     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
05100     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
05101 
05102     /* allocate memory to store block level MV info */
05103     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05104     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
05105     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05106     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
05107     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
05108     v->mv_f_last_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05109     v->mv_f_last[0]     = v->mv_f_last_base + s->b8_stride + 1;
05110     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);
05111     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05112     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
05113     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);
05114 
05115     /* Init coded blocks info */
05116     if (v->profile == PROFILE_ADVANCED) {
05117 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
05118 //            return -1;
05119 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
05120 //            return -1;
05121     }
05122 
05123     ff_intrax8_common_init(&v->x8,s);
05124 
05125     if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
05126         for (i = 0; i < 4; i++)
05127             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
05128     }
05129 
05130     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
05131         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
05132         !v->mb_type_base) {
05133         av_freep(&v->mv_type_mb_plane);
05134         av_freep(&v->direct_mb_plane);
05135         av_freep(&v->acpred_plane);
05136         av_freep(&v->over_flags_plane);
05137         av_freep(&v->block);
05138         av_freep(&v->cbp_base);
05139         av_freep(&v->ttblk_base);
05140         av_freep(&v->is_intra_base);
05141         av_freep(&v->luma_mv_base);
05142         av_freep(&v->mb_type_base);
05143         return AVERROR(ENOMEM);
05144     }
05145 
05146     return 0;
05147 }
05148 
05153 static av_cold int vc1_decode_init(AVCodecContext *avctx)
05154 {
05155     VC1Context *v = avctx->priv_data;
05156     MpegEncContext *s = &v->s;
05157     GetBitContext gb;
05158     int i;
05159 
05160     /* save the container output size for WMImage */
05161     v->output_width  = avctx->width;
05162     v->output_height = avctx->height;
05163 
05164     if (!avctx->extradata_size || !avctx->extradata)
05165         return -1;
05166     if (!(avctx->flags & CODEC_FLAG_GRAY))
05167         avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
05168     else
05169         avctx->pix_fmt = PIX_FMT_GRAY8;
05170     avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
05171     v->s.avctx = avctx;
05172     avctx->flags |= CODEC_FLAG_EMU_EDGE;
05173     v->s.flags   |= CODEC_FLAG_EMU_EDGE;
05174 
05175     if (avctx->idct_algo == FF_IDCT_AUTO) {
05176         avctx->idct_algo = FF_IDCT_WMV2;
05177     }
05178 
05179     if (ff_vc1_init_common(v) < 0)
05180         return -1;
05181     ff_vc1dsp_init(&v->vc1dsp);
05182 
05183     if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
05184         int count = 0;
05185 
05186         // looks like WMV3 has a sequence header stored in the extradata
05187         // advanced sequence header may be before the first frame
05188         // the last byte of the extradata is a version number, 1 for the
05189         // samples we can decode
05190 
05191         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
05192 
05193         if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
05194           return -1;
05195 
05196         count = avctx->extradata_size*8 - get_bits_count(&gb);
05197         if (count > 0) {
05198             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
05199                    count, get_bits(&gb, count));
05200         } else if (count < 0) {
05201             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
05202         }
05203     } else { // VC1/WVC1/WVP2
05204         const uint8_t *start = avctx->extradata;
05205         uint8_t *end = avctx->extradata + avctx->extradata_size;
05206         const uint8_t *next;
05207         int size, buf2_size;
05208         uint8_t *buf2 = NULL;
05209         int seq_initialized = 0, ep_initialized = 0;
05210 
05211         if (avctx->extradata_size < 16) {
05212             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
05213             return -1;
05214         }
05215 
05216         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
05217         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
05218         next  = start;
05219         for (; next < end; start = next) {
05220             next = find_next_marker(start + 4, end);
05221             size = next - start - 4;
05222             if (size <= 0)
05223                 continue;
05224             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
05225             init_get_bits(&gb, buf2, buf2_size * 8);
05226             switch (AV_RB32(start)) {
05227             case VC1_CODE_SEQHDR:
05228                 if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
05229                     av_free(buf2);
05230                     return -1;
05231                 }
05232                 seq_initialized = 1;
05233                 break;
05234             case VC1_CODE_ENTRYPOINT:
05235                 if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
05236                     av_free(buf2);
05237                     return -1;
05238                 }
05239                 ep_initialized = 1;
05240                 break;
05241             }
05242         }
05243         av_free(buf2);
05244         if (!seq_initialized || !ep_initialized) {
05245             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
05246             return -1;
05247         }
05248         v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
05249     }
05250 
05251     avctx->profile = v->profile;
05252     if (v->profile == PROFILE_ADVANCED)
05253         avctx->level = v->level;
05254 
05255     avctx->has_b_frames = !!avctx->max_b_frames;
05256 
05257     s->mb_width  = (avctx->coded_width  + 15) >> 4;
05258     s->mb_height = (avctx->coded_height + 15) >> 4;
05259 
05260     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
05261         for (i = 0; i < 64; i++) {
05262 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
05263             v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
05264             v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
05265             v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
05266             v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
05267             v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
05268         }
05269         v->left_blk_sh = 0;
05270         v->top_blk_sh  = 3;
05271     } else {
05272         memcpy(v->zz_8x8, wmv1_scantable, 4*64);
05273         v->left_blk_sh = 3;
05274         v->top_blk_sh  = 0;
05275     }
05276 
05277     if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05278         v->sprite_width  = avctx->coded_width;
05279         v->sprite_height = avctx->coded_height;
05280 
05281         avctx->coded_width  = avctx->width  = v->output_width;
05282         avctx->coded_height = avctx->height = v->output_height;
05283 
05284         // prevent 16.16 overflows
05285         if (v->sprite_width  > 1 << 14 ||
05286             v->sprite_height > 1 << 14 ||
05287             v->output_width  > 1 << 14 ||
05288             v->output_height > 1 << 14) return -1;
05289     }
05290     return 0;
05291 }
05292 
05296 static av_cold int vc1_decode_end(AVCodecContext *avctx)
05297 {
05298     VC1Context *v = avctx->priv_data;
05299     int i;
05300 
05301     if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05302         && v->sprite_output_frame.data[0])
05303         avctx->release_buffer(avctx, &v->sprite_output_frame);
05304     for (i = 0; i < 4; i++)
05305         av_freep(&v->sr_rows[i >> 1][i & 1]);
05306     av_freep(&v->hrd_rate);
05307     av_freep(&v->hrd_buffer);
05308     MPV_common_end(&v->s);
05309     av_freep(&v->mv_type_mb_plane);
05310     av_freep(&v->direct_mb_plane);
05311     av_freep(&v->forward_mb_plane);
05312     av_freep(&v->fieldtx_plane);
05313     av_freep(&v->acpred_plane);
05314     av_freep(&v->over_flags_plane);
05315     av_freep(&v->mb_type_base);
05316     av_freep(&v->blk_mv_type_base);
05317     av_freep(&v->mv_f_base);
05318     av_freep(&v->mv_f_last_base);
05319     av_freep(&v->mv_f_next_base);
05320     av_freep(&v->block);
05321     av_freep(&v->cbp_base);
05322     av_freep(&v->ttblk_base);
05323     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
05324     av_freep(&v->luma_mv_base);
05325     ff_intrax8_common_end(&v->x8);
05326     return 0;
05327 }
05328 
05329 
05333 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
05334                             int *data_size, AVPacket *avpkt)
05335 {
05336     const uint8_t *buf = avpkt->data;
05337     int buf_size = avpkt->size, n_slices = 0, i;
05338     VC1Context *v = avctx->priv_data;
05339     MpegEncContext *s = &v->s;
05340     AVFrame *pict = data;
05341     uint8_t *buf2 = NULL;
05342     const uint8_t *buf_start = buf;
05343     int mb_height, n_slices1;
05344     struct {
05345         uint8_t *buf;
05346         GetBitContext gb;
05347         int mby_start;
05348     } *slices = NULL, *tmp;
05349 
05350     /* no supplementary picture */
05351     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
05352         /* special case for last picture */
05353         if (s->low_delay == 0 && s->next_picture_ptr) {
05354             *pict = *(AVFrame*)s->next_picture_ptr;
05355             s->next_picture_ptr = NULL;
05356 
05357             *data_size = sizeof(AVFrame);
05358         }
05359 
05360         return 0;
05361     }
05362 
05363     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
05364         if (v->profile < PROFILE_ADVANCED)
05365             avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
05366         else
05367             avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
05368     }
05369 
05370     //for advanced profile we may need to parse and unescape data
05371     if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05372         int buf_size2 = 0;
05373         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05374 
05375         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
05376             const uint8_t *start, *end, *next;
05377             int size;
05378 
05379             next = buf;
05380             for (start = buf, end = buf + buf_size; next < end; start = next) {
05381                 next = find_next_marker(start + 4, end);
05382                 size = next - start - 4;
05383                 if (size <= 0) continue;
05384                 switch (AV_RB32(start)) {
05385                 case VC1_CODE_FRAME:
05386                     if (avctx->hwaccel ||
05387                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05388                         buf_start = start;
05389                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05390                     break;
05391                 case VC1_CODE_FIELD: {
05392                     int buf_size3;
05393                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05394                     if (!slices)
05395                         goto err;
05396                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05397                     if (!slices[n_slices].buf)
05398                         goto err;
05399                     buf_size3 = vc1_unescape_buffer(start + 4, size,
05400                                                     slices[n_slices].buf);
05401                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05402                                   buf_size3 << 3);
05403                     /* assuming that the field marker is at the exact middle,
05404                        hope it's correct */
05405                     slices[n_slices].mby_start = s->mb_height >> 1;
05406                     n_slices1 = n_slices - 1; // index of the last slice of the first field
05407                     n_slices++;
05408                     break;
05409                 }
05410                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
05411                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
05412                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
05413                     vc1_decode_entry_point(avctx, v, &s->gb);
05414                     break;
05415                 case VC1_CODE_SLICE: {
05416                     int buf_size3;
05417                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05418                     if (!slices)
05419                         goto err;
05420                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05421                     if (!slices[n_slices].buf)
05422                         goto err;
05423                     buf_size3 = vc1_unescape_buffer(start + 4, size,
05424                                                     slices[n_slices].buf);
05425                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05426                                   buf_size3 << 3);
05427                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
05428                     n_slices++;
05429                     break;
05430                 }
05431                 }
05432             }
05433         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
05434             const uint8_t *divider;
05435             int buf_size3;
05436 
05437             divider = find_next_marker(buf, buf + buf_size);
05438             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
05439                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
05440                 goto err;
05441             } else { // found field marker, unescape second field
05442                 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
05443                 if (!tmp)
05444                     goto err;
05445                 slices = tmp;
05446                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
05447                 if (!slices[n_slices].buf)
05448                     goto err;
05449                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
05450                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
05451                               buf_size3 << 3);
05452                 slices[n_slices].mby_start = s->mb_height >> 1;
05453                 n_slices1 = n_slices - 1;
05454                 n_slices++;
05455             }
05456             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
05457         } else {
05458             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
05459         }
05460         init_get_bits(&s->gb, buf2, buf_size2*8);
05461     } else
05462         init_get_bits(&s->gb, buf, buf_size*8);
05463 
05464     if (v->res_sprite) {
05465         v->new_sprite  = !get_bits1(&s->gb);
05466         v->two_sprites =  get_bits1(&s->gb);
05467         /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
05468            we're using the sprite compositor. These are intentionally kept separate
05469            so you can get the raw sprites by using the wmv3 decoder for WMVP or
05470            the vc1 one for WVP2 */
05471         if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05472             if (v->new_sprite) {
05473                 // switch AVCodecContext parameters to those of the sprites
05474                 avctx->width  = avctx->coded_width  = v->sprite_width;
05475                 avctx->height = avctx->coded_height = v->sprite_height;
05476             } else {
05477                 goto image;
05478             }
05479         }
05480     }
05481 
05482     if (s->context_initialized &&
05483         (s->width  != avctx->coded_width ||
05484          s->height != avctx->coded_height)) {
05485         vc1_decode_end(avctx);
05486     }
05487 
05488     if (!s->context_initialized) {
05489         if (ff_msmpeg4_decode_init(avctx) < 0)
05490             return -1;
05491         if (vc1_decode_init_alloc_tables(v) < 0) {
05492             MPV_common_end(s);
05493             return -1;
05494         }
05495 
05496         s->low_delay = !avctx->has_b_frames || v->res_sprite;
05497 
05498         if (v->profile == PROFILE_ADVANCED) {
05499             s->h_edge_pos = avctx->coded_width;
05500             s->v_edge_pos = avctx->coded_height;
05501         }
05502     }
05503 
05504     /* We need to set current_picture_ptr before reading the header,
05505      * otherwise we cannot store anything in there. */
05506     if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
05507         int i = ff_find_unused_picture(s, 0);
05508         if (i < 0)
05509             goto err;
05510         s->current_picture_ptr = &s->picture[i];
05511     }
05512 
05513     // do parse frame header
05514     v->pic_header_flag = 0;
05515     if (v->profile < PROFILE_ADVANCED) {
05516         if (vc1_parse_frame_header(v, &s->gb) == -1) {
05517             goto err;
05518         }
05519     } else {
05520         if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
05521             goto err;
05522         }
05523     }
05524 
05525     if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
05526         && s->pict_type != AV_PICTURE_TYPE_I) {
05527         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
05528         goto err;
05529     }
05530 
05531     // process pulldown flags
05532     s->current_picture_ptr->f.repeat_pict = 0;
05533     // Pulldown flags are only valid when 'broadcast' has been set.
05534     // So ticks_per_frame will be 2
05535     if (v->rff) {
05536         // repeat field
05537         s->current_picture_ptr->f.repeat_pict = 1;
05538     } else if (v->rptfrm) {
05539         // repeat frames
05540         s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
05541     }
05542 
05543     // for skipping the frame
05544     s->current_picture.f.pict_type = s->pict_type;
05545     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
05546 
05547     /* skip B-frames if we don't have reference frames */
05548     if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
05549         goto err;
05550     }
05551     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
05552         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
05553          avctx->skip_frame >= AVDISCARD_ALL) {
05554         goto end;
05555     }
05556 
05557     if (s->next_p_frame_damaged) {
05558         if (s->pict_type == AV_PICTURE_TYPE_B)
05559             goto end;
05560         else
05561             s->next_p_frame_damaged = 0;
05562     }
05563 
05564     if (MPV_frame_start(s, avctx) < 0) {
05565         goto err;
05566     }
05567 
05568     s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
05569     s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
05570 
05571     if ((CONFIG_VC1_VDPAU_DECODER)
05572         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
05573         ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
05574     else if (avctx->hwaccel) {
05575         if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
05576             goto err;
05577         if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
05578             goto err;
05579         if (avctx->hwaccel->end_frame(avctx) < 0)
05580             goto err;
05581     } else {
05582         int header_ret = 0;
05583 
05584         ff_er_frame_start(s);
05585 
05586         v->bits = buf_size * 8;
05587         if (v->field_mode) {
05588             uint8_t *tmp[2];
05589             s->current_picture.f.linesize[0] <<= 1;
05590             s->current_picture.f.linesize[1] <<= 1;
05591             s->current_picture.f.linesize[2] <<= 1;
05592             s->linesize                      <<= 1;
05593             s->uvlinesize                    <<= 1;
05594             tmp[0]          = v->mv_f_last[0];
05595             tmp[1]          = v->mv_f_last[1];
05596             v->mv_f_last[0] = v->mv_f_next[0];
05597             v->mv_f_last[1] = v->mv_f_next[1];
05598             v->mv_f_next[0] = v->mv_f[0];
05599             v->mv_f_next[1] = v->mv_f[1];
05600             v->mv_f[0] = tmp[0];
05601             v->mv_f[1] = tmp[1];
05602         }
05603         mb_height = s->mb_height >> v->field_mode;
05604 
05605         if (!mb_height) {
05606             av_log(v->s.avctx, AV_LOG_ERROR, "Invalid mb_height.\n");
05607             goto err;
05608         }
05609 
05610         for (i = 0; i <= n_slices; i++) {
05611             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
05612                 if (v->field_mode <= 0) {
05613                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
05614                            "picture boundary (%d >= %d)\n", i,
05615                            slices[i - 1].mby_start, mb_height);
05616                     continue;
05617                 }
05618                 v->second_field = 1;
05619                 v->blocks_off   = s->mb_width  * s->mb_height << 1;
05620                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
05621             } else {
05622                 v->second_field = 0;
05623                 v->blocks_off   = 0;
05624                 v->mb_off       = 0;
05625             }
05626             if (i) {
05627                 v->pic_header_flag = 0;
05628                 if (v->field_mode && i == n_slices1 + 2) {
05629                     if ((header_ret = vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
05630                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
05631                         continue;
05632                     }
05633                 } else if (get_bits1(&s->gb)) {
05634                     v->pic_header_flag = 1;
05635                     if ((header_ret = vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
05636                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
05637                         continue;
05638                     }
05639                 }
05640             }
05641             if (header_ret < 0)
05642                 continue;
05643             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
05644             if (!v->field_mode || v->second_field)
05645                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05646             else
05647                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
05648             vc1_decode_blocks(v);
05649             if (i != n_slices)
05650                 s->gb = slices[i].gb;
05651         }
05652         if (v->field_mode) {
05653             v->second_field = 0;
05654             if (s->pict_type == AV_PICTURE_TYPE_B) {
05655                 memcpy(v->mv_f_base, v->mv_f_next_base,
05656                        2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
05657             }
05658             s->current_picture.f.linesize[0] >>= 1;
05659             s->current_picture.f.linesize[1] >>= 1;
05660             s->current_picture.f.linesize[2] >>= 1;
05661             s->linesize                      >>= 1;
05662             s->uvlinesize                    >>= 1;
05663         }
05664 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
05665 //  if (get_bits_count(&s->gb) > buf_size * 8)
05666 //      return -1;
05667         ff_er_frame_end(s);
05668     }
05669 
05670     MPV_frame_end(s);
05671 
05672     if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
05673 image:
05674         avctx->width  = avctx->coded_width  = v->output_width;
05675         avctx->height = avctx->coded_height = v->output_height;
05676         if (avctx->skip_frame >= AVDISCARD_NONREF)
05677             goto end;
05678 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
05679         if (vc1_decode_sprites(v, &s->gb))
05680             goto err;
05681 #endif
05682         *pict      = v->sprite_output_frame;
05683         *data_size = sizeof(AVFrame);
05684     } else {
05685         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
05686             *pict = *(AVFrame*)s->current_picture_ptr;
05687         } else if (s->last_picture_ptr != NULL) {
05688             *pict = *(AVFrame*)s->last_picture_ptr;
05689         }
05690         if (s->last_picture_ptr || s->low_delay) {
05691             *data_size = sizeof(AVFrame);
05692             ff_print_debug_info(s, pict);
05693         }
05694     }
05695 
05696 end:
05697     av_free(buf2);
05698     for (i = 0; i < n_slices; i++)
05699         av_free(slices[i].buf);
05700     av_free(slices);
05701     return buf_size;
05702 
05703 err:
05704     av_free(buf2);
05705     for (i = 0; i < n_slices; i++)
05706         av_free(slices[i].buf);
05707     av_free(slices);
05708     return -1;
05709 }
05710 
05711 
05712 static const AVProfile profiles[] = {
05713     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
05714     { FF_PROFILE_VC1_MAIN,     "Main"     },
05715     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
05716     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
05717     { FF_PROFILE_UNKNOWN },
05718 };
05719 
05720 AVCodec ff_vc1_decoder = {
05721     .name           = "vc1",
05722     .type           = AVMEDIA_TYPE_VIDEO,
05723     .id             = CODEC_ID_VC1,
05724     .priv_data_size = sizeof(VC1Context),
05725     .init           = vc1_decode_init,
05726     .close          = vc1_decode_end,
05727     .decode         = vc1_decode_frame,
05728     .flush          = ff_mpeg_flush,
05729     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05730     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
05731     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
05732     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05733 };
05734 
05735 #if CONFIG_WMV3_DECODER
05736 AVCodec ff_wmv3_decoder = {
05737     .name           = "wmv3",
05738     .type           = AVMEDIA_TYPE_VIDEO,
05739     .id             = CODEC_ID_WMV3,
05740     .priv_data_size = sizeof(VC1Context),
05741     .init           = vc1_decode_init,
05742     .close          = vc1_decode_end,
05743     .decode         = vc1_decode_frame,
05744     .flush          = ff_mpeg_flush,
05745     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
05746     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
05747     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
05748     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05749 };
05750 #endif
05751 
05752 #if CONFIG_WMV3_VDPAU_DECODER
05753 AVCodec ff_wmv3_vdpau_decoder = {
05754     .name           = "wmv3_vdpau",
05755     .type           = AVMEDIA_TYPE_VIDEO,
05756     .id             = CODEC_ID_WMV3,
05757     .priv_data_size = sizeof(VC1Context),
05758     .init           = vc1_decode_init,
05759     .close          = vc1_decode_end,
05760     .decode         = vc1_decode_frame,
05761     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05762     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
05763     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
05764     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05765 };
05766 #endif
05767 
05768 #if CONFIG_VC1_VDPAU_DECODER
05769 AVCodec ff_vc1_vdpau_decoder = {
05770     .name           = "vc1_vdpau",
05771     .type           = AVMEDIA_TYPE_VIDEO,
05772     .id             = CODEC_ID_VC1,
05773     .priv_data_size = sizeof(VC1Context),
05774     .init           = vc1_decode_init,
05775     .close          = vc1_decode_end,
05776     .decode         = vc1_decode_frame,
05777     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
05778     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
05779     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
05780     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
05781 };
05782 #endif
05783 
05784 #if CONFIG_WMV3IMAGE_DECODER
05785 AVCodec ff_wmv3image_decoder = {
05786     .name           = "wmv3image",
05787     .type           = AVMEDIA_TYPE_VIDEO,
05788     .id             = CODEC_ID_WMV3IMAGE,
05789     .priv_data_size = sizeof(VC1Context),
05790     .init           = vc1_decode_init,
05791     .close          = vc1_decode_end,
05792     .decode         = vc1_decode_frame,
05793     .capabilities   = CODEC_CAP_DR1,
05794     .flush          = vc1_sprite_flush,
05795     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
05796     .pix_fmts       = ff_pixfmt_list_420
05797 };
05798 #endif
05799 
05800 #if CONFIG_VC1IMAGE_DECODER
05801 AVCodec ff_vc1image_decoder = {
05802     .name           = "vc1image",
05803     .type           = AVMEDIA_TYPE_VIDEO,
05804     .id             = CODEC_ID_VC1IMAGE,
05805     .priv_data_size = sizeof(VC1Context),
05806     .init           = vc1_decode_init,
05807     .close          = vc1_decode_end,
05808     .decode         = vc1_decode_frame,
05809     .capabilities   = CODEC_CAP_DR1,
05810     .flush          = vc1_sprite_flush,
05811     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
05812     .pix_fmts       = ff_pixfmt_list_420
05813 };
05814 #endif