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