ebb13c351cdc55ba4b44a028905a58798f2c274f
[ffmpeg.git] / libavcodec / vc1dec.c
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * VC-1 and WMV3 decoder
27  */
28
29 #include "internal.h"
30 #include "avcodec.h"
31 #include "error_resilience.h"
32 #include "mpegvideo.h"
33 #include "h263.h"
34 #include "h264chroma.h"
35 #include "vc1.h"
36 #include "vc1data.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.h"
39 #include "unary.h"
40 #include "mathops.h"
41 #include "vdpau_internal.h"
42 #include "libavutil/avassert.h"
43
44 #undef NDEBUG
45 #include <assert.h>
46
47 #define MB_INTRA_VLC_BITS 9
48 #define DC_VLC_BITS 9
49
50
51 // offset tables for interlaced picture MVDATA decoding
52 static const int offset_table1[9] = {  0,  1,  2,  4,  8, 16, 32,  64, 128 };
53 static const int offset_table2[9] = {  0,  1,  3,  7, 15, 31, 63, 127, 255 };
54
55 /***********************************************************************/
56 /**
57  * @name VC-1 Bitplane decoding
58  * @see 8.7, p56
59  * @{
60  */
61
62 /**
63  * Imode types
64  * @{
65  */
66 enum Imode {
67     IMODE_RAW,
68     IMODE_NORM2,
69     IMODE_DIFF2,
70     IMODE_NORM6,
71     IMODE_DIFF6,
72     IMODE_ROWSKIP,
73     IMODE_COLSKIP
74 };
75 /** @} */ //imode defines
76
77 static void init_block_index(VC1Context *v)
78 {
79     MpegEncContext *s = &v->s;
80     ff_init_block_index(s);
81     if (v->field_mode && v->second_field) {
82         s->dest[0] += s->current_picture_ptr->f.linesize[0];
83         s->dest[1] += s->current_picture_ptr->f.linesize[1];
84         s->dest[2] += s->current_picture_ptr->f.linesize[2];
85     }
86 }
87
88
89 /** @} */ //Bitplane group
90
91 static void vc1_put_signed_blocks_clamped(VC1Context *v)
92 {
93     MpegEncContext *s = &v->s;
94     int topleft_mb_pos, top_mb_pos;
95     int stride_y, fieldtx = 0;
96     int v_dist;
97
98     /* The put pixels loop is always one MB row behind the decoding loop,
99      * because we can only put pixels when overlap filtering is done, and
100      * for filtering of the bottom edge of a MB, we need the next MB row
101      * present as well.
102      * Within the row, the put pixels loop is also one MB col behind the
103      * decoding loop. The reason for this is again, because for filtering
104      * of the right MB edge, we need the next MB present. */
105     if (!s->first_slice_line) {
106         if (s->mb_x) {
107             topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
108             if (v->fcm == ILACE_FRAME)
109                 fieldtx = v->fieldtx_plane[topleft_mb_pos];
110             stride_y       = s->linesize << fieldtx;
111             v_dist         = (16 - fieldtx) >> (fieldtx == 0);
112             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
113                                              s->dest[0] - 16 * s->linesize - 16,
114                                              stride_y);
115             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
116                                              s->dest[0] - 16 * s->linesize - 8,
117                                              stride_y);
118             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
119                                              s->dest[0] - v_dist * s->linesize - 16,
120                                              stride_y);
121             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
122                                              s->dest[0] - v_dist * s->linesize - 8,
123                                              stride_y);
124             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
125                                              s->dest[1] - 8 * s->uvlinesize - 8,
126                                              s->uvlinesize);
127             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
128                                              s->dest[2] - 8 * s->uvlinesize - 8,
129                                              s->uvlinesize);
130         }
131         if (s->mb_x == s->mb_width - 1) {
132             top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
133             if (v->fcm == ILACE_FRAME)
134                 fieldtx = v->fieldtx_plane[top_mb_pos];
135             stride_y   = s->linesize << fieldtx;
136             v_dist     = fieldtx ? 15 : 8;
137             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
138                                              s->dest[0] - 16 * s->linesize,
139                                              stride_y);
140             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
141                                              s->dest[0] - 16 * s->linesize + 8,
142                                              stride_y);
143             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
144                                              s->dest[0] - v_dist * s->linesize,
145                                              stride_y);
146             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
147                                              s->dest[0] - v_dist * s->linesize + 8,
148                                              stride_y);
149             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
150                                              s->dest[1] - 8 * s->uvlinesize,
151                                              s->uvlinesize);
152             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
153                                              s->dest[2] - 8 * s->uvlinesize,
154                                              s->uvlinesize);
155         }
156     }
157
158 #define inc_blk_idx(idx) do { \
159         idx++; \
160         if (idx >= v->n_allocated_blks) \
161             idx = 0; \
162     } while (0)
163
164     inc_blk_idx(v->topleft_blk_idx);
165     inc_blk_idx(v->top_blk_idx);
166     inc_blk_idx(v->left_blk_idx);
167     inc_blk_idx(v->cur_blk_idx);
168 }
169
170 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
171 {
172     MpegEncContext *s = &v->s;
173     int j;
174     if (!s->first_slice_line) {
175         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
176         if (s->mb_x)
177             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
178         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
179         for (j = 0; j < 2; j++) {
180             v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
181             if (s->mb_x)
182                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
183         }
184     }
185     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
186
187     if (s->mb_y == s->end_mb_y - 1) {
188         if (s->mb_x) {
189             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
190             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
191             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
192         }
193         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
194     }
195 }
196
197 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
198 {
199     MpegEncContext *s = &v->s;
200     int j;
201
202     /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
203      * means it runs two rows/cols behind the decoding loop. */
204     if (!s->first_slice_line) {
205         if (s->mb_x) {
206             if (s->mb_y >= s->start_mb_y + 2) {
207                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
208
209                 if (s->mb_x >= 2)
210                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
211                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
212                 for (j = 0; j < 2; j++) {
213                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
214                     if (s->mb_x >= 2) {
215                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
216                     }
217                 }
218             }
219             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
220         }
221
222         if (s->mb_x == s->mb_width - 1) {
223             if (s->mb_y >= s->start_mb_y + 2) {
224                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
225
226                 if (s->mb_x)
227                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
228                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
229                 for (j = 0; j < 2; j++) {
230                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
231                     if (s->mb_x >= 2) {
232                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
233                     }
234                 }
235             }
236             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
237         }
238
239         if (s->mb_y == s->end_mb_y) {
240             if (s->mb_x) {
241                 if (s->mb_x >= 2)
242                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
243                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
244                 if (s->mb_x >= 2) {
245                     for (j = 0; j < 2; j++) {
246                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
247                     }
248                 }
249             }
250
251             if (s->mb_x == s->mb_width - 1) {
252                 if (s->mb_x)
253                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
254                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
255                 if (s->mb_x) {
256                     for (j = 0; j < 2; j++) {
257                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
258                     }
259                 }
260             }
261         }
262     }
263 }
264
265 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
266 {
267     MpegEncContext *s = &v->s;
268     int mb_pos;
269
270     if (v->condover == CONDOVER_NONE)
271         return;
272
273     mb_pos = s->mb_x + s->mb_y * s->mb_stride;
274
275     /* Within a MB, the horizontal overlap always runs before the vertical.
276      * To accomplish that, we run the H on left and internal borders of the
277      * currently decoded MB. Then, we wait for the next overlap iteration
278      * to do H overlap on the right edge of this MB, before moving over and
279      * running the V overlap. Therefore, the V overlap makes us trail by one
280      * MB col and the H overlap filter makes us trail by one MB row. This
281      * is reflected in the time at which we run the put_pixels loop. */
282     if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
283         if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
284                         v->over_flags_plane[mb_pos - 1])) {
285             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
286                                       v->block[v->cur_blk_idx][0]);
287             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
288                                       v->block[v->cur_blk_idx][2]);
289             if (!(s->flags & CODEC_FLAG_GRAY)) {
290                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
291                                           v->block[v->cur_blk_idx][4]);
292                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
293                                           v->block[v->cur_blk_idx][5]);
294             }
295         }
296         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
297                                   v->block[v->cur_blk_idx][1]);
298         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
299                                   v->block[v->cur_blk_idx][3]);
300
301         if (s->mb_x == s->mb_width - 1) {
302             if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
303                                          v->over_flags_plane[mb_pos - s->mb_stride])) {
304                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
305                                           v->block[v->cur_blk_idx][0]);
306                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
307                                           v->block[v->cur_blk_idx][1]);
308                 if (!(s->flags & CODEC_FLAG_GRAY)) {
309                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
310                                               v->block[v->cur_blk_idx][4]);
311                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
312                                               v->block[v->cur_blk_idx][5]);
313                 }
314             }
315             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
316                                       v->block[v->cur_blk_idx][2]);
317             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
318                                       v->block[v->cur_blk_idx][3]);
319         }
320     }
321     if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
322         if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
323                                      v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
324             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
325                                       v->block[v->left_blk_idx][0]);
326             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
327                                       v->block[v->left_blk_idx][1]);
328             if (!(s->flags & CODEC_FLAG_GRAY)) {
329                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
330                                           v->block[v->left_blk_idx][4]);
331                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
332                                           v->block[v->left_blk_idx][5]);
333             }
334         }
335         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
336                                   v->block[v->left_blk_idx][2]);
337         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
338                                   v->block[v->left_blk_idx][3]);
339     }
340 }
341
342 /** Do motion compensation over 1 macroblock
343  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
344  */
345 static void vc1_mc_1mv(VC1Context *v, int dir)
346 {
347     MpegEncContext *s = &v->s;
348     H264ChromaContext *h264chroma = &v->h264chroma;
349     uint8_t *srcY, *srcU, *srcV;
350     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
351     int off, off_uv;
352     int v_edge_pos = s->v_edge_pos >> v->field_mode;
353
354     if ((!v->field_mode ||
355          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
356         !v->s.last_picture.f.data[0])
357         return;
358
359     mx = s->mv[dir][0][0];
360     my = s->mv[dir][0][1];
361
362     // store motion vectors for further use in B frames
363     if (s->pict_type == AV_PICTURE_TYPE_P) {
364         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
365         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
366     }
367
368     uvmx = (mx + ((mx & 3) == 3)) >> 1;
369     uvmy = (my + ((my & 3) == 3)) >> 1;
370     v->luma_mv[s->mb_x][0] = uvmx;
371     v->luma_mv[s->mb_x][1] = uvmy;
372
373     if (v->field_mode &&
374         v->cur_field_type != v->ref_field_type[dir]) {
375         my   = my   - 2 + 4 * v->cur_field_type;
376         uvmy = uvmy - 2 + 4 * v->cur_field_type;
377     }
378
379     // fastuvmc shall be ignored for interlaced frame picture
380     if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
381         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
382         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
383     }
384     if (v->field_mode) { // interlaced field picture
385         if (!dir) {
386             if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
387                 srcY = s->current_picture.f.data[0];
388                 srcU = s->current_picture.f.data[1];
389                 srcV = s->current_picture.f.data[2];
390             } else {
391                 srcY = s->last_picture.f.data[0];
392                 srcU = s->last_picture.f.data[1];
393                 srcV = s->last_picture.f.data[2];
394             }
395         } else {
396             srcY = s->next_picture.f.data[0];
397             srcU = s->next_picture.f.data[1];
398             srcV = s->next_picture.f.data[2];
399         }
400     } else {
401         if (!dir) {
402             srcY = s->last_picture.f.data[0];
403             srcU = s->last_picture.f.data[1];
404             srcV = s->last_picture.f.data[2];
405         } else {
406             srcY = s->next_picture.f.data[0];
407             srcU = s->next_picture.f.data[1];
408             srcV = s->next_picture.f.data[2];
409         }
410     }
411
412     if(!srcY)
413         return;
414
415     src_x   = s->mb_x * 16 + (mx   >> 2);
416     src_y   = s->mb_y * 16 + (my   >> 2);
417     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
418     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
419
420     if (v->profile != PROFILE_ADVANCED) {
421         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
422         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
423         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
424         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
425     } else {
426         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
427         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
428         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
429         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
430     }
431
432     srcY += src_y   * s->linesize   + src_x;
433     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
434     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
435
436     if (v->field_mode && v->ref_field_type[dir]) {
437         srcY += s->current_picture_ptr->f.linesize[0];
438         srcU += s->current_picture_ptr->f.linesize[1];
439         srcV += s->current_picture_ptr->f.linesize[2];
440     }
441
442     /* for grayscale we should not try to read from unknown area */
443     if (s->flags & CODEC_FLAG_GRAY) {
444         srcU = s->edge_emu_buffer + 18 * s->linesize;
445         srcV = s->edge_emu_buffer + 18 * s->linesize;
446     }
447
448     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
449         || s->h_edge_pos < 22 || v_edge_pos < 22
450         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
451         || (unsigned)(src_y - 1)        > v_edge_pos    - (my&3) - 16 - 3) {
452         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
453
454         srcY -= s->mspel * (1 + s->linesize);
455         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
456                                  17 + s->mspel * 2, 17 + s->mspel * 2,
457                                  src_x - s->mspel, src_y - s->mspel,
458                                  s->h_edge_pos, v_edge_pos);
459         srcY = s->edge_emu_buffer;
460         s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
461                                  uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
462         s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
463                                  uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
464         srcU = uvbuf;
465         srcV = uvbuf + 16;
466         /* if we deal with range reduction we need to scale source blocks */
467         if (v->rangeredfrm) {
468             int i, j;
469             uint8_t *src, *src2;
470
471             src = srcY;
472             for (j = 0; j < 17 + s->mspel * 2; j++) {
473                 for (i = 0; i < 17 + s->mspel * 2; i++)
474                     src[i] = ((src[i] - 128) >> 1) + 128;
475                 src += s->linesize;
476             }
477             src  = srcU;
478             src2 = srcV;
479             for (j = 0; j < 9; j++) {
480                 for (i = 0; i < 9; i++) {
481                     src[i]  = ((src[i]  - 128) >> 1) + 128;
482                     src2[i] = ((src2[i] - 128) >> 1) + 128;
483                 }
484                 src  += s->uvlinesize;
485                 src2 += s->uvlinesize;
486             }
487         }
488         /* if we deal with intensity compensation we need to scale source blocks */
489         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
490             int i, j;
491             uint8_t *src, *src2;
492
493             src = srcY;
494             for (j = 0; j < 17 + s->mspel * 2; j++) {
495                 for (i = 0; i < 17 + s->mspel * 2; i++)
496                     src[i] = v->luty[src[i]];
497                 src += s->linesize;
498             }
499             src  = srcU;
500             src2 = srcV;
501             for (j = 0; j < 9; j++) {
502                 for (i = 0; i < 9; i++) {
503                     src[i]  = v->lutuv[src[i]];
504                     src2[i] = v->lutuv[src2[i]];
505                 }
506                 src  += s->uvlinesize;
507                 src2 += s->uvlinesize;
508             }
509         }
510         srcY += s->mspel * (1 + s->linesize);
511     }
512
513         off    = 0;
514         off_uv = 0;
515     if (s->mspel) {
516         dxy = ((my & 3) << 2) | (mx & 3);
517         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
518         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
519         srcY += s->linesize * 8;
520         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
521         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
522     } else { // hpel mc - always used for luma
523         dxy = (my & 2) | ((mx & 2) >> 1);
524         if (!v->rnd)
525             s->hdsp.put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
526         else
527             s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
528     }
529
530     if (s->flags & CODEC_FLAG_GRAY) return;
531     /* Chroma MC always uses qpel bilinear */
532     uvmx = (uvmx & 3) << 1;
533     uvmy = (uvmy & 3) << 1;
534     if (!v->rnd) {
535         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
536         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
537     } else {
538         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
539         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
540     }
541 }
542
543 static inline int median4(int a, int b, int c, int d)
544 {
545     if (a < b) {
546         if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
547         else       return (FFMIN(b, c) + FFMAX(a, d)) / 2;
548     } else {
549         if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
550         else       return (FFMIN(a, c) + FFMAX(b, d)) / 2;
551     }
552 }
553
554 /** Do motion compensation for 4-MV macroblock - luminance block
555  */
556 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
557 {
558     MpegEncContext *s = &v->s;
559     uint8_t *srcY;
560     int dxy, mx, my, src_x, src_y;
561     int off;
562     int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
563     int v_edge_pos = s->v_edge_pos >> v->field_mode;
564
565     if ((!v->field_mode ||
566          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
567         !v->s.last_picture.f.data[0])
568         return;
569
570     mx = s->mv[dir][n][0];
571     my = s->mv[dir][n][1];
572
573     if (!dir) {
574         if (v->field_mode) {
575             if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
576                 srcY = s->current_picture.f.data[0];
577             else
578                 srcY = s->last_picture.f.data[0];
579         } else
580             srcY = s->last_picture.f.data[0];
581     } else
582         srcY = s->next_picture.f.data[0];
583
584     if(!srcY)
585         return;
586
587     if (v->field_mode) {
588         if (v->cur_field_type != v->ref_field_type[dir])
589             my = my - 2 + 4 * v->cur_field_type;
590     }
591
592     if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
593         int same_count = 0, opp_count = 0, k;
594         int chosen_mv[2][4][2], f;
595         int tx, ty;
596         for (k = 0; k < 4; k++) {
597             f = v->mv_f[0][s->block_index[k] + v->blocks_off];
598             chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
599             chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
600             opp_count  += f;
601             same_count += 1 - f;
602         }
603         f = opp_count > same_count;
604         switch (f ? opp_count : same_count) {
605         case 4:
606             tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
607                          chosen_mv[f][2][0], chosen_mv[f][3][0]);
608             ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
609                          chosen_mv[f][2][1], chosen_mv[f][3][1]);
610             break;
611         case 3:
612             tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
613             ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
614             break;
615         case 2:
616             tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
617             ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
618             break;
619         default:
620             av_assert2(0);
621         }
622         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
623         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
624         for (k = 0; k < 4; k++)
625             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
626     }
627
628     if (v->fcm == ILACE_FRAME) {  // not sure if needed for other types of picture
629         int qx, qy;
630         int width  = s->avctx->coded_width;
631         int height = s->avctx->coded_height >> 1;
632         qx = (s->mb_x * 16) + (mx >> 2);
633         qy = (s->mb_y *  8) + (my >> 3);
634
635         if (qx < -17)
636             mx -= 4 * (qx + 17);
637         else if (qx > width)
638             mx -= 4 * (qx - width);
639         if (qy < -18)
640             my -= 8 * (qy + 18);
641         else if (qy > height + 1)
642             my -= 8 * (qy - height - 1);
643     }
644
645     if ((v->fcm == ILACE_FRAME) && fieldmv)
646         off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
647     else
648         off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
649
650     src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
651     if (!fieldmv)
652         src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
653     else
654         src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
655
656     if (v->profile != PROFILE_ADVANCED) {
657         src_x = av_clip(src_x, -16, s->mb_width  * 16);
658         src_y = av_clip(src_y, -16, s->mb_height * 16);
659     } else {
660         src_x = av_clip(src_x, -17, s->avctx->coded_width);
661         if (v->fcm == ILACE_FRAME) {
662             if (src_y & 1)
663                 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
664             else
665                 src_y = av_clip(src_y, -18, s->avctx->coded_height);
666         } else {
667             src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
668         }
669     }
670
671     srcY += src_y * s->linesize + src_x;
672     if (v->field_mode && v->ref_field_type[dir])
673         srcY += s->current_picture_ptr->f.linesize[0];
674
675     if (fieldmv && !(src_y & 1))
676         v_edge_pos--;
677     if (fieldmv && (src_y & 1) && src_y < 4)
678         src_y--;
679     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
680         || s->h_edge_pos < 13 || v_edge_pos < 23
681         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
682         || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
683         srcY -= s->mspel * (1 + (s->linesize << fieldmv));
684         /* check emulate edge stride and offset */
685         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
686                                  9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
687                                  src_x - s->mspel, src_y - (s->mspel << fieldmv),
688                                  s->h_edge_pos, v_edge_pos);
689         srcY = s->edge_emu_buffer;
690         /* if we deal with range reduction we need to scale source blocks */
691         if (v->rangeredfrm) {
692             int i, j;
693             uint8_t *src;
694
695             src = srcY;
696             for (j = 0; j < 9 + s->mspel * 2; j++) {
697                 for (i = 0; i < 9 + s->mspel * 2; i++)
698                     src[i] = ((src[i] - 128) >> 1) + 128;
699                 src += s->linesize << fieldmv;
700             }
701         }
702         /* if we deal with intensity compensation we need to scale source blocks */
703         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
704             int i, j;
705             uint8_t *src;
706
707             src = srcY;
708             for (j = 0; j < 9 + s->mspel * 2; j++) {
709                 for (i = 0; i < 9 + s->mspel * 2; i++)
710                     src[i] = v->luty[src[i]];
711                 src += s->linesize << fieldmv;
712             }
713         }
714         srcY += s->mspel * (1 + (s->linesize << fieldmv));
715     }
716
717     if (s->mspel) {
718         dxy = ((my & 3) << 2) | (mx & 3);
719         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
720     } else { // hpel mc - always used for luma
721         dxy = (my & 2) | ((mx & 2) >> 1);
722         if (!v->rnd)
723             s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
724         else
725             s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
726     }
727 }
728
729 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
730 {
731     int idx, i;
732     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
733
734     idx =  ((a[3] != flag) << 3)
735          | ((a[2] != flag) << 2)
736          | ((a[1] != flag) << 1)
737          |  (a[0] != flag);
738     if (!idx) {
739         *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
740         *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
741         return 4;
742     } else if (count[idx] == 1) {
743         switch (idx) {
744         case 0x1:
745             *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
746             *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
747             return 3;
748         case 0x2:
749             *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
750             *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
751             return 3;
752         case 0x4:
753             *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
754             *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
755             return 3;
756         case 0x8:
757             *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
758             *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
759             return 3;
760         }
761     } else if (count[idx] == 2) {
762         int t1 = 0, t2 = 0;
763         for (i = 0; i < 3; i++)
764             if (!a[i]) {
765                 t1 = i;
766                 break;
767             }
768         for (i = t1 + 1; i < 4; i++)
769             if (!a[i]) {
770                 t2 = i;
771                 break;
772             }
773         *tx = (mvx[t1] + mvx[t2]) / 2;
774         *ty = (mvy[t1] + mvy[t2]) / 2;
775         return 2;
776     } else {
777         return 0;
778     }
779     return -1;
780 }
781
782 /** Do motion compensation for 4-MV macroblock - both chroma blocks
783  */
784 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
785 {
786     MpegEncContext *s = &v->s;
787     H264ChromaContext *h264chroma = &v->h264chroma;
788     uint8_t *srcU, *srcV;
789     int uvmx, uvmy, uvsrc_x, uvsrc_y;
790     int k, tx = 0, ty = 0;
791     int mvx[4], mvy[4], intra[4], mv_f[4];
792     int valid_count;
793     int chroma_ref_type = v->cur_field_type, off = 0;
794     int v_edge_pos = s->v_edge_pos >> v->field_mode;
795
796     if (!v->field_mode && !v->s.last_picture.f.data[0])
797         return;
798     if (s->flags & CODEC_FLAG_GRAY)
799         return;
800
801     for (k = 0; k < 4; k++) {
802         mvx[k] = s->mv[dir][k][0];
803         mvy[k] = s->mv[dir][k][1];
804         intra[k] = v->mb_type[0][s->block_index[k]];
805         if (v->field_mode)
806             mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
807     }
808
809     /* calculate chroma MV vector from four luma MVs */
810     if (!v->field_mode || (v->field_mode && !v->numref)) {
811         valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
812         chroma_ref_type = v->reffield;
813         if (!valid_count) {
814             s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
815             s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
816             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
817             return; //no need to do MC for intra blocks
818         }
819     } else {
820         int dominant = 0;
821         if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
822             dominant = 1;
823         valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
824         if (dominant)
825             chroma_ref_type = !v->cur_field_type;
826     }
827     if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
828         return;
829     s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
830     s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
831     uvmx = (tx + ((tx & 3) == 3)) >> 1;
832     uvmy = (ty + ((ty & 3) == 3)) >> 1;
833
834     v->luma_mv[s->mb_x][0] = uvmx;
835     v->luma_mv[s->mb_x][1] = uvmy;
836
837     if (v->fastuvmc) {
838         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
839         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
840     }
841     // Field conversion bias
842     if (v->cur_field_type != chroma_ref_type)
843         uvmy += 2 - 4 * chroma_ref_type;
844
845     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
846     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
847
848     if (v->profile != PROFILE_ADVANCED) {
849         uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width  * 8);
850         uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
851     } else {
852         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
853         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
854     }
855
856     if (!dir) {
857         if (v->field_mode) {
858             if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
859                 srcU = s->current_picture.f.data[1];
860                 srcV = s->current_picture.f.data[2];
861             } else {
862                 srcU = s->last_picture.f.data[1];
863                 srcV = s->last_picture.f.data[2];
864             }
865         } else {
866             srcU = s->last_picture.f.data[1];
867             srcV = s->last_picture.f.data[2];
868         }
869     } else {
870         srcU = s->next_picture.f.data[1];
871         srcV = s->next_picture.f.data[2];
872     }
873
874     if(!srcU)
875         return;
876
877     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
878     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
879
880     if (v->field_mode) {
881         if (chroma_ref_type) {
882             srcU += s->current_picture_ptr->f.linesize[1];
883             srcV += s->current_picture_ptr->f.linesize[2];
884         }
885         off = 0;
886     }
887
888     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
889         || s->h_edge_pos < 18 || v_edge_pos < 18
890         || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
891         || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {
892         s->vdsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,
893                                  8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
894                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
895         s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
896                                  8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
897                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
898         srcU = s->edge_emu_buffer;
899         srcV = s->edge_emu_buffer + 16;
900
901         /* if we deal with range reduction we need to scale source blocks */
902         if (v->rangeredfrm) {
903             int i, j;
904             uint8_t *src, *src2;
905
906             src  = srcU;
907             src2 = srcV;
908             for (j = 0; j < 9; j++) {
909                 for (i = 0; i < 9; i++) {
910                     src[i]  = ((src[i]  - 128) >> 1) + 128;
911                     src2[i] = ((src2[i] - 128) >> 1) + 128;
912                 }
913                 src  += s->uvlinesize;
914                 src2 += s->uvlinesize;
915             }
916         }
917         /* if we deal with intensity compensation we need to scale source blocks */
918         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
919             int i, j;
920             uint8_t *src, *src2;
921
922             src  = srcU;
923             src2 = srcV;
924             for (j = 0; j < 9; j++) {
925                 for (i = 0; i < 9; i++) {
926                     src[i]  = v->lutuv[src[i]];
927                     src2[i] = v->lutuv[src2[i]];
928                 }
929                 src  += s->uvlinesize;
930                 src2 += s->uvlinesize;
931             }
932         }
933     }
934
935     /* Chroma MC always uses qpel bilinear */
936     uvmx = (uvmx & 3) << 1;
937     uvmy = (uvmy & 3) << 1;
938     if (!v->rnd) {
939         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
940         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
941     } else {
942         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
943         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
944     }
945 }
946
947 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
948  */
949 static void vc1_mc_4mv_chroma4(VC1Context *v)
950 {
951     MpegEncContext *s = &v->s;
952     H264ChromaContext *h264chroma = &v->h264chroma;
953     uint8_t *srcU, *srcV;
954     int uvsrc_x, uvsrc_y;
955     int uvmx_field[4], uvmy_field[4];
956     int i, off, tx, ty;
957     int fieldmv = v->blk_mv_type[s->block_index[0]];
958     static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
959     int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
960     int v_edge_pos = s->v_edge_pos >> 1;
961
962     if (!v->s.last_picture.f.data[0])
963         return;
964     if (s->flags & CODEC_FLAG_GRAY)
965         return;
966
967     for (i = 0; i < 4; i++) {
968         tx = s->mv[0][i][0];
969         uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
970         ty = s->mv[0][i][1];
971         if (fieldmv)
972             uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
973         else
974             uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
975     }
976
977     for (i = 0; i < 4; i++) {
978         off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
979         uvsrc_x = s->mb_x * 8 +  (i & 1) * 4           + (uvmx_field[i] >> 2);
980         uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
981         // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
982         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
983         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
984         srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
985         srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
986         uvmx_field[i] = (uvmx_field[i] & 3) << 1;
987         uvmy_field[i] = (uvmy_field[i] & 3) << 1;
988
989         if (fieldmv && !(uvsrc_y & 1))
990             v_edge_pos = (s->v_edge_pos >> 1) - 1;
991
992         if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
993             uvsrc_y--;
994         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
995             || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
996             || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
997             || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
998             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
999                                      5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1000                                      s->h_edge_pos >> 1, v_edge_pos);
1001             s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
1002                                      5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1003                                      s->h_edge_pos >> 1, v_edge_pos);
1004             srcU = s->edge_emu_buffer;
1005             srcV = s->edge_emu_buffer + 16;
1006
1007             /* if we deal with intensity compensation we need to scale source blocks */
1008             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1009                 int i, j;
1010                 uint8_t *src, *src2;
1011
1012                 src  = srcU;
1013                 src2 = srcV;
1014                 for (j = 0; j < 5; j++) {
1015                     for (i = 0; i < 5; i++) {
1016                         src[i]  = v->lutuv[src[i]];
1017                         src2[i] = v->lutuv[src2[i]];
1018                     }
1019                     src  += s->uvlinesize << 1;
1020                     src2 += s->uvlinesize << 1;
1021                 }
1022             }
1023         }
1024         if (!v->rnd) {
1025             h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1026             h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1027         } else {
1028             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]);
1029             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]);
1030         }
1031     }
1032 }
1033
1034 /***********************************************************************/
1035 /**
1036  * @name VC-1 Block-level functions
1037  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1038  * @{
1039  */
1040
1041 /**
1042  * @def GET_MQUANT
1043  * @brief Get macroblock-level quantizer scale
1044  */
1045 #define GET_MQUANT()                                           \
1046     if (v->dquantfrm) {                                        \
1047         int edges = 0;                                         \
1048         if (v->dqprofile == DQPROFILE_ALL_MBS) {               \
1049             if (v->dqbilevel) {                                \
1050                 mquant = (get_bits1(gb)) ? v->altpq : v->pq;   \
1051             } else {                                           \
1052                 mqdiff = get_bits(gb, 3);                      \
1053                 if (mqdiff != 7)                               \
1054                     mquant = v->pq + mqdiff;                   \
1055                 else                                           \
1056                     mquant = get_bits(gb, 5);                  \
1057             }                                                  \
1058         }                                                      \
1059         if (v->dqprofile == DQPROFILE_SINGLE_EDGE)             \
1060             edges = 1 << v->dqsbedge;                          \
1061         else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES)       \
1062             edges = (3 << v->dqsbedge) % 15;                   \
1063         else if (v->dqprofile == DQPROFILE_FOUR_EDGES)         \
1064             edges = 15;                                        \
1065         if ((edges&1) && !s->mb_x)                             \
1066             mquant = v->altpq;                                 \
1067         if ((edges&2) && s->first_slice_line)                  \
1068             mquant = v->altpq;                                 \
1069         if ((edges&4) && s->mb_x == (s->mb_width - 1))         \
1070             mquant = v->altpq;                                 \
1071         if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
1072             mquant = v->altpq;                                 \
1073         if (!mquant || mquant > 31) {                          \
1074             av_log(v->s.avctx, AV_LOG_ERROR,                   \
1075                    "Overriding invalid mquant %d\n", mquant);  \
1076             mquant = 1;                                        \
1077         }                                                      \
1078     }
1079
1080 /**
1081  * @def GET_MVDATA(_dmv_x, _dmv_y)
1082  * @brief Get MV differentials
1083  * @see MVDATA decoding from 8.3.5.2, p(1)20
1084  * @param _dmv_x Horizontal differential for decoded MV
1085  * @param _dmv_y Vertical differential for decoded MV
1086  */
1087 #define GET_MVDATA(_dmv_x, _dmv_y)                                      \
1088     index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1089                          VC1_MV_DIFF_VLC_BITS, 2);                      \
1090     if (index > 36) {                                                   \
1091         mb_has_coeffs = 1;                                              \
1092         index -= 37;                                                    \
1093     } else                                                              \
1094         mb_has_coeffs = 0;                                              \
1095     s->mb_intra = 0;                                                    \
1096     if (!index) {                                                       \
1097         _dmv_x = _dmv_y = 0;                                            \
1098     } else if (index == 35) {                                           \
1099         _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1100         _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1101     } else if (index == 36) {                                           \
1102         _dmv_x = 0;                                                     \
1103         _dmv_y = 0;                                                     \
1104         s->mb_intra = 1;                                                \
1105     } else {                                                            \
1106         index1 = index % 6;                                             \
1107         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1108         else                                   val = 0;                 \
1109         if (size_table[index1] - val > 0)                               \
1110             val = get_bits(gb, size_table[index1] - val);               \
1111         else                                   val = 0;                 \
1112         sign = 0 - (val&1);                                             \
1113         _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1114                                                                         \
1115         index1 = index / 6;                                             \
1116         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1117         else                                   val = 0;                 \
1118         if (size_table[index1] - val > 0)                               \
1119             val = get_bits(gb, size_table[index1] - val);               \
1120         else                                   val = 0;                 \
1121         sign = 0 - (val & 1);                                           \
1122         _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign;   \
1123     }
1124
1125 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1126                                                    int *dmv_y, int *pred_flag)
1127 {
1128     int index, index1;
1129     int extend_x = 0, extend_y = 0;
1130     GetBitContext *gb = &v->s.gb;
1131     int bits, esc;
1132     int val, sign;
1133     const int* offs_tab;
1134
1135     if (v->numref) {
1136         bits = VC1_2REF_MVDATA_VLC_BITS;
1137         esc  = 125;
1138     } else {
1139         bits = VC1_1REF_MVDATA_VLC_BITS;
1140         esc  = 71;
1141     }
1142     switch (v->dmvrange) {
1143     case 1:
1144         extend_x = 1;
1145         break;
1146     case 2:
1147         extend_y = 1;
1148         break;
1149     case 3:
1150         extend_x = extend_y = 1;
1151         break;
1152     }
1153     index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1154     if (index == esc) {
1155         *dmv_x = get_bits(gb, v->k_x);
1156         *dmv_y = get_bits(gb, v->k_y);
1157         if (v->numref) {
1158             if (pred_flag) {
1159                 *pred_flag = *dmv_y & 1;
1160                 *dmv_y     = (*dmv_y + *pred_flag) >> 1;
1161             } else {
1162                 *dmv_y     = (*dmv_y + (*dmv_y & 1)) >> 1;
1163             }
1164         }
1165     }
1166     else {
1167         av_assert0(index < esc);
1168         if (extend_x)
1169             offs_tab = offset_table2;
1170         else
1171             offs_tab = offset_table1;
1172         index1 = (index + 1) % 9;
1173         if (index1 != 0) {
1174             val    = get_bits(gb, index1 + extend_x);
1175             sign   = 0 -(val & 1);
1176             *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1177         } else
1178             *dmv_x = 0;
1179         if (extend_y)
1180             offs_tab = offset_table2;
1181         else
1182             offs_tab = offset_table1;
1183         index1 = (index + 1) / 9;
1184         if (index1 > v->numref) {
1185             val    = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1186             sign   = 0 - (val & 1);
1187             *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1188         } else
1189             *dmv_y = 0;
1190         if (v->numref && pred_flag)
1191             *pred_flag = index1 & 1;
1192     }
1193 }
1194
1195 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1196 {
1197     int scaledvalue, refdist;
1198     int scalesame1, scalesame2;
1199     int scalezone1_x, zone1offset_x;
1200     int table_index = dir ^ v->second_field;
1201
1202     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1203         refdist = v->refdist;
1204     else
1205         refdist = dir ? v->brfd : v->frfd;
1206     if (refdist > 3)
1207         refdist = 3;
1208     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1209     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1210     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1211     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1212
1213     if (FFABS(n) > 255)
1214         scaledvalue = n;
1215     else {
1216         if (FFABS(n) < scalezone1_x)
1217             scaledvalue = (n * scalesame1) >> 8;
1218         else {
1219             if (n < 0)
1220                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1221             else
1222                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1223         }
1224     }
1225     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1226 }
1227
1228 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1229 {
1230     int scaledvalue, refdist;
1231     int scalesame1, scalesame2;
1232     int scalezone1_y, zone1offset_y;
1233     int table_index = dir ^ v->second_field;
1234
1235     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1236         refdist = v->refdist;
1237     else
1238         refdist = dir ? v->brfd : v->frfd;
1239     if (refdist > 3)
1240         refdist = 3;
1241     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1242     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1243     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1244     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1245
1246     if (FFABS(n) > 63)
1247         scaledvalue = n;
1248     else {
1249         if (FFABS(n) < scalezone1_y)
1250             scaledvalue = (n * scalesame1) >> 8;
1251         else {
1252             if (n < 0)
1253                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1254             else
1255                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1256         }
1257     }
1258
1259     if (v->cur_field_type && !v->ref_field_type[dir])
1260         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1261     else
1262         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1263 }
1264
1265 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1266 {
1267     int scalezone1_x, zone1offset_x;
1268     int scaleopp1, scaleopp2, brfd;
1269     int scaledvalue;
1270
1271     brfd = FFMIN(v->brfd, 3);
1272     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
1273     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1274     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1275     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1276
1277     if (FFABS(n) > 255)
1278         scaledvalue = n;
1279     else {
1280         if (FFABS(n) < scalezone1_x)
1281             scaledvalue = (n * scaleopp1) >> 8;
1282         else {
1283             if (n < 0)
1284                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1285             else
1286                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1287         }
1288     }
1289     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1290 }
1291
1292 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1293 {
1294     int scalezone1_y, zone1offset_y;
1295     int scaleopp1, scaleopp2, brfd;
1296     int scaledvalue;
1297
1298     brfd = FFMIN(v->brfd, 3);
1299     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
1300     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1301     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1302     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1303
1304     if (FFABS(n) > 63)
1305         scaledvalue = n;
1306     else {
1307         if (FFABS(n) < scalezone1_y)
1308             scaledvalue = (n * scaleopp1) >> 8;
1309         else {
1310             if (n < 0)
1311                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1312             else
1313                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1314         }
1315     }
1316     if (v->cur_field_type && !v->ref_field_type[dir]) {
1317         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1318     } else {
1319         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1320     }
1321 }
1322
1323 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1324                                          int dim, int dir)
1325 {
1326     int brfd, scalesame;
1327     int hpel = 1 - v->s.quarter_sample;
1328
1329     n >>= hpel;
1330     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1331         if (dim)
1332             n = scaleforsame_y(v, i, n, dir) << hpel;
1333         else
1334             n = scaleforsame_x(v, n, dir) << hpel;
1335         return n;
1336     }
1337     brfd      = FFMIN(v->brfd, 3);
1338     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1339
1340     n = (n * scalesame >> 8) << hpel;
1341     return n;
1342 }
1343
1344 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1345                                         int dim, int dir)
1346 {
1347     int refdist, scaleopp;
1348     int hpel = 1 - v->s.quarter_sample;
1349
1350     n >>= hpel;
1351     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1352         if (dim)
1353             n = scaleforopp_y(v, n, dir) << hpel;
1354         else
1355             n = scaleforopp_x(v, n) << hpel;
1356         return n;
1357     }
1358     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1359         refdist = FFMIN(v->refdist, 3);
1360     else
1361         refdist = dir ? v->brfd : v->frfd;
1362     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1363
1364     n = (n * scaleopp >> 8) << hpel;
1365     return n;
1366 }
1367
1368 /** Predict and set motion vector
1369  */
1370 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1371                                int mv1, int r_x, int r_y, uint8_t* is_intra,
1372                                int pred_flag, int dir)
1373 {
1374     MpegEncContext *s = &v->s;
1375     int xy, wrap, off = 0;
1376     int16_t *A, *B, *C;
1377     int px, py;
1378     int sum;
1379     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1380     int opposite, a_f, b_f, c_f;
1381     int16_t field_predA[2];
1382     int16_t field_predB[2];
1383     int16_t field_predC[2];
1384     int a_valid, b_valid, c_valid;
1385     int hybridmv_thresh, y_bias = 0;
1386
1387     if (v->mv_mode == MV_PMODE_MIXED_MV ||
1388         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1389         mixedmv_pic = 1;
1390     else
1391         mixedmv_pic = 0;
1392     /* scale MV difference to be quad-pel */
1393     dmv_x <<= 1 - s->quarter_sample;
1394     dmv_y <<= 1 - s->quarter_sample;
1395
1396     wrap = s->b8_stride;
1397     xy   = s->block_index[n];
1398
1399     if (s->mb_intra) {
1400         s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1401         s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1402         s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1403         s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1404         if (mv1) { /* duplicate motion data for 1-MV block */
1405             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
1406             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
1407             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
1408             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
1409             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1410             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1411             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1412             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
1413             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
1414             s->current_picture.motion_val[1][xy + wrap][0]                     = 0;
1415             s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
1416             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1417             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1418         }
1419         return;
1420     }
1421
1422     C = s->current_picture.motion_val[dir][xy -    1 + v->blocks_off];
1423     A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1424     if (mv1) {
1425         if (v->field_mode && mixedmv_pic)
1426             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1427         else
1428             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1429     } else {
1430         //in 4-MV mode different blocks have different B predictor position
1431         switch (n) {
1432         case 0:
1433             off = (s->mb_x > 0) ? -1 : 1;
1434             break;
1435         case 1:
1436             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1437             break;
1438         case 2:
1439             off = 1;
1440             break;
1441         case 3:
1442             off = -1;
1443         }
1444     }
1445     B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1446
1447     a_valid = !s->first_slice_line || (n == 2 || n == 3);
1448     b_valid = a_valid && (s->mb_width > 1);
1449     c_valid = s->mb_x || (n == 1 || n == 3);
1450     if (v->field_mode) {
1451         a_valid = a_valid && !is_intra[xy - wrap];
1452         b_valid = b_valid && !is_intra[xy - wrap + off];
1453         c_valid = c_valid && !is_intra[xy - 1];
1454     }
1455
1456     if (a_valid) {
1457         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1458         num_oppfield  += a_f;
1459         num_samefield += 1 - a_f;
1460         field_predA[0] = A[0];
1461         field_predA[1] = A[1];
1462     } else {
1463         field_predA[0] = field_predA[1] = 0;
1464         a_f = 0;
1465     }
1466     if (b_valid) {
1467         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1468         num_oppfield  += b_f;
1469         num_samefield += 1 - b_f;
1470         field_predB[0] = B[0];
1471         field_predB[1] = B[1];
1472     } else {
1473         field_predB[0] = field_predB[1] = 0;
1474         b_f = 0;
1475     }
1476     if (c_valid) {
1477         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1478         num_oppfield  += c_f;
1479         num_samefield += 1 - c_f;
1480         field_predC[0] = C[0];
1481         field_predC[1] = C[1];
1482     } else {
1483         field_predC[0] = field_predC[1] = 0;
1484         c_f = 0;
1485     }
1486
1487     if (v->field_mode) {
1488         if (!v->numref)
1489             // REFFIELD determines if the last field or the second-last field is
1490             // to be used as reference
1491             opposite = 1 - v->reffield;
1492         else {
1493             if (num_samefield <= num_oppfield)
1494                 opposite = 1 - pred_flag;
1495             else
1496                 opposite = pred_flag;
1497         }
1498     } else
1499         opposite = 0;
1500     if (opposite) {
1501         if (a_valid && !a_f) {
1502             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1503             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1504         }
1505         if (b_valid && !b_f) {
1506             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1507             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1508         }
1509         if (c_valid && !c_f) {
1510             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1511             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1512         }
1513         v->mv_f[dir][xy + v->blocks_off] = 1;
1514         v->ref_field_type[dir] = !v->cur_field_type;
1515     } else {
1516         if (a_valid && a_f) {
1517             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1518             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1519         }
1520         if (b_valid && b_f) {
1521             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1522             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1523         }
1524         if (c_valid && c_f) {
1525             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1526             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1527         }
1528         v->mv_f[dir][xy + v->blocks_off] = 0;
1529         v->ref_field_type[dir] = v->cur_field_type;
1530     }
1531
1532     if (a_valid) {
1533         px = field_predA[0];
1534         py = field_predA[1];
1535     } else if (c_valid) {
1536         px = field_predC[0];
1537         py = field_predC[1];
1538     } else if (b_valid) {
1539         px = field_predB[0];
1540         py = field_predB[1];
1541     } else {
1542         px = 0;
1543         py = 0;
1544     }
1545
1546     if (num_samefield + num_oppfield > 1) {
1547         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1548         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1549     }
1550
1551     /* Pullback MV as specified in 8.3.5.3.4 */
1552     if (!v->field_mode) {
1553         int qx, qy, X, Y;
1554         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1555         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1556         X  = (s->mb_width  << 6) - 4;
1557         Y  = (s->mb_height << 6) - 4;
1558         if (mv1) {
1559             if (qx + px < -60) px = -60 - qx;
1560             if (qy + py < -60) py = -60 - qy;
1561         } else {
1562             if (qx + px < -28) px = -28 - qx;
1563             if (qy + py < -28) py = -28 - qy;
1564         }
1565         if (qx + px > X) px = X - qx;
1566         if (qy + py > Y) py = Y - qy;
1567     }
1568
1569     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1570         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1571         hybridmv_thresh = 32;
1572         if (a_valid && c_valid) {
1573             if (is_intra[xy - wrap])
1574                 sum = FFABS(px) + FFABS(py);
1575             else
1576                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1577             if (sum > hybridmv_thresh) {
1578                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
1579                     px = field_predA[0];
1580                     py = field_predA[1];
1581                 } else {
1582                     px = field_predC[0];
1583                     py = field_predC[1];
1584                 }
1585             } else {
1586                 if (is_intra[xy - 1])
1587                     sum = FFABS(px) + FFABS(py);
1588                 else
1589                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1590                 if (sum > hybridmv_thresh) {
1591                     if (get_bits1(&s->gb)) {
1592                         px = field_predA[0];
1593                         py = field_predA[1];
1594                     } else {
1595                         px = field_predC[0];
1596                         py = field_predC[1];
1597                     }
1598                 }
1599             }
1600         }
1601     }
1602
1603     if (v->field_mode && v->numref)
1604         r_y >>= 1;
1605     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1606         y_bias = 1;
1607     /* store MV using signed modulus of MV range defined in 4.11 */
1608     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1609     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1610     if (mv1) { /* duplicate motion data for 1-MV block */
1611         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1612         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1613         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1614         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1615         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1616         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1617         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
1618         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];
1619     }
1620 }
1621
1622 /** Predict and set motion vector for interlaced frame picture MBs
1623  */
1624 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1625                                      int mvn, int r_x, int r_y, uint8_t* is_intra)
1626 {
1627     MpegEncContext *s = &v->s;
1628     int xy, wrap, off = 0;
1629     int A[2], B[2], C[2];
1630     int px, py;
1631     int a_valid = 0, b_valid = 0, c_valid = 0;
1632     int field_a, field_b, field_c; // 0: same, 1: opposit
1633     int total_valid, num_samefield, num_oppfield;
1634     int pos_c, pos_b, n_adj;
1635
1636     wrap = s->b8_stride;
1637     xy = s->block_index[n];
1638
1639     if (s->mb_intra) {
1640         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1641         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1642         s->current_picture.motion_val[1][xy][0] = 0;
1643         s->current_picture.motion_val[1][xy][1] = 0;
1644         if (mvn == 1) { /* duplicate motion data for 1-MV block */
1645             s->current_picture.motion_val[0][xy + 1][0]        = 0;
1646             s->current_picture.motion_val[0][xy + 1][1]        = 0;
1647             s->current_picture.motion_val[0][xy + wrap][0]     = 0;
1648             s->current_picture.motion_val[0][xy + wrap][1]     = 0;
1649             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1650             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1651             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1652             s->current_picture.motion_val[1][xy + 1][0]        = 0;
1653             s->current_picture.motion_val[1][xy + 1][1]        = 0;
1654             s->current_picture.motion_val[1][xy + wrap][0]     = 0;
1655             s->current_picture.motion_val[1][xy + wrap][1]     = 0;
1656             s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1657             s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1658         }
1659         return;
1660     }
1661
1662     off = ((n == 0) || (n == 1)) ? 1 : -1;
1663     /* predict A */
1664     if (s->mb_x || (n == 1) || (n == 3)) {
1665         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1666             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1667             A[0] = s->current_picture.motion_val[0][xy - 1][0];
1668             A[1] = s->current_picture.motion_val[0][xy - 1][1];
1669             a_valid = 1;
1670         } else { // current block has frame mv and cand. has field MV (so average)
1671             A[0] = (s->current_picture.motion_val[0][xy - 1][0]
1672                     + s->current_picture.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1673             A[1] = (s->current_picture.motion_val[0][xy - 1][1]
1674                     + s->current_picture.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1675             a_valid = 1;
1676         }
1677         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1678             a_valid = 0;
1679             A[0] = A[1] = 0;
1680         }
1681     } else
1682         A[0] = A[1] = 0;
1683     /* Predict B and C */
1684     B[0] = B[1] = C[0] = C[1] = 0;
1685     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1686         if (!s->first_slice_line) {
1687             if (!v->is_intra[s->mb_x - s->mb_stride]) {
1688                 b_valid = 1;
1689                 n_adj   = n | 2;
1690                 pos_b   = s->block_index[n_adj] - 2 * wrap;
1691                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1692                     n_adj = (n & 2) | (n & 1);
1693                 }
1694                 B[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1695                 B[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1696                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1697                     B[0] = (B[0] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1698                     B[1] = (B[1] + s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1699                 }
1700             }
1701             if (s->mb_width > 1) {
1702                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1703                     c_valid = 1;
1704                     n_adj   = 2;
1705                     pos_c   = s->block_index[2] - 2 * wrap + 2;
1706                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1707                         n_adj = n & 2;
1708                     }
1709                     C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1710                     C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1711                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1712                         C[0] = (1 + C[0] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1713                         C[1] = (1 + C[1] + (s->current_picture.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1714                     }
1715                     if (s->mb_x == s->mb_width - 1) {
1716                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1717                             c_valid = 1;
1718                             n_adj   = 3;
1719                             pos_c   = s->block_index[3] - 2 * wrap - 2;
1720                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1721                                 n_adj = n | 1;
1722                             }
1723                             C[0] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1724                             C[1] = s->current_picture.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1725                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1726                                 C[0] = (1 + C[0] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1727                                 C[1] = (1 + C[1] + s->current_picture.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1728                             }
1729                         } else
1730                             c_valid = 0;
1731                     }
1732                 }
1733             }
1734         }
1735     } else {
1736         pos_b   = s->block_index[1];
1737         b_valid = 1;
1738         B[0]    = s->current_picture.motion_val[0][pos_b][0];
1739         B[1]    = s->current_picture.motion_val[0][pos_b][1];
1740         pos_c   = s->block_index[0];
1741         c_valid = 1;
1742         C[0]    = s->current_picture.motion_val[0][pos_c][0];
1743         C[1]    = s->current_picture.motion_val[0][pos_c][1];
1744     }
1745
1746     total_valid = a_valid + b_valid + c_valid;
1747     // check if predictor A is out of bounds
1748     if (!s->mb_x && !(n == 1 || n == 3)) {
1749         A[0] = A[1] = 0;
1750     }
1751     // check if predictor B is out of bounds
1752     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1753         B[0] = B[1] = C[0] = C[1] = 0;
1754     }
1755     if (!v->blk_mv_type[xy]) {
1756         if (s->mb_width == 1) {
1757             px = B[0];
1758             py = B[1];
1759         } else {
1760             if (total_valid >= 2) {
1761                 px = mid_pred(A[0], B[0], C[0]);
1762                 py = mid_pred(A[1], B[1], C[1]);
1763             } else if (total_valid) {
1764                 if      (a_valid) { px = A[0]; py = A[1]; }
1765                 else if (b_valid) { px = B[0]; py = B[1]; }
1766                 else if (c_valid) { px = C[0]; py = C[1]; }
1767                 else av_assert2(0);
1768             } else
1769                 px = py = 0;
1770         }
1771     } else {
1772         if (a_valid)
1773             field_a = (A[1] & 4) ? 1 : 0;
1774         else
1775             field_a = 0;
1776         if (b_valid)
1777             field_b = (B[1] & 4) ? 1 : 0;
1778         else
1779             field_b = 0;
1780         if (c_valid)
1781             field_c = (C[1] & 4) ? 1 : 0;
1782         else
1783             field_c = 0;
1784
1785         num_oppfield  = field_a + field_b + field_c;
1786         num_samefield = total_valid - num_oppfield;
1787         if (total_valid == 3) {
1788             if ((num_samefield == 3) || (num_oppfield == 3)) {
1789                 px = mid_pred(A[0], B[0], C[0]);
1790                 py = mid_pred(A[1], B[1], C[1]);
1791             } else if (num_samefield >= num_oppfield) {
1792                 /* take one MV from same field set depending on priority
1793                 the check for B may not be necessary */
1794                 px = !field_a ? A[0] : B[0];
1795                 py = !field_a ? A[1] : B[1];
1796             } else {
1797                 px =  field_a ? A[0] : B[0];
1798                 py =  field_a ? A[1] : B[1];
1799             }
1800         } else if (total_valid == 2) {
1801             if (num_samefield >= num_oppfield) {
1802                 if (!field_a && a_valid) {
1803                     px = A[0];
1804                     py = A[1];
1805                 } else if (!field_b && b_valid) {
1806                     px = B[0];
1807                     py = B[1];
1808                 } else if (c_valid) {
1809                     px = C[0];
1810                     py = C[1];
1811                 } else px = py = 0;
1812             } else {
1813                 if (field_a && a_valid) {
1814                     px = A[0];
1815                     py = A[1];
1816                 } else if (field_b && b_valid) {
1817                     px = B[0];
1818                     py = B[1];
1819                 } else if (c_valid) {
1820                     px = C[0];
1821                     py = C[1];
1822                 } else px = py = 0;
1823             }
1824         } else if (total_valid == 1) {
1825             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1826             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1827         } else
1828             px = py = 0;
1829     }
1830
1831     /* store MV using signed modulus of MV range defined in 4.11 */
1832     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1833     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1834     if (mvn == 1) { /* duplicate motion data for 1-MV block */
1835         s->current_picture.motion_val[0][xy +    1    ][0] = s->current_picture.motion_val[0][xy][0];
1836         s->current_picture.motion_val[0][xy +    1    ][1] = s->current_picture.motion_val[0][xy][1];
1837         s->current_picture.motion_val[0][xy + wrap    ][0] = s->current_picture.motion_val[0][xy][0];
1838         s->current_picture.motion_val[0][xy + wrap    ][1] = s->current_picture.motion_val[0][xy][1];
1839         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1840         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1841     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1842         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1843         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1844         s->mv[0][n + 1][0] = s->mv[0][n][0];
1845         s->mv[0][n + 1][1] = s->mv[0][n][1];
1846     }
1847 }
1848
1849 /** Motion compensation for direct or interpolated blocks in B-frames
1850  */
1851 static void vc1_interp_mc(VC1Context *v)
1852 {
1853     MpegEncContext *s = &v->s;
1854     H264ChromaContext *h264chroma = &v->h264chroma;
1855     uint8_t *srcY, *srcU, *srcV;
1856     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1857     int off, off_uv;
1858     int v_edge_pos = s->v_edge_pos >> v->field_mode;
1859
1860     if (!v->field_mode && !v->s.next_picture.f.data[0])
1861         return;
1862
1863     mx   = s->mv[1][0][0];
1864     my   = s->mv[1][0][1];
1865     uvmx = (mx + ((mx & 3) == 3)) >> 1;
1866     uvmy = (my + ((my & 3) == 3)) >> 1;
1867     if (v->field_mode) {
1868         if (v->cur_field_type != v->ref_field_type[1])
1869             my   = my   - 2 + 4 * v->cur_field_type;
1870             uvmy = uvmy - 2 + 4 * v->cur_field_type;
1871     }
1872     if (v->fastuvmc) {
1873         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1874         uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1875     }
1876     srcY = s->next_picture.f.data[0];
1877     srcU = s->next_picture.f.data[1];
1878     srcV = s->next_picture.f.data[2];
1879
1880     src_x   = s->mb_x * 16 + (mx   >> 2);
1881     src_y   = s->mb_y * 16 + (my   >> 2);
1882     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
1883     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
1884
1885     if (v->profile != PROFILE_ADVANCED) {
1886         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
1887         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
1888         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
1889         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
1890     } else {
1891         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
1892         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
1893         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
1894         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
1895     }
1896
1897     srcY += src_y   * s->linesize   + src_x;
1898     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1899     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1900
1901     if (v->field_mode && v->ref_field_type[1]) {
1902         srcY += s->current_picture_ptr->f.linesize[0];
1903         srcU += s->current_picture_ptr->f.linesize[1];
1904         srcV += s->current_picture_ptr->f.linesize[2];
1905     }
1906
1907     /* for grayscale we should not try to read from unknown area */
1908     if (s->flags & CODEC_FLAG_GRAY) {
1909         srcU = s->edge_emu_buffer + 18 * s->linesize;
1910         srcV = s->edge_emu_buffer + 18 * s->linesize;
1911     }
1912
1913     if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1914         || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1915         || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1916         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1917
1918         srcY -= s->mspel * (1 + s->linesize);
1919         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1920                                  17 + s->mspel * 2, 17 + s->mspel * 2,
1921                                  src_x - s->mspel, src_y - s->mspel,
1922                                  s->h_edge_pos, v_edge_pos);
1923         srcY = s->edge_emu_buffer;
1924         s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1925                                  uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1926         s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1927                                  uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1928         srcU = uvbuf;
1929         srcV = uvbuf + 16;
1930         /* if we deal with range reduction we need to scale source blocks */
1931         if (v->rangeredfrm) {
1932             int i, j;
1933             uint8_t *src, *src2;
1934
1935             src = srcY;
1936             for (j = 0; j < 17 + s->mspel * 2; j++) {
1937                 for (i = 0; i < 17 + s->mspel * 2; i++)
1938                     src[i] = ((src[i] - 128) >> 1) + 128;
1939                 src += s->linesize;
1940             }
1941             src = srcU;
1942             src2 = srcV;
1943             for (j = 0; j < 9; j++) {
1944                 for (i = 0; i < 9; i++) {
1945                     src[i]  = ((src[i]  - 128) >> 1) + 128;
1946                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1947                 }
1948                 src  += s->uvlinesize;
1949                 src2 += s->uvlinesize;
1950             }
1951         }
1952         srcY += s->mspel * (1 + s->linesize);
1953     }
1954
1955         off    = 0;
1956         off_uv = 0;
1957
1958     if (s->mspel) {
1959         dxy = ((my & 3) << 2) | (mx & 3);
1960         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
1961         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1962         srcY += s->linesize * 8;
1963         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
1964         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1965     } else { // hpel mc
1966         dxy = (my & 2) | ((mx & 2) >> 1);
1967
1968         if (!v->rnd)
1969             s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1970         else
1971             s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
1972     }
1973
1974     if (s->flags & CODEC_FLAG_GRAY) return;
1975     /* Chroma MC always uses qpel blilinear */
1976     uvmx = (uvmx & 3) << 1;
1977     uvmy = (uvmy & 3) << 1;
1978     if (!v->rnd) {
1979         h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1980         h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1981     } else {
1982         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1983         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1984     }
1985 }
1986
1987 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1988 {
1989     int n = bfrac;
1990
1991 #if B_FRACTION_DEN==256
1992     if (inv)
1993         n -= 256;
1994     if (!qs)
1995         return 2 * ((value * n + 255) >> 9);
1996     return (value * n + 128) >> 8;
1997 #else
1998     if (inv)
1999         n -= B_FRACTION_DEN;
2000     if (!qs)
2001         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2002     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2003 #endif
2004 }
2005
2006 /** Reconstruct motion vector for B-frame and do motion compensation
2007  */
2008 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2009                             int direct, int mode)
2010 {
2011     if (v->use_ic) {
2012         v->mv_mode2 = v->mv_mode;
2013         v->mv_mode  = MV_PMODE_INTENSITY_COMP;
2014     }
2015     if (direct) {
2016         vc1_mc_1mv(v, 0);
2017         vc1_interp_mc(v);
2018         if (v->use_ic)
2019             v->mv_mode = v->mv_mode2;
2020         return;
2021     }
2022     if (mode == BMV_TYPE_INTERPOLATED) {
2023         vc1_mc_1mv(v, 0);
2024         vc1_interp_mc(v);
2025         if (v->use_ic)
2026             v->mv_mode = v->mv_mode2;
2027         return;
2028     }
2029
2030     if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2031         v->mv_mode = v->mv_mode2;
2032     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2033     if (v->use_ic)
2034         v->mv_mode = v->mv_mode2;
2035 }
2036
2037 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2038                                  int direct, int mvtype)
2039 {
2040     MpegEncContext *s = &v->s;
2041     int xy, wrap, off = 0;
2042     int16_t *A, *B, *C;
2043     int px, py;
2044     int sum;
2045     int r_x, r_y;
2046     const uint8_t *is_intra = v->mb_type[0];
2047
2048     r_x = v->range_x;
2049     r_y = v->range_y;
2050     /* scale MV difference to be quad-pel */
2051     dmv_x[0] <<= 1 - s->quarter_sample;
2052     dmv_y[0] <<= 1 - s->quarter_sample;
2053     dmv_x[1] <<= 1 - s->quarter_sample;
2054     dmv_y[1] <<= 1 - s->quarter_sample;
2055
2056     wrap = s->b8_stride;
2057     xy = s->block_index[0];
2058
2059     if (s->mb_intra) {
2060         s->current_picture.motion_val[0][xy + v->blocks_off][0] =
2061         s->current_picture.motion_val[0][xy + v->blocks_off][1] =
2062         s->current_picture.motion_val[1][xy + v->blocks_off][0] =
2063         s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
2064         return;
2065     }
2066     if (!v->field_mode) {
2067         s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2068         s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2069         s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2070         s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2071
2072         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2073         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));
2074         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));
2075         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));
2076         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));
2077     }
2078     if (direct) {
2079         s->current_picture.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2080         s->current_picture.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2081         s->current_picture.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2082         s->current_picture.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2083         return;
2084     }
2085
2086     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2087         C   = s->current_picture.motion_val[0][xy - 2];
2088         A   = s->current_picture.motion_val[0][xy - wrap * 2];
2089         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2090         B   = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2091
2092         if (!s->mb_x) C[0] = C[1] = 0;
2093         if (!s->first_slice_line) { // predictor A is not out of bounds
2094             if (s->mb_width == 1) {
2095                 px = A[0];
2096                 py = A[1];
2097             } else {
2098                 px = mid_pred(A[0], B[0], C[0]);
2099                 py = mid_pred(A[1], B[1], C[1]);
2100             }
2101         } else if (s->mb_x) { // predictor C is not out of bounds
2102             px = C[0];
2103             py = C[1];
2104         } else {
2105             px = py = 0;
2106         }
2107         /* Pullback MV as specified in 8.3.5.3.4 */
2108         {
2109             int qx, qy, X, Y;
2110             if (v->profile < PROFILE_ADVANCED) {
2111                 qx = (s->mb_x << 5);
2112                 qy = (s->mb_y << 5);
2113                 X  = (s->mb_width  << 5) - 4;
2114                 Y  = (s->mb_height << 5) - 4;
2115                 if (qx + px < -28) px = -28 - qx;
2116                 if (qy + py < -28) py = -28 - qy;
2117                 if (qx + px > X) px = X - qx;
2118                 if (qy + py > Y) py = Y - qy;
2119             } else {
2120                 qx = (s->mb_x << 6);
2121                 qy = (s->mb_y << 6);
2122                 X  = (s->mb_width  << 6) - 4;
2123                 Y  = (s->mb_height << 6) - 4;
2124                 if (qx + px < -60) px = -60 - qx;
2125                 if (qy + py < -60) py = -60 - qy;
2126                 if (qx + px > X) px = X - qx;
2127                 if (qy + py > Y) py = Y - qy;
2128             }
2129         }
2130         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2131         if (0 && !s->first_slice_line && s->mb_x) {
2132             if (is_intra[xy - wrap])
2133                 sum = FFABS(px) + FFABS(py);
2134             else
2135                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2136             if (sum > 32) {
2137                 if (get_bits1(&s->gb)) {
2138                     px = A[0];
2139                     py = A[1];
2140                 } else {
2141                     px = C[0];
2142                     py = C[1];
2143                 }
2144             } else {
2145                 if (is_intra[xy - 2])
2146                     sum = FFABS(px) + FFABS(py);
2147                 else
2148                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2149                 if (sum > 32) {
2150                     if (get_bits1(&s->gb)) {
2151                         px = A[0];
2152                         py = A[1];
2153                     } else {
2154                         px = C[0];
2155                         py = C[1];
2156                     }
2157                 }
2158             }
2159         }
2160         /* store MV using signed modulus of MV range defined in 4.11 */
2161         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2162         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2163     }
2164     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2165         C   = s->current_picture.motion_val[1][xy - 2];
2166         A   = s->current_picture.motion_val[1][xy - wrap * 2];
2167         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2168         B   = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2169
2170         if (!s->mb_x)
2171             C[0] = C[1] = 0;
2172         if (!s->first_slice_line) { // predictor A is not out of bounds
2173             if (s->mb_width == 1) {
2174                 px = A[0];
2175                 py = A[1];
2176             } else {
2177                 px = mid_pred(A[0], B[0], C[0]);
2178                 py = mid_pred(A[1], B[1], C[1]);
2179             }
2180         } else if (s->mb_x) { // predictor C is not out of bounds
2181             px = C[0];
2182             py = C[1];
2183         } else {
2184             px = py = 0;
2185         }
2186         /* Pullback MV as specified in 8.3.5.3.4 */
2187         {
2188             int qx, qy, X, Y;
2189             if (v->profile < PROFILE_ADVANCED) {
2190                 qx = (s->mb_x << 5);
2191                 qy = (s->mb_y << 5);
2192                 X  = (s->mb_width  << 5) - 4;
2193                 Y  = (s->mb_height << 5) - 4;
2194                 if (qx + px < -28) px = -28 - qx;
2195                 if (qy + py < -28) py = -28 - qy;
2196                 if (qx + px > X) px = X - qx;
2197                 if (qy + py > Y) py = Y - qy;
2198             } else {
2199                 qx = (s->mb_x << 6);
2200                 qy = (s->mb_y << 6);
2201                 X  = (s->mb_width  << 6) - 4;
2202                 Y  = (s->mb_height << 6) - 4;
2203                 if (qx + px < -60) px = -60 - qx;
2204                 if (qy + py < -60) py = -60 - qy;
2205                 if (qx + px > X) px = X - qx;
2206                 if (qy + py > Y) py = Y - qy;
2207             }
2208         }
2209         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2210         if (0 && !s->first_slice_line && s->mb_x) {
2211             if (is_intra[xy - wrap])
2212                 sum = FFABS(px) + FFABS(py);
2213             else
2214                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2215             if (sum > 32) {
2216                 if (get_bits1(&s->gb)) {
2217                     px = A[0];
2218                     py = A[1];
2219                 } else {
2220                     px = C[0];
2221                     py = C[1];
2222                 }
2223             } else {
2224                 if (is_intra[xy - 2])
2225                     sum = FFABS(px) + FFABS(py);
2226                 else
2227                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2228                 if (sum > 32) {
2229                     if (get_bits1(&s->gb)) {
2230                         px = A[0];
2231                         py = A[1];
2232                     } else {
2233                         px = C[0];
2234                         py = C[1];
2235                     }
2236                 }
2237             }
2238         }
2239         /* store MV using signed modulus of MV range defined in 4.11 */
2240
2241         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2242         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2243     }
2244     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2245     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2246     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2247     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2248 }
2249
2250 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2251 {
2252     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2253     MpegEncContext *s = &v->s;
2254     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2255
2256     if (v->bmvtype == BMV_TYPE_DIRECT) {
2257         int total_opp, k, f;
2258         if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2259             s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2260                                       v->bfraction, 0, s->quarter_sample);
2261             s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2262                                       v->bfraction, 0, s->quarter_sample);
2263             s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2264                                       v->bfraction, 1, s->quarter_sample);
2265             s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2266                                       v->bfraction, 1, s->quarter_sample);
2267
2268             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2269                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2270                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2271                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2272             f = (total_opp > 2) ? 1 : 0;
2273         } else {
2274             s->mv[0][0][0] = s->mv[0][0][1] = 0;
2275             s->mv[1][0][0] = s->mv[1][0][1] = 0;
2276             f = 0;
2277         }
2278         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2279         for (k = 0; k < 4; k++) {
2280             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2281             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2282             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2283             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2284             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2285             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2286         }
2287         return;
2288     }
2289     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2290         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);
2291         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);
2292         return;
2293     }
2294     if (dir) { // backward
2295         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);
2296         if (n == 3 || mv1) {
2297             vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2298         }
2299     } else { // forward
2300         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);
2301         if (n == 3 || mv1) {
2302             vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2303         }
2304     }
2305 }
2306
2307 /** Get predicted DC value for I-frames only
2308  * prediction dir: left=0, top=1
2309  * @param s MpegEncContext
2310  * @param overlap flag indicating that overlap filtering is used
2311  * @param pq integer part of picture quantizer
2312  * @param[in] n block index in the current MB
2313  * @param dc_val_ptr Pointer to DC predictor
2314  * @param dir_ptr Prediction direction for use in AC prediction
2315  */
2316 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2317                                 int16_t **dc_val_ptr, int *dir_ptr)
2318 {
2319     int a, b, c, wrap, pred, scale;
2320     int16_t *dc_val;
2321     static const uint16_t dcpred[32] = {
2322         -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2323              114,  102,   93,   85,   79,   73,   68,   64,
2324               60,   57,   54,   51,   49,   47,   45,   43,
2325               41,   39,   38,   37,   35,   34,   33
2326     };
2327
2328     /* find prediction - wmv3_dc_scale always used here in fact */
2329     if (n < 4) scale = s->y_dc_scale;
2330     else       scale = s->c_dc_scale;
2331
2332     wrap   = s->block_wrap[n];
2333     dc_val = s->dc_val[0] + s->block_index[n];
2334
2335     /* B A
2336      * C X
2337      */
2338     c = dc_val[ - 1];
2339     b = dc_val[ - 1 - wrap];
2340     a = dc_val[ - wrap];
2341
2342     if (pq < 9 || !overlap) {
2343         /* Set outer values */
2344         if (s->first_slice_line && (n != 2 && n != 3))
2345             b = a = dcpred[scale];
2346         if (s->mb_x == 0 && (n != 1 && n != 3))
2347             b = c = dcpred[scale];
2348     } else {
2349         /* Set outer values */
2350         if (s->first_slice_line && (n != 2 && n != 3))
2351             b = a = 0;
2352         if (s->mb_x == 0 && (n != 1 && n != 3))
2353             b = c = 0;
2354     }
2355
2356     if (abs(a - b) <= abs(b - c)) {
2357         pred     = c;
2358         *dir_ptr = 1; // left
2359     } else {
2360         pred     = a;
2361         *dir_ptr = 0; // top
2362     }
2363
2364     /* update predictor */
2365     *dc_val_ptr = &dc_val[0];
2366     return pred;
2367 }
2368
2369
2370 /** Get predicted DC value
2371  * prediction dir: left=0, top=1
2372  * @param s MpegEncContext
2373  * @param overlap flag indicating that overlap filtering is used
2374  * @param pq integer part of picture quantizer
2375  * @param[in] n block index in the current MB
2376  * @param a_avail flag indicating top block availability
2377  * @param c_avail flag indicating left block availability
2378  * @param dc_val_ptr Pointer to DC predictor
2379  * @param dir_ptr Prediction direction for use in AC prediction
2380  */
2381 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2382                               int a_avail, int c_avail,
2383                               int16_t **dc_val_ptr, int *dir_ptr)
2384 {
2385     int a, b, c, wrap, pred;
2386     int16_t *dc_val;
2387     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2388     int q1, q2 = 0;
2389     int dqscale_index;
2390
2391     wrap = s->block_wrap[n];
2392     dc_val = s->dc_val[0] + s->block_index[n];
2393
2394     /* B A
2395      * C X
2396      */
2397     c = dc_val[ - 1];
2398     b = dc_val[ - 1 - wrap];
2399     a = dc_val[ - wrap];
2400     /* scale predictors if needed */
2401     q1 = s->current_picture.qscale_table[mb_pos];
2402     dqscale_index = s->y_dc_scale_table[q1] - 1;
2403     if (dqscale_index < 0)
2404         return 0;
2405     if (c_avail && (n != 1 && n != 3)) {
2406         q2 = s->current_picture.qscale_table[mb_pos - 1];
2407         if (q2 && q2 != q1)
2408             c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2409     }
2410     if (a_avail && (n != 2 && n != 3)) {
2411         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2412         if (q2 && q2 != q1)
2413             a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2414     }
2415     if (a_avail && c_avail && (n != 3)) {
2416         int off = mb_pos;
2417         if (n != 1)
2418             off--;
2419         if (n != 2)
2420             off -= s->mb_stride;
2421         q2 = s->current_picture.qscale_table[off];
2422         if (q2 && q2 != q1)
2423             b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2424     }
2425
2426     if (a_avail && c_avail) {
2427         if (abs(a - b) <= abs(b - c)) {
2428             pred     = c;
2429             *dir_ptr = 1; // left
2430         } else {
2431             pred     = a;
2432             *dir_ptr = 0; // top
2433         }
2434     } else if (a_avail) {
2435         pred     = a;
2436         *dir_ptr = 0; // top
2437     } else if (c_avail) {
2438         pred     = c;
2439         *dir_ptr = 1; // left
2440     } else {
2441         pred     = 0;
2442         *dir_ptr = 1; // left
2443     }
2444
2445     /* update predictor */
2446     *dc_val_ptr = &dc_val[0];
2447     return pred;
2448 }
2449
2450 /** @} */ // Block group
2451
2452 /**
2453  * @name VC1 Macroblock-level functions in Simple/Main Profiles
2454  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2455  * @{
2456  */
2457
2458 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2459                                        uint8_t **coded_block_ptr)
2460 {
2461     int xy, wrap, pred, a, b, c;
2462
2463     xy   = s->block_index[n];
2464     wrap = s->b8_stride;
2465
2466     /* B C
2467      * A X
2468      */
2469     a = s->coded_block[xy - 1       ];
2470     b = s->coded_block[xy - 1 - wrap];
2471     c = s->coded_block[xy     - wrap];
2472
2473     if (b == c) {
2474         pred = a;
2475     } else {
2476         pred = c;
2477     }
2478
2479     /* store value */
2480     *coded_block_ptr = &s->coded_block[xy];
2481
2482     return pred;
2483 }
2484
2485 /**
2486  * Decode one AC coefficient
2487  * @param v The VC1 context
2488  * @param last Last coefficient
2489  * @param skip How much zero coefficients to skip
2490  * @param value Decoded AC coefficient value
2491  * @param codingset set of VLC to decode data
2492  * @see 8.1.3.4
2493  */
2494 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2495                                 int *value, int codingset)
2496 {
2497     GetBitContext *gb = &v->s.gb;
2498     int index, escape, run = 0, level = 0, lst = 0;
2499
2500     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2501     if (index != ff_vc1_ac_sizes[codingset] - 1) {
2502         run   = vc1_index_decode_table[codingset][index][0];
2503         level = vc1_index_decode_table[codingset][index][1];
2504         lst   = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2505         if (get_bits1(gb))
2506             level = -level;
2507     } else {
2508         escape = decode210(gb);
2509         if (escape != 2) {
2510             index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2511             run   = vc1_index_decode_table[codingset][index][0];
2512             level = vc1_index_decode_table[codingset][index][1];
2513             lst   = index >= vc1_last_decode_table[codingset];
2514             if (escape == 0) {
2515                 if (lst)
2516                     level += vc1_last_delta_level_table[codingset][run];
2517                 else
2518                     level += vc1_delta_level_table[codingset][run];
2519             } else {
2520                 if (lst)
2521                     run += vc1_last_delta_run_table[codingset][level] + 1;
2522                 else
2523                     run += vc1_delta_run_table[codingset][level] + 1;
2524             }
2525             if (get_bits1(gb))
2526                 level = -level;
2527         } else {
2528             int sign;
2529             lst = get_bits1(gb);
2530             if (v->s.esc3_level_length == 0) {
2531                 if (v->pq < 8 || v->dquantfrm) { // table 59
2532                     v->s.esc3_level_length = get_bits(gb, 3);
2533                     if (!v->s.esc3_level_length)
2534                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2535                 } else { // table 60
2536                     v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2537                 }
2538                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2539             }
2540             run   = get_bits(gb, v->s.esc3_run_length);
2541             sign  = get_bits1(gb);
2542             level = get_bits(gb, v->s.esc3_level_length);
2543             if (sign)
2544                 level = -level;
2545         }
2546     }
2547
2548     *last  = lst;
2549     *skip  = run;
2550     *value = level;
2551 }
2552
2553 /** Decode intra block in intra frames - should be faster than decode_intra_block
2554  * @param v VC1Context
2555  * @param block block to decode
2556  * @param[in] n subblock index
2557  * @param coded are AC coeffs present or not
2558  * @param codingset set of VLC to decode data
2559  */
2560 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2561                               int coded, int codingset)
2562 {
2563     GetBitContext *gb = &v->s.gb;
2564     MpegEncContext *s = &v->s;
2565     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2566     int i;
2567     int16_t *dc_val;
2568     int16_t *ac_val, *ac_val2;
2569     int dcdiff;
2570
2571     /* Get DC differential */
2572     if (n < 4) {
2573         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2574     } else {
2575         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2576     }
2577     if (dcdiff < 0) {
2578         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2579         return -1;
2580     }
2581     if (dcdiff) {
2582         if (dcdiff == 119 /* ESC index value */) {
2583             /* TODO: Optimize */
2584             if (v->pq == 1)      dcdiff = get_bits(gb, 10);
2585             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2586             else                 dcdiff = get_bits(gb, 8);
2587         } else {
2588             if (v->pq == 1)
2589                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2590             else if (v->pq == 2)
2591                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2592         }
2593         if (get_bits1(gb))
2594             dcdiff = -dcdiff;
2595     }
2596
2597     /* Prediction */
2598     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2599     *dc_val = dcdiff;
2600
2601     /* Store the quantized DC coeff, used for prediction */
2602     if (n < 4) {
2603         block[0] = dcdiff * s->y_dc_scale;
2604     } else {
2605         block[0] = dcdiff * s->c_dc_scale;
2606     }
2607     /* Skip ? */
2608     if (!coded) {
2609         goto not_coded;
2610     }
2611
2612     // AC Decoding
2613     i = 1;
2614
2615     {
2616         int last = 0, skip, value;
2617         const uint8_t *zz_table;
2618         int scale;
2619         int k;
2620
2621         scale = v->pq * 2 + v->halfpq;
2622
2623         if (v->s.ac_pred) {
2624             if (!dc_pred_dir)
2625                 zz_table = v->zz_8x8[2];
2626             else
2627                 zz_table = v->zz_8x8[3];
2628         } else
2629             zz_table = v->zz_8x8[1];
2630
2631         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2632         ac_val2 = ac_val;
2633         if (dc_pred_dir) // left
2634             ac_val -= 16;
2635         else // top
2636             ac_val -= 16 * s->block_wrap[n];
2637
2638         while (!last) {
2639             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2640             i += skip;
2641             if (i > 63)
2642                 break;
2643             block[zz_table[i++]] = value;
2644         }
2645
2646         /* apply AC prediction if needed */
2647         if (s->ac_pred) {
2648             if (dc_pred_dir) { // left
2649                 for (k = 1; k < 8; k++)
2650                     block[k << v->left_blk_sh] += ac_val[k];
2651             } else { // top
2652                 for (k = 1; k < 8; k++)
2653                     block[k << v->top_blk_sh] += ac_val[k + 8];
2654             }
2655         }
2656         /* save AC coeffs for further prediction */
2657         for (k = 1; k < 8; k++) {
2658             ac_val2[k]     = block[k << v->left_blk_sh];
2659             ac_val2[k + 8] = block[k << v->top_blk_sh];
2660         }
2661
2662         /* scale AC coeffs */
2663         for (k = 1; k < 64; k++)
2664             if (block[k]) {
2665                 block[k] *= scale;
2666                 if (!v->pquantizer)
2667                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2668             }
2669
2670         if (s->ac_pred) i = 63;
2671     }
2672
2673 not_coded:
2674     if (!coded) {
2675         int k, scale;
2676         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2677         ac_val2 = ac_val;
2678
2679         i = 0;
2680         scale = v->pq * 2 + v->halfpq;
2681         memset(ac_val2, 0, 16 * 2);
2682         if (dc_pred_dir) { // left
2683             ac_val -= 16;
2684             if (s->ac_pred)
2685                 memcpy(ac_val2, ac_val, 8 * 2);
2686         } else { // top
2687             ac_val -= 16 * s->block_wrap[n];
2688             if (s->ac_pred)
2689                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2690         }
2691
2692         /* apply AC prediction if needed */
2693         if (s->ac_pred) {
2694             if (dc_pred_dir) { //left
2695                 for (k = 1; k < 8; k++) {
2696                     block[k << v->left_blk_sh] = ac_val[k] * scale;
2697                     if (!v->pquantizer && block[k << v->left_blk_sh])
2698                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2699                 }
2700             } else { // top
2701                 for (k = 1; k < 8; k++) {
2702                     block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2703                     if (!v->pquantizer && block[k << v->top_blk_sh])
2704                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2705                 }
2706             }
2707             i = 63;
2708         }
2709     }
2710     s->block_last_index[n] = i;
2711
2712     return 0;
2713 }
2714
2715 /** Decode intra block in intra frames - should be faster than decode_intra_block
2716  * @param v VC1Context
2717  * @param block block to decode
2718  * @param[in] n subblock number
2719  * @param coded are AC coeffs present or not
2720  * @param codingset set of VLC to decode data
2721  * @param mquant quantizer value for this macroblock
2722  */
2723 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2724                                   int coded, int codingset, int mquant)
2725 {
2726     GetBitContext *gb = &v->s.gb;
2727     MpegEncContext *s = &v->s;
2728     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2729     int i;
2730     int16_t *dc_val = NULL;
2731     int16_t *ac_val, *ac_val2;
2732     int dcdiff;
2733     int a_avail = v->a_avail, c_avail = v->c_avail;
2734     int use_pred = s->ac_pred;
2735     int scale;
2736     int q1, q2 = 0;
2737     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2738
2739     /* Get DC differential */
2740     if (n < 4) {
2741         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2742     } else {
2743         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2744     }
2745     if (dcdiff < 0) {
2746         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2747         return -1;
2748     }
2749     if (dcdiff) {
2750         if (dcdiff == 119 /* ESC index value */) {
2751             /* TODO: Optimize */
2752             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2753             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2754             else                  dcdiff = get_bits(gb, 8);
2755         } else {
2756             if (mquant == 1)
2757                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2758             else if (mquant == 2)
2759                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2760         }
2761         if (get_bits1(gb))
2762             dcdiff = -dcdiff;
2763     }
2764
2765     /* Prediction */
2766     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2767     *dc_val = dcdiff;
2768
2769     /* Store the quantized DC coeff, used for prediction */
2770     if (n < 4) {
2771         block[0] = dcdiff * s->y_dc_scale;
2772     } else {
2773         block[0] = dcdiff * s->c_dc_scale;
2774     }
2775
2776     //AC Decoding
2777     i = 1;
2778
2779     /* check if AC is needed at all */
2780     if (!a_avail && !c_avail)
2781         use_pred = 0;
2782     ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2783     ac_val2 = ac_val;
2784
2785     scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2786
2787     if (dc_pred_dir) // left
2788         ac_val -= 16;
2789     else // top
2790         ac_val -= 16 * s->block_wrap[n];
2791
2792     q1 = s->current_picture.qscale_table[mb_pos];
2793     if ( dc_pred_dir && c_avail && mb_pos)
2794         q2 = s->current_picture.qscale_table[mb_pos - 1];
2795     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2796         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2797     if ( dc_pred_dir && n == 1)
2798         q2 = q1;
2799     if (!dc_pred_dir && n == 2)
2800         q2 = q1;
2801     if (n == 3)
2802         q2 = q1;
2803
2804     if (coded) {
2805         int last = 0, skip, value;
2806         const uint8_t *zz_table;
2807         int k;
2808
2809         if (v->s.ac_pred) {
2810             if (!use_pred && v->fcm == ILACE_FRAME) {
2811                 zz_table = v->zzi_8x8;
2812             } else {
2813                 if (!dc_pred_dir) // top
2814                     zz_table = v->zz_8x8[2];
2815                 else // left
2816                     zz_table = v->zz_8x8[3];
2817             }
2818         } else {
2819             if (v->fcm != ILACE_FRAME)
2820                 zz_table = v->zz_8x8[1];
2821             else
2822                 zz_table = v->zzi_8x8;
2823         }
2824
2825         while (!last) {
2826             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2827             i += skip;
2828             if (i > 63)
2829                 break;
2830             block[zz_table[i++]] = value;
2831         }
2832
2833         /* apply AC prediction if needed */
2834         if (use_pred) {
2835             /* scale predictors if needed*/
2836             if (q2 && q1 != q2) {
2837                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2838                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2839
2840                 if (q1 < 1)
2841                     return AVERROR_INVALIDDATA;
2842                 if (dc_pred_dir) { // left
2843                     for (k = 1; k < 8; k++)
2844                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2845                 } else { // top
2846                     for (k = 1; k < 8; k++)
2847                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2848                 }
2849             } else {
2850                 if (dc_pred_dir) { //left
2851                     for (k = 1; k < 8; k++)
2852                         block[k << v->left_blk_sh] += ac_val[k];
2853                 } else { //top
2854                     for (k = 1; k < 8; k++)
2855                         block[k << v->top_blk_sh] += ac_val[k + 8];
2856                 }
2857             }
2858         }
2859         /* save AC coeffs for further prediction */
2860         for (k = 1; k < 8; k++) {
2861             ac_val2[k    ] = block[k << v->left_blk_sh];
2862             ac_val2[k + 8] = block[k << v->top_blk_sh];
2863         }
2864
2865         /* scale AC coeffs */
2866         for (k = 1; k < 64; k++)
2867             if (block[k]) {
2868                 block[k] *= scale;
2869                 if (!v->pquantizer)
2870                     block[k] += (block[k] < 0) ? -mquant : mquant;
2871             }
2872
2873         if (use_pred) i = 63;
2874     } else { // no AC coeffs
2875         int k;
2876
2877         memset(ac_val2, 0, 16 * 2);
2878         if (dc_pred_dir) { // left
2879             if (use_pred) {
2880                 memcpy(ac_val2, ac_val, 8 * 2);
2881                 if (q2 && q1 != q2) {
2882                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2883                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2884                     if (q1 < 1)
2885                         return AVERROR_INVALIDDATA;
2886                     for (k = 1; k < 8; k++)
2887                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2888                 }
2889             }
2890         } else { // top
2891             if (use_pred) {
2892                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2893                 if (q2 && q1 != q2) {
2894                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2895                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2896                     if (q1 < 1)
2897                         return AVERROR_INVALIDDATA;
2898                     for (k = 1; k < 8; k++)
2899                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2900                 }
2901             }
2902         }
2903
2904         /* apply AC prediction if needed */
2905         if (use_pred) {
2906             if (dc_pred_dir) { // left
2907                 for (k = 1; k < 8; k++) {
2908                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
2909                     if (!v->pquantizer && block[k << v->left_blk_sh])
2910                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2911                 }
2912             } else { // top
2913                 for (k = 1; k < 8; k++) {
2914                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2915                     if (!v->pquantizer && block[k << v->top_blk_sh])
2916                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2917                 }
2918             }
2919             i = 63;
2920         }
2921     }
2922     s->block_last_index[n] = i;
2923
2924     return 0;
2925 }
2926
2927 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2928  * @param v VC1Context
2929  * @param block block to decode
2930  * @param[in] n subblock index
2931  * @param coded are AC coeffs present or not
2932  * @param mquant block quantizer
2933  * @param codingset set of VLC to decode data
2934  */
2935 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
2936                                   int coded, int mquant, int codingset)
2937 {
2938     GetBitContext *gb = &v->s.gb;
2939     MpegEncContext *s = &v->s;
2940     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2941     int i;
2942     int16_t *dc_val = NULL;
2943     int16_t *ac_val, *ac_val2;
2944     int dcdiff;
2945     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2946     int a_avail = v->a_avail, c_avail = v->c_avail;
2947     int use_pred = s->ac_pred;
2948     int scale;
2949     int q1, q2 = 0;
2950
2951     s->dsp.clear_block(block);
2952
2953     /* XXX: Guard against dumb values of mquant */
2954     mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2955
2956     /* Set DC scale - y and c use the same */
2957     s->y_dc_scale = s->y_dc_scale_table[mquant];
2958     s->c_dc_scale = s->c_dc_scale_table[mquant];
2959
2960     /* Get DC differential */
2961     if (n < 4) {
2962         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2963     } else {
2964         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2965     }
2966     if (dcdiff < 0) {
2967         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2968         return -1;
2969     }
2970     if (dcdiff) {
2971         if (dcdiff == 119 /* ESC index value */) {
2972             /* TODO: Optimize */
2973             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2974             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2975             else                  dcdiff = get_bits(gb, 8);
2976         } else {
2977             if (mquant == 1)
2978                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2979             else if (mquant == 2)
2980                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2981         }
2982         if (get_bits1(gb))
2983             dcdiff = -dcdiff;
2984     }
2985
2986     /* Prediction */
2987     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2988     *dc_val = dcdiff;
2989
2990     /* Store the quantized DC coeff, used for prediction */
2991
2992     if (n < 4) {
2993         block[0] = dcdiff * s->y_dc_scale;
2994     } else {
2995         block[0] = dcdiff * s->c_dc_scale;
2996     }
2997
2998     //AC Decoding
2999     i = 1;
3000
3001     /* check if AC is needed at all and adjust direction if needed */
3002     if (!a_avail) dc_pred_dir = 1;
3003     if (!c_avail) dc_pred_dir = 0;
3004     if (!a_avail && !c_avail) use_pred = 0;
3005     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3006     ac_val2 = ac_val;
3007
3008     scale = mquant * 2 + v->halfpq;
3009
3010     if (dc_pred_dir) //left
3011         ac_val -= 16;
3012     else //top
3013         ac_val -= 16 * s->block_wrap[n];
3014
3015     q1 = s->current_picture.qscale_table[mb_pos];
3016     if (dc_pred_dir && c_avail && mb_pos)
3017         q2 = s->current_picture.qscale_table[mb_pos - 1];
3018     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3019         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3020     if ( dc_pred_dir && n == 1)
3021         q2 = q1;
3022     if (!dc_pred_dir && n == 2)
3023         q2 = q1;
3024     if (n == 3) q2 = q1;
3025
3026     if (coded) {
3027         int last = 0, skip, value;
3028         int k;
3029
3030         while (!last) {
3031             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3032             i += skip;
3033             if (i > 63)
3034                 break;
3035             if (v->fcm == PROGRESSIVE)
3036                 block[v->zz_8x8[0][i++]] = value;
3037             else {
3038                 if (use_pred && (v->fcm == ILACE_FRAME)) {
3039                     if (!dc_pred_dir) // top
3040                         block[v->zz_8x8[2][i++]] = value;
3041                     else // left
3042                         block[v->zz_8x8[3][i++]] = value;
3043                 } else {
3044                     block[v->zzi_8x8[i++]] = value;
3045                 }
3046             }
3047         }
3048
3049         /* apply AC prediction if needed */
3050         if (use_pred) {
3051             /* scale predictors if needed*/
3052             if (q2 && q1 != q2) {
3053                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3054                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3055
3056                 if (q1 < 1)
3057                     return AVERROR_INVALIDDATA;
3058                 if (dc_pred_dir) { // left
3059                     for (k = 1; k < 8; k++)
3060                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3061                 } else { //top
3062                     for (k = 1; k < 8; k++)
3063                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3064                 }
3065             } else {
3066                 if (dc_pred_dir) { // left
3067                     for (k = 1; k < 8; k++)
3068                         block[k << v->left_blk_sh] += ac_val[k];
3069                 } else { // top
3070                     for (k = 1; k < 8; k++)
3071                         block[k << v->top_blk_sh] += ac_val[k + 8];
3072                 }
3073             }
3074         }
3075         /* save AC coeffs for further prediction */
3076         for (k = 1; k < 8; k++) {
3077             ac_val2[k    ] = block[k << v->left_blk_sh];
3078             ac_val2[k + 8] = block[k << v->top_blk_sh];
3079         }
3080
3081         /* scale AC coeffs */
3082         for (k = 1; k < 64; k++)
3083             if (block[k]) {
3084                 block[k] *= scale;
3085                 if (!v->pquantizer)
3086                     block[k] += (block[k] < 0) ? -mquant : mquant;
3087             }
3088
3089         if (use_pred) i = 63;
3090     } else { // no AC coeffs
3091         int k;
3092
3093         memset(ac_val2, 0, 16 * 2);
3094         if (dc_pred_dir) { // left
3095             if (use_pred) {
3096                 memcpy(ac_val2, ac_val, 8 * 2);
3097                 if (q2 && q1 != q2) {
3098                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3099                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3100                     if (q1 < 1)
3101                         return AVERROR_INVALIDDATA;
3102                     for (k = 1; k < 8; k++)
3103                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3104                 }
3105             }
3106         } else { // top
3107             if (use_pred) {
3108                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3109                 if (q2 && q1 != q2) {
3110                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3111                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3112                     if (q1 < 1)
3113                         return AVERROR_INVALIDDATA;
3114                     for (k = 1; k < 8; k++)
3115                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3116                 }
3117             }
3118         }
3119
3120         /* apply AC prediction if needed */
3121         if (use_pred) {
3122             if (dc_pred_dir) { // left
3123                 for (k = 1; k < 8; k++) {
3124                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
3125                     if (!v->pquantizer && block[k << v->left_blk_sh])
3126                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3127                 }
3128             } else { // top
3129                 for (k = 1; k < 8; k++) {
3130                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3131                     if (!v->pquantizer && block[k << v->top_blk_sh])
3132                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3133                 }
3134             }
3135             i = 63;
3136         }
3137     }
3138     s->block_last_index[n] = i;
3139
3140     return 0;
3141 }
3142
3143 /** Decode P block
3144  */
3145 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3146                               int mquant, int ttmb, int first_block,
3147                               uint8_t *dst, int linesize, int skip_block,
3148                               int *ttmb_out)
3149 {
3150     MpegEncContext *s = &v->s;
3151     GetBitContext *gb = &s->gb;
3152     int i, j;
3153     int subblkpat = 0;
3154     int scale, off, idx, last, skip, value;
3155     int ttblk = ttmb & 7;
3156     int pat = 0;
3157
3158     s->dsp.clear_block(block);
3159
3160     if (ttmb == -1) {
3161         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)];
3162     }
3163     if (ttblk == TT_4X4) {
3164         subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3165     }
3166     if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3167         && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3168             || (!v->res_rtm_flag && !first_block))) {
3169         subblkpat = decode012(gb);
3170         if (subblkpat)
3171             subblkpat ^= 3; // swap decoded pattern bits
3172         if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3173             ttblk = TT_8X4;
3174         if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3175             ttblk = TT_4X8;
3176     }
3177     scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3178
3179     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3180     if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3181         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3182         ttblk     = TT_8X4;
3183     }
3184     if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3185         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3186         ttblk     = TT_4X8;
3187     }
3188     switch (ttblk) {
3189     case TT_8X8:
3190         pat  = 0xF;
3191         i    = 0;
3192         last = 0;
3193         while (!last) {
3194             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3195             i += skip;
3196             if (i > 63)
3197                 break;
3198             if (!v->fcm)
3199                 idx = v->zz_8x8[0][i++];
3200             else
3201                 idx = v->zzi_8x8[i++];
3202             block[idx] = value * scale;
3203             if (!v->pquantizer)
3204                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3205         }
3206         if (!skip_block) {
3207             if (i == 1)
3208                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3209             else {
3210                 v->vc1dsp.vc1_inv_trans_8x8(block);
3211                 s->dsp.add_pixels_clamped(block, dst, linesize);
3212             }
3213         }
3214         break;
3215     case TT_4X4:
3216         pat = ~subblkpat & 0xF;
3217         for (j = 0; j < 4; j++) {
3218             last = subblkpat & (1 << (3 - j));
3219             i    = 0;
3220             off  = (j & 1) * 4 + (j & 2) * 16;
3221             while (!last) {
3222                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3223                 i += skip;
3224                 if (i > 15)
3225                     break;
3226                 if (!v->fcm)
3227                     idx = ff_vc1_simple_progressive_4x4_zz[i++];
3228                 else
3229                     idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3230                 block[idx + off] = value * scale;
3231                 if (!v->pquantizer)
3232                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3233             }
3234             if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3235                 if (i == 1)
3236                     v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3237                 else
3238                     v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) *  2 * linesize, linesize, block + off);
3239             }
3240         }
3241         break;
3242     case TT_8X4:
3243         pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3244         for (j = 0; j < 2; j++) {
3245             last = subblkpat & (1 << (1 - j));
3246             i    = 0;
3247             off  = j * 32;
3248             while (!last) {
3249                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3250                 i += skip;
3251                 if (i > 31)
3252                     break;
3253                 if (!v->fcm)
3254                     idx = v->zz_8x4[i++] + off;
3255                 else
3256                     idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3257                 block[idx] = value * scale;
3258                 if (!v->pquantizer)
3259                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3260             }
3261             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3262                 if (i == 1)
3263                     v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3264                 else
3265                     v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3266             }
3267         }
3268         break;
3269     case TT_4X8:
3270         pat = ~(subblkpat * 5) & 0xF;
3271         for (j = 0; j < 2; j++) {
3272             last = subblkpat & (1 << (1 - j));
3273             i    = 0;
3274             off  = j * 4;
3275             while (!last) {
3276                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3277                 i += skip;
3278                 if (i > 31)
3279                     break;
3280                 if (!v->fcm)
3281                     idx = v->zz_4x8[i++] + off;
3282                 else
3283                     idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3284                 block[idx] = value * scale;
3285                 if (!v->pquantizer)
3286                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3287             }
3288             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3289                 if (i == 1)
3290                     v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3291                 else
3292                     v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3293             }
3294         }
3295         break;
3296     }
3297     if (ttmb_out)
3298         *ttmb_out |= ttblk << (n * 4);
3299     return pat;
3300 }
3301
3302 /** @} */ // Macroblock group
3303
3304 static const int size_table  [6] = { 0, 2, 3, 4,  5,  8 };
3305 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3306
3307 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3308 {
3309     MpegEncContext *s  = &v->s;
3310     int mb_cbp         = v->cbp[s->mb_x - s->mb_stride],
3311         block_cbp      = mb_cbp      >> (block_num * 4), bottom_cbp,
3312         mb_is_intra    = v->is_intra[s->mb_x - s->mb_stride],
3313         block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3314     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3315     uint8_t *dst;
3316
3317     if (block_num > 3) {
3318         dst      = s->dest[block_num - 3];
3319     } else {
3320         dst      = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3321     }
3322     if (s->mb_y != s->end_mb_y || block_num < 2) {
3323         int16_t (*mv)[2];
3324         int mv_stride;
3325
3326         if (block_num > 3) {
3327             bottom_cbp      = v->cbp[s->mb_x]      >> (block_num * 4);
3328             bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3329             mv              = &v->luma_mv[s->mb_x - s->mb_stride];
3330             mv_stride       = s->mb_stride;
3331         } else {
3332             bottom_cbp      = (block_num < 2) ? (mb_cbp               >> ((block_num + 2) * 4))
3333                                               : (v->cbp[s->mb_x]      >> ((block_num - 2) * 4));
3334             bottom_is_intra = (block_num < 2) ? (mb_is_intra          >> ((block_num + 2) * 4))
3335                                               : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3336             mv_stride       = s->b8_stride;
3337             mv              = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3338         }
3339
3340         if (bottom_is_intra & 1 || block_is_intra & 1 ||
3341             mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3342             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3343         } else {
3344             idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3345             if (idx == 3) {
3346                 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3347             } else if (idx) {
3348                 if (idx == 1)
3349                     v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3350                 else
3351                     v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
3352             }
3353         }
3354     }
3355
3356     dst -= 4 * linesize;
3357     ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3358     if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3359         idx = (block_cbp | (block_cbp >> 2)) & 3;
3360         if (idx == 3) {
3361             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3362         } else if (idx) {
3363             if (idx == 1)
3364                 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3365             else
3366                 v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
3367         }
3368     }
3369 }
3370
3371 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3372 {
3373     MpegEncContext *s  = &v->s;
3374     int mb_cbp         = v->cbp[s->mb_x - 1 - s->mb_stride],
3375         block_cbp      = mb_cbp      >> (block_num * 4), right_cbp,
3376         mb_is_intra    = v->is_intra[s->mb_x - 1 - s->mb_stride],
3377         block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3378     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3379     uint8_t *dst;
3380
3381     if (block_num > 3) {
3382         dst = s->dest[block_num - 3] - 8 * linesize;
3383     } else {
3384         dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3385     }
3386
3387     if (s->mb_x != s->mb_width || !(block_num & 5)) {
3388         int16_t (*mv)[2];
3389
3390         if (block_num > 3) {
3391             right_cbp      = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3392             right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3393             mv             = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3394         } else {
3395             right_cbp      = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride]      >> ((block_num - 1) * 4))
3396                                              : (mb_cbp                              >> ((block_num + 1) * 4));
3397             right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3398                                              : (mb_is_intra                         >> ((block_num + 1) * 4));
3399             mv             = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3400         }
3401         if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3402             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3403         } else {
3404             idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3405             if (idx == 5) {
3406                 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3407             } else if (idx) {
3408                 if (idx == 1)
3409                     v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3410                 else
3411                     v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
3412             }
3413         }
3414     }
3415
3416     dst -= 4;
3417     ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3418     if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3419         idx = (block_cbp | (block_cbp >> 1)) & 5;
3420         if (idx == 5) {
3421             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3422         } else if (idx) {
3423             if (idx == 1)
3424                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3425             else
3426                 v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
3427         }
3428     }
3429 }
3430
3431 static void vc1_apply_p_loop_filter(VC1Context *v)
3432 {
3433     MpegEncContext *s = &v->s;
3434     int i;
3435
3436     for (i = 0; i < 6; i++) {
3437         vc1_apply_p_v_loop_filter(v, i);
3438     }
3439
3440     /* V always precedes H, therefore we run H one MB before V;
3441      * at the end of a row, we catch up to complete the row */
3442     if (s->mb_x) {
3443         for (i = 0; i < 6; i++) {
3444             vc1_apply_p_h_loop_filter(v, i);
3445         }
3446         if (s->mb_x == s->mb_width - 1) {
3447             s->mb_x++;
3448             ff_update_block_index(s);
3449             for (i = 0; i < 6; i++) {
3450                 vc1_apply_p_h_loop_filter(v, i);
3451             }
3452         }
3453     }
3454 }
3455
3456 /** Decode one P-frame MB
3457  */
3458 static int vc1_decode_p_mb(VC1Context *v)
3459 {
3460     MpegEncContext *s = &v->s;
3461     GetBitContext *gb = &s->gb;
3462     int i, j;
3463     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3464     int cbp; /* cbp decoding stuff */
3465     int mqdiff, mquant; /* MB quantization */
3466     int ttmb = v->ttfrm; /* MB Transform type */
3467
3468     int mb_has_coeffs = 1; /* last_flag */
3469     int dmv_x, dmv_y; /* Differential MV components */
3470     int index, index1; /* LUT indexes */
3471     int val, sign; /* temp values */
3472     int first_block = 1;
3473     int dst_idx, off;
3474     int skipped, fourmv;
3475     int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3476
3477     mquant = v->pq; /* lossy initialization */
3478
3479     if (v->mv_type_is_raw)
3480         fourmv = get_bits1(gb);
3481     else
3482         fourmv = v->mv_type_mb_plane[mb_pos];
3483     if (v->skip_is_raw)
3484         skipped = get_bits1(gb);
3485     else
3486         skipped = v->s.mbskip_table[mb_pos];
3487
3488     if (!fourmv) { /* 1MV mode */
3489         if (!skipped) {
3490             GET_MVDATA(dmv_x, dmv_y);
3491
3492             if (s->mb_intra) {
3493                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3494                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3495             }
3496             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3497             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3498
3499             /* FIXME Set DC val for inter block ? */
3500             if (s->mb_intra && !mb_has_coeffs) {
3501                 GET_MQUANT();
3502                 s->ac_pred = get_bits1(gb);
3503                 cbp        = 0;
3504             } else if (mb_has_coeffs) {
3505                 if (s->mb_intra)
3506                     s->ac_pred = get_bits1(gb);
3507                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3508                 GET_MQUANT();
3509             } else {
3510                 mquant = v->pq;
3511                 cbp    = 0;
3512             }
3513             s->current_picture.qscale_table[mb_pos] = mquant;
3514
3515             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3516                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3517                                 VC1_TTMB_VLC_BITS, 2);
3518             if (!s->mb_intra) vc1_mc_1mv(v, 0);
3519             dst_idx = 0;
3520             for (i = 0; i < 6; i++) {
3521                 s->dc_val[0][s->block_index[i]] = 0;
3522                 dst_idx += i >> 2;
3523                 val = ((cbp >> (5 - i)) & 1);
3524                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3525                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3526                 if (s->mb_intra) {
3527                     /* check if prediction blocks A and C are available */
3528                     v->a_avail = v->c_avail = 0;
3529                     if (i == 2 || i == 3 || !s->first_slice_line)
3530                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3531                     if (i == 1 || i == 3 || s->mb_x)
3532                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3533
3534                     vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3535                                            (i & 4) ? v->codingset2 : v->codingset);
3536                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3537                         continue;
3538                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3539                     if (v->rangeredfrm)
3540                         for (j = 0; j < 64; j++)
3541                             s->block[i][j] <<= 1;
3542                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3543                     if (v->pq >= 9 && v->overlap) {
3544                         if (v->c_avail)
3545                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3546                         if (v->a_avail)
3547                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3548                     }
3549                     block_cbp   |= 0xF << (i << 2);
3550                     block_intra |= 1 << i;
3551                 } else if (val) {
3552                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3553                                              s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3554                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3555                     block_cbp |= pat << (i << 2);
3556                     if (!v->ttmbf && ttmb < 8)
3557                         ttmb = -1;
3558                     first_block = 0;
3559                 }
3560             }
3561         } else { // skipped
3562             s->mb_intra = 0;
3563             for (i = 0; i < 6; i++) {
3564                 v->mb_type[0][s->block_index[i]] = 0;
3565                 s->dc_val[0][s->block_index[i]]  = 0;
3566             }
3567             s->current_picture.mb_type[mb_pos]      = MB_TYPE_SKIP;
3568             s->current_picture.qscale_table[mb_pos] = 0;
3569             vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3570             vc1_mc_1mv(v, 0);
3571         }
3572     } else { // 4MV mode
3573         if (!skipped /* unskipped MB */) {
3574             int intra_count = 0, coded_inter = 0;
3575             int is_intra[6], is_coded[6];
3576             /* Get CBPCY */
3577             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3578             for (i = 0; i < 6; i++) {
3579                 val = ((cbp >> (5 - i)) & 1);
3580                 s->dc_val[0][s->block_index[i]] = 0;
3581                 s->mb_intra                     = 0;
3582                 if (i < 4) {
3583                     dmv_x = dmv_y = 0;
3584                     s->mb_intra   = 0;
3585                     mb_has_coeffs = 0;
3586                     if (val) {
3587                         GET_MVDATA(dmv_x, dmv_y);
3588                     }
3589                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3590                     if (!s->mb_intra)
3591                         vc1_mc_4mv_luma(v, i, 0);
3592                     intra_count += s->mb_intra;
3593                     is_intra[i]  = s->mb_intra;
3594                     is_coded[i]  = mb_has_coeffs;
3595                 }
3596                 if (i & 4) {
3597                     is_intra[i] = (intra_count >= 3);
3598                     is_coded[i] = val;
3599                 }
3600                 if (i == 4)
3601                     vc1_mc_4mv_chroma(v, 0);
3602                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3603                 if (!coded_inter)
3604                     coded_inter = !is_intra[i] & is_coded[i];
3605             }
3606             // if there are no coded blocks then don't do anything more
3607             dst_idx = 0;
3608             if (!intra_count && !coded_inter)
3609                 goto end;
3610             GET_MQUANT();
3611             s->current_picture.qscale_table[mb_pos] = mquant;
3612             /* test if block is intra and has pred */
3613             {
3614                 int intrapred = 0;
3615                 for (i = 0; i < 6; i++)
3616                     if (is_intra[i]) {
3617                         if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3618                             || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3619                             intrapred = 1;
3620                             break;
3621                         }
3622                     }
3623                 if (intrapred)
3624                     s->ac_pred = get_bits1(gb);
3625                 else
3626                     s->ac_pred = 0;
3627             }
3628             if (!v->ttmbf && coded_inter)
3629                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3630             for (i = 0; i < 6; i++) {
3631                 dst_idx    += i >> 2;
3632                 off         = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3633                 s->mb_intra = is_intra[i];
3634                 if (is_intra[i]) {
3635                     /* check if prediction blocks A and C are available */
3636                     v->a_avail = v->c_avail = 0;
3637                     if (i == 2 || i == 3 || !s->first_slice_line)
3638                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3639                     if (i == 1 || i == 3 || s->mb_x)
3640                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3641
3642                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3643                                            (i & 4) ? v->codingset2 : v->codingset);
3644                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3645                         continue;
3646                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3647                     if (v->rangeredfrm)
3648                         for (j = 0; j < 64; j++)
3649                             s->block[i][j] <<= 1;
3650                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3651                                                      (i & 4) ? s->uvlinesize : s->linesize);
3652                     if (v->pq >= 9 && v->overlap) {
3653                         if (v->c_avail)
3654                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3655                         if (v->a_avail)
3656                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3657                     }
3658                     block_cbp   |= 0xF << (i << 2);
3659                     block_intra |= 1 << i;
3660                 } else if (is_coded[i]) {
3661                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3662                                              first_block, s->dest[dst_idx] + off,
3663                                              (i & 4) ? s->uvlinesize : s->linesize,
3664                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3665                                              &block_tt);
3666                     block_cbp |= pat << (i << 2);
3667                     if (!v->ttmbf && ttmb < 8)
3668                         ttmb = -1;
3669                     first_block = 0;
3670                 }
3671             }
3672         } else { // skipped MB
3673             s->mb_intra                               = 0;
3674             s->current_picture.qscale_table[mb_pos] = 0;
3675             for (i = 0; i < 6; i++) {
3676                 v->mb_type[0][s->block_index[i]] = 0;
3677                 s->dc_val[0][s->block_index[i]]  = 0;
3678             }
3679             for (i = 0; i < 4; i++) {
3680                 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3681                 vc1_mc_4mv_luma(v, i, 0);
3682             }
3683             vc1_mc_4mv_chroma(v, 0);
3684             s->current_picture.qscale_table[mb_pos] = 0;
3685         }
3686     }
3687 end:
3688     v->cbp[s->mb_x]      = block_cbp;
3689     v->ttblk[s->mb_x]    = block_tt;
3690     v->is_intra[s->mb_x] = block_intra;
3691
3692     return 0;
3693 }
3694
3695 /* Decode one macroblock in an interlaced frame p picture */
3696
3697 static int vc1_decode_p_mb_intfr(VC1Context *v)
3698 {
3699     MpegEncContext *s = &v->s;
3700     GetBitContext *gb = &s->gb;
3701     int i;
3702     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3703     int cbp = 0; /* cbp decoding stuff */
3704     int mqdiff, mquant; /* MB quantization */
3705     int ttmb = v->ttfrm; /* MB Transform type */
3706
3707     int mb_has_coeffs = 1; /* last_flag */
3708     int dmv_x, dmv_y; /* Differential MV components */
3709     int val; /* temp value */
3710     int first_block = 1;
3711     int dst_idx, off;
3712     int skipped, fourmv = 0, twomv = 0;
3713     int block_cbp = 0, pat, block_tt = 0;
3714     int idx_mbmode = 0, mvbp;
3715     int stride_y, fieldtx;
3716
3717     mquant = v->pq; /* Lossy initialization */
3718
3719     if (v->skip_is_raw)
3720         skipped = get_bits1(gb);
3721     else
3722         skipped = v->s.mbskip_table[mb_pos];
3723     if (!skipped) {
3724         if (v->fourmvswitch)
3725             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3726         else
3727             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3728         switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3729         /* store the motion vector type in a flag (useful later) */
3730         case MV_PMODE_INTFR_4MV:
3731             fourmv = 1;
3732             v->blk_mv_type[s->block_index[0]] = 0;
3733             v->blk_mv_type[s->block_index[1]] = 0;
3734             v->blk_mv_type[s->block_index[2]] = 0;
3735             v->blk_mv_type[s->block_index[3]] = 0;
3736             break;
3737         case MV_PMODE_INTFR_4MV_FIELD:
3738             fourmv = 1;
3739             v->blk_mv_type[s->block_index[0]] = 1;
3740             v->blk_mv_type[s->block_index[1]] = 1;
3741             v->blk_mv_type[s->block_index[2]] = 1;
3742             v->blk_mv_type[s->block_index[3]] = 1;
3743             break;
3744         case MV_PMODE_INTFR_2MV_FIELD:
3745             twomv = 1;
3746             v->blk_mv_type[s->block_index[0]] = 1;
3747             v->blk_mv_type[s->block_index[1]] = 1;
3748             v->blk_mv_type[s->block_index[2]] = 1;
3749             v->blk_mv_type[s->block_index[3]] = 1;
3750             break;
3751         case MV_PMODE_INTFR_1MV:
3752             v->blk_mv_type[s->block_index[0]] = 0;
3753             v->blk_mv_type[s->block_index[1]] = 0;
3754             v->blk_mv_type[s->block_index[2]] = 0;
3755             v->blk_mv_type[s->block_index[3]] = 0;
3756             break;
3757         }
3758         if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3759             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3760             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3761             s->current_picture.mb_type[mb_pos]                     = MB_TYPE_INTRA;
3762             s->mb_intra = v->is_intra[s->mb_x] = 1;
3763             for (i = 0; i < 6; i++)
3764                 v->mb_type[0][s->block_index[i]] = 1;
3765             fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3766             mb_has_coeffs = get_bits1(gb);
3767             if (mb_has_coeffs)
3768                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3769             v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3770             GET_MQUANT();
3771             s->current_picture.qscale_table[mb_pos] = mquant;
3772             /* Set DC scale - y and c use the same (not sure if necessary here) */
3773             s->y_dc_scale = s->y_dc_scale_table[mquant];
3774             s->c_dc_scale = s->c_dc_scale_table[mquant];
3775             dst_idx = 0;
3776             for (i = 0; i < 6; i++) {
3777                 s->dc_val[0][s->block_index[i]] = 0;
3778                 dst_idx += i >> 2;
3779                 val = ((cbp >> (5 - i)) & 1);
3780                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3781                 v->a_avail = v->c_avail = 0;
3782                 if (i == 2 || i == 3 || !s->first_slice_line)
3783                     v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3784                 if (i == 1 || i == 3 || s->mb_x)
3785                     v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3786
3787                 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3788                                        (i & 4) ? v->codingset2 : v->codingset);
3789                 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3790                 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3791                 if (i < 4) {
3792                     stride_y = s->linesize << fieldtx;
3793                     off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3794                 } else {
3795                     stride_y = s->uvlinesize;
3796                     off = 0;
3797                 }
3798                 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3799                 //TODO: loop filter
3800             }
3801
3802         } else { // inter MB
3803             mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3804             if (mb_has_coeffs)
3805                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3806             if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3807                 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3808             } else {
3809                 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3810                     || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3811                     v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3812                 }
3813             }
3814             s->mb_intra = v->is_intra[s->mb_x] = 0;
3815             for (i = 0; i < 6; i++)
3816                 v->mb_type[0][s->block_index[i]] = 0;
3817             fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3818             /* for all motion vector read MVDATA and motion compensate each block */
3819             dst_idx = 0;
3820             if (fourmv) {
3821                 mvbp = v->fourmvbp;
3822                 for (i = 0; i < 6; i++) {
3823                     if (i < 4) {
3824                         dmv_x = dmv_y = 0;
3825                         val   = ((mvbp >> (3 - i)) & 1);
3826                         if (val) {
3827                             get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3828                         }
3829                         vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3830                         vc1_mc_4mv_luma(v, i, 0);
3831                     } else if (i == 4) {
3832                         vc1_mc_4mv_chroma4(v);
3833                     }
3834<