Merge commit '5d471b73d20616f5ac701ff62e5de49465cda264'
[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->dsp.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->dsp.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->dsp.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->dsp.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->dsp.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->dsp.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->dsp.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->dsp.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             *pred_flag = *dmv_y & 1;
1153             *dmv_y     = (*dmv_y + *pred_flag) >> 1;
1154         }
1155     }
1156     else {
1157         av_assert0(index < esc);
1158         if (extend_x)
1159             offs_tab = offset_table2;
1160         else
1161             offs_tab = offset_table1;
1162         index1 = (index + 1) % 9;
1163         if (index1 != 0) {
1164             val    = get_bits(gb, index1 + extend_x);
1165             sign   = 0 -(val & 1);
1166             *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1167         } else
1168             *dmv_x = 0;
1169         if (extend_y)
1170             offs_tab = offset_table2;
1171         else
1172             offs_tab = offset_table1;
1173         index1 = (index + 1) / 9;
1174         if (index1 > v->numref) {
1175             val    = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1176             sign   = 0 - (val & 1);
1177             *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1178         } else
1179             *dmv_y = 0;
1180         if (v->numref)
1181             *pred_flag = index1 & 1;
1182     }
1183 }
1184
1185 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1186 {
1187     int scaledvalue, refdist;
1188     int scalesame1, scalesame2;
1189     int scalezone1_x, zone1offset_x;
1190     int table_index = dir ^ v->second_field;
1191
1192     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1193         refdist = v->refdist;
1194     else
1195         refdist = dir ? v->brfd : v->frfd;
1196     if (refdist > 3)
1197         refdist = 3;
1198     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1199     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1200     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1201     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1202
1203     if (FFABS(n) > 255)
1204         scaledvalue = n;
1205     else {
1206         if (FFABS(n) < scalezone1_x)
1207             scaledvalue = (n * scalesame1) >> 8;
1208         else {
1209             if (n < 0)
1210                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1211             else
1212                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1213         }
1214     }
1215     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1216 }
1217
1218 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1219 {
1220     int scaledvalue, refdist;
1221     int scalesame1, scalesame2;
1222     int scalezone1_y, zone1offset_y;
1223     int table_index = dir ^ v->second_field;
1224
1225     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1226         refdist = v->refdist;
1227     else
1228         refdist = dir ? v->brfd : v->frfd;
1229     if (refdist > 3)
1230         refdist = 3;
1231     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1232     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1233     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1234     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1235
1236     if (FFABS(n) > 63)
1237         scaledvalue = n;
1238     else {
1239         if (FFABS(n) < scalezone1_y)
1240             scaledvalue = (n * scalesame1) >> 8;
1241         else {
1242             if (n < 0)
1243                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1244             else
1245                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1246         }
1247     }
1248
1249     if (v->cur_field_type && !v->ref_field_type[dir])
1250         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1251     else
1252         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1253 }
1254
1255 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1256 {
1257     int scalezone1_x, zone1offset_x;
1258     int scaleopp1, scaleopp2, brfd;
1259     int scaledvalue;
1260
1261     brfd = FFMIN(v->brfd, 3);
1262     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
1263     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1264     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1265     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1266
1267     if (FFABS(n) > 255)
1268         scaledvalue = n;
1269     else {
1270         if (FFABS(n) < scalezone1_x)
1271             scaledvalue = (n * scaleopp1) >> 8;
1272         else {
1273             if (n < 0)
1274                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1275             else
1276                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1277         }
1278     }
1279     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1280 }
1281
1282 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1283 {
1284     int scalezone1_y, zone1offset_y;
1285     int scaleopp1, scaleopp2, brfd;
1286     int scaledvalue;
1287
1288     brfd = FFMIN(v->brfd, 3);
1289     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
1290     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1291     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1292     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1293
1294     if (FFABS(n) > 63)
1295         scaledvalue = n;
1296     else {
1297         if (FFABS(n) < scalezone1_y)
1298             scaledvalue = (n * scaleopp1) >> 8;
1299         else {
1300             if (n < 0)
1301                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1302             else
1303                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1304         }
1305     }
1306     if (v->cur_field_type && !v->ref_field_type[dir]) {
1307         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1308     } else {
1309         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1310     }
1311 }
1312
1313 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1314                                          int dim, int dir)
1315 {
1316     int brfd, scalesame;
1317     int hpel = 1 - v->s.quarter_sample;
1318
1319     n >>= hpel;
1320     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1321         if (dim)
1322             n = scaleforsame_y(v, i, n, dir) << hpel;
1323         else
1324             n = scaleforsame_x(v, n, dir) << hpel;
1325         return n;
1326     }
1327     brfd      = FFMIN(v->brfd, 3);
1328     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1329
1330     n = (n * scalesame >> 8) << hpel;
1331     return n;
1332 }
1333
1334 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1335                                         int dim, int dir)
1336 {
1337     int refdist, scaleopp;
1338     int hpel = 1 - v->s.quarter_sample;
1339
1340     n >>= hpel;
1341     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1342         if (dim)
1343             n = scaleforopp_y(v, n, dir) << hpel;
1344         else
1345             n = scaleforopp_x(v, n) << hpel;
1346         return n;
1347     }
1348     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1349         refdist = FFMIN(v->refdist, 3);
1350     else
1351         refdist = dir ? v->brfd : v->frfd;
1352     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1353
1354     n = (n * scaleopp >> 8) << hpel;
1355     return n;
1356 }
1357
1358 /** Predict and set motion vector
1359  */
1360 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1361                                int mv1, int r_x, int r_y, uint8_t* is_intra,
1362                                int pred_flag, int dir)
1363 {
1364     MpegEncContext *s = &v->s;
1365     int xy, wrap, off = 0;
1366     int16_t *A, *B, *C;
1367     int px, py;
1368     int sum;
1369     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1370     int opposite, a_f, b_f, c_f;
1371     int16_t field_predA[2];
1372     int16_t field_predB[2];
1373     int16_t field_predC[2];
1374     int a_valid, b_valid, c_valid;
1375     int hybridmv_thresh, y_bias = 0;
1376
1377     if (v->mv_mode == MV_PMODE_MIXED_MV ||
1378         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1379         mixedmv_pic = 1;
1380     else
1381         mixedmv_pic = 0;
1382     /* scale MV difference to be quad-pel */
1383     dmv_x <<= 1 - s->quarter_sample;
1384     dmv_y <<= 1 - s->quarter_sample;
1385
1386     wrap = s->b8_stride;
1387     xy   = s->block_index[n];
1388
1389     if (s->mb_intra) {
1390         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1391         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1392         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1393         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1394         if (mv1) { /* duplicate motion data for 1-MV block */
1395             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
1396             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
1397             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
1398             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
1399             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1400             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1401             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1402             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
1403             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
1404             s->current_picture.f.motion_val[1][xy + wrap][0]                     = 0;
1405             s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
1406             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1407             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1408         }
1409         return;
1410     }
1411
1412     C = s->current_picture.f.motion_val[dir][xy -    1 + v->blocks_off];
1413     A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1414     if (mv1) {
1415         if (v->field_mode && mixedmv_pic)
1416             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1417         else
1418             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1419     } else {
1420         //in 4-MV mode different blocks have different B predictor position
1421         switch (n) {
1422         case 0:
1423             off = (s->mb_x > 0) ? -1 : 1;
1424             break;
1425         case 1:
1426             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1427             break;
1428         case 2:
1429             off = 1;
1430             break;
1431         case 3:
1432             off = -1;
1433         }
1434     }
1435     B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1436
1437     a_valid = !s->first_slice_line || (n == 2 || n == 3);
1438     b_valid = a_valid && (s->mb_width > 1);
1439     c_valid = s->mb_x || (n == 1 || n == 3);
1440     if (v->field_mode) {
1441         a_valid = a_valid && !is_intra[xy - wrap];
1442         b_valid = b_valid && !is_intra[xy - wrap + off];
1443         c_valid = c_valid && !is_intra[xy - 1];
1444     }
1445
1446     if (a_valid) {
1447         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1448         num_oppfield  += a_f;
1449         num_samefield += 1 - a_f;
1450         field_predA[0] = A[0];
1451         field_predA[1] = A[1];
1452     } else {
1453         field_predA[0] = field_predA[1] = 0;
1454         a_f = 0;
1455     }
1456     if (b_valid) {
1457         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1458         num_oppfield  += b_f;
1459         num_samefield += 1 - b_f;
1460         field_predB[0] = B[0];
1461         field_predB[1] = B[1];
1462     } else {
1463         field_predB[0] = field_predB[1] = 0;
1464         b_f = 0;
1465     }
1466     if (c_valid) {
1467         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1468         num_oppfield  += c_f;
1469         num_samefield += 1 - c_f;
1470         field_predC[0] = C[0];
1471         field_predC[1] = C[1];
1472     } else {
1473         field_predC[0] = field_predC[1] = 0;
1474         c_f = 0;
1475     }
1476
1477     if (v->field_mode) {
1478         if (!v->numref)
1479             // REFFIELD determines if the last field or the second-last field is
1480             // to be used as reference
1481             opposite = 1 - v->reffield;
1482         else {
1483             if (num_samefield <= num_oppfield)
1484                 opposite = 1 - pred_flag;
1485             else
1486                 opposite = pred_flag;
1487         }
1488     } else
1489         opposite = 0;
1490     if (opposite) {
1491         if (a_valid && !a_f) {
1492             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1493             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1494         }
1495         if (b_valid && !b_f) {
1496             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1497             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1498         }
1499         if (c_valid && !c_f) {
1500             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1501             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1502         }
1503         v->mv_f[dir][xy + v->blocks_off] = 1;
1504         v->ref_field_type[dir] = !v->cur_field_type;
1505     } else {
1506         if (a_valid && a_f) {
1507             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1508             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1509         }
1510         if (b_valid && b_f) {
1511             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1512             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1513         }
1514         if (c_valid && c_f) {
1515             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1516             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1517         }
1518         v->mv_f[dir][xy + v->blocks_off] = 0;
1519         v->ref_field_type[dir] = v->cur_field_type;
1520     }
1521
1522     if (a_valid) {
1523         px = field_predA[0];
1524         py = field_predA[1];
1525     } else if (c_valid) {
1526         px = field_predC[0];
1527         py = field_predC[1];
1528     } else if (b_valid) {
1529         px = field_predB[0];
1530         py = field_predB[1];
1531     } else {
1532         px = 0;
1533         py = 0;
1534     }
1535
1536     if (num_samefield + num_oppfield > 1) {
1537         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1538         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1539     }
1540
1541     /* Pullback MV as specified in 8.3.5.3.4 */
1542     if (!v->field_mode) {
1543         int qx, qy, X, Y;
1544         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1545         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1546         X  = (s->mb_width  << 6) - 4;
1547         Y  = (s->mb_height << 6) - 4;
1548         if (mv1) {
1549             if (qx + px < -60) px = -60 - qx;
1550             if (qy + py < -60) py = -60 - qy;
1551         } else {
1552             if (qx + px < -28) px = -28 - qx;
1553             if (qy + py < -28) py = -28 - qy;
1554         }
1555         if (qx + px > X) px = X - qx;
1556         if (qy + py > Y) py = Y - qy;
1557     }
1558
1559     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1560         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1561         hybridmv_thresh = 32;
1562         if (a_valid && c_valid) {
1563             if (is_intra[xy - wrap])
1564                 sum = FFABS(px) + FFABS(py);
1565             else
1566                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1567             if (sum > hybridmv_thresh) {
1568                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
1569                     px = field_predA[0];
1570                     py = field_predA[1];
1571                 } else {
1572                     px = field_predC[0];
1573                     py = field_predC[1];
1574                 }
1575             } else {
1576                 if (is_intra[xy - 1])
1577                     sum = FFABS(px) + FFABS(py);
1578                 else
1579                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1580                 if (sum > hybridmv_thresh) {
1581                     if (get_bits1(&s->gb)) {
1582                         px = field_predA[0];
1583                         py = field_predA[1];
1584                     } else {
1585                         px = field_predC[0];
1586                         py = field_predC[1];
1587                     }
1588                 }
1589             }
1590         }
1591     }
1592
1593     if (v->field_mode && v->numref)
1594         r_y >>= 1;
1595     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1596         y_bias = 1;
1597     /* store MV using signed modulus of MV range defined in 4.11 */
1598     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;
1599     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;
1600     if (mv1) { /* duplicate motion data for 1-MV block */
1601         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];
1602         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];
1603         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];
1604         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];
1605         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];
1606         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];
1607         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
1608         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];
1609     }
1610 }
1611
1612 /** Predict and set motion vector for interlaced frame picture MBs
1613  */
1614 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1615                                      int mvn, int r_x, int r_y, uint8_t* is_intra)
1616 {
1617     MpegEncContext *s = &v->s;
1618     int xy, wrap, off = 0;
1619     int A[2], B[2], C[2];
1620     int px, py;
1621     int a_valid = 0, b_valid = 0, c_valid = 0;
1622     int field_a, field_b, field_c; // 0: same, 1: opposit
1623     int total_valid, num_samefield, num_oppfield;
1624     int pos_c, pos_b, n_adj;
1625
1626     wrap = s->b8_stride;
1627     xy = s->block_index[n];
1628
1629     if (s->mb_intra) {
1630         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1631         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1632         s->current_picture.f.motion_val[1][xy][0] = 0;
1633         s->current_picture.f.motion_val[1][xy][1] = 0;
1634         if (mvn == 1) { /* duplicate motion data for 1-MV block */
1635             s->current_picture.f.motion_val[0][xy + 1][0]        = 0;
1636             s->current_picture.f.motion_val[0][xy + 1][1]        = 0;
1637             s->current_picture.f.motion_val[0][xy + wrap][0]     = 0;
1638             s->current_picture.f.motion_val[0][xy + wrap][1]     = 0;
1639             s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1640             s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1641             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1642             s->current_picture.f.motion_val[1][xy + 1][0]        = 0;
1643             s->current_picture.f.motion_val[1][xy + 1][1]        = 0;
1644             s->current_picture.f.motion_val[1][xy + wrap][0]     = 0;
1645             s->current_picture.f.motion_val[1][xy + wrap][1]     = 0;
1646             s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1647             s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1648         }
1649         return;
1650     }
1651
1652     off = ((n == 0) || (n == 1)) ? 1 : -1;
1653     /* predict A */
1654     if (s->mb_x || (n == 1) || (n == 3)) {
1655         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1656             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1657             A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1658             A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1659             a_valid = 1;
1660         } else { // current block has frame mv and cand. has field MV (so average)
1661             A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1662                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1663             A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1664                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1665             a_valid = 1;
1666         }
1667         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1668             a_valid = 0;
1669             A[0] = A[1] = 0;
1670         }
1671     } else
1672         A[0] = A[1] = 0;
1673     /* Predict B and C */
1674     B[0] = B[1] = C[0] = C[1] = 0;
1675     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1676         if (!s->first_slice_line) {
1677             if (!v->is_intra[s->mb_x - s->mb_stride]) {
1678                 b_valid = 1;
1679                 n_adj   = n | 2;
1680                 pos_b   = s->block_index[n_adj] - 2 * wrap;
1681                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1682                     n_adj = (n & 2) | (n & 1);
1683                 }
1684                 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1685                 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1686                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1687                     B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1688                     B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1689                 }
1690             }
1691             if (s->mb_width > 1) {
1692                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1693                     c_valid = 1;
1694                     n_adj   = 2;
1695                     pos_c   = s->block_index[2] - 2 * wrap + 2;
1696                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1697                         n_adj = n & 2;
1698                     }
1699                     C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1700                     C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1701                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1702                         C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1703                         C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1704                     }
1705                     if (s->mb_x == s->mb_width - 1) {
1706                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1707                             c_valid = 1;
1708                             n_adj   = 3;
1709                             pos_c   = s->block_index[3] - 2 * wrap - 2;
1710                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1711                                 n_adj = n | 1;
1712                             }
1713                             C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1714                             C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1715                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1716                                 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1717                                 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1718                             }
1719                         } else
1720                             c_valid = 0;
1721                     }
1722                 }
1723             }
1724         }
1725     } else {
1726         pos_b   = s->block_index[1];
1727         b_valid = 1;
1728         B[0]    = s->current_picture.f.motion_val[0][pos_b][0];
1729         B[1]    = s->current_picture.f.motion_val[0][pos_b][1];
1730         pos_c   = s->block_index[0];
1731         c_valid = 1;
1732         C[0]    = s->current_picture.f.motion_val[0][pos_c][0];
1733         C[1]    = s->current_picture.f.motion_val[0][pos_c][1];
1734     }
1735
1736     total_valid = a_valid + b_valid + c_valid;
1737     // check if predictor A is out of bounds
1738     if (!s->mb_x && !(n == 1 || n == 3)) {
1739         A[0] = A[1] = 0;
1740     }
1741     // check if predictor B is out of bounds
1742     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1743         B[0] = B[1] = C[0] = C[1] = 0;
1744     }
1745     if (!v->blk_mv_type[xy]) {
1746         if (s->mb_width == 1) {
1747             px = B[0];
1748             py = B[1];
1749         } else {
1750             if (total_valid >= 2) {
1751                 px = mid_pred(A[0], B[0], C[0]);
1752                 py = mid_pred(A[1], B[1], C[1]);
1753             } else if (total_valid) {
1754                 if (a_valid) { px = A[0]; py = A[1]; }
1755                 if (b_valid) { px = B[0]; py = B[1]; }
1756                 if (c_valid) { px = C[0]; py = C[1]; }
1757             } else
1758                 px = py = 0;
1759         }
1760     } else {
1761         if (a_valid)
1762             field_a = (A[1] & 4) ? 1 : 0;
1763         else
1764             field_a = 0;
1765         if (b_valid)
1766             field_b = (B[1] & 4) ? 1 : 0;
1767         else
1768             field_b = 0;
1769         if (c_valid)
1770             field_c = (C[1] & 4) ? 1 : 0;
1771         else
1772             field_c = 0;
1773
1774         num_oppfield  = field_a + field_b + field_c;
1775         num_samefield = total_valid - num_oppfield;
1776         if (total_valid == 3) {
1777             if ((num_samefield == 3) || (num_oppfield == 3)) {
1778                 px = mid_pred(A[0], B[0], C[0]);
1779                 py = mid_pred(A[1], B[1], C[1]);
1780             } else if (num_samefield >= num_oppfield) {
1781                 /* take one MV from same field set depending on priority
1782                 the check for B may not be necessary */
1783                 px = !field_a ? A[0] : B[0];
1784                 py = !field_a ? A[1] : B[1];
1785             } else {
1786                 px =  field_a ? A[0] : B[0];
1787                 py =  field_a ? A[1] : B[1];
1788             }
1789         } else if (total_valid == 2) {
1790             if (num_samefield >= num_oppfield) {
1791                 if (!field_a && a_valid) {
1792                     px = A[0];
1793                     py = A[1];
1794                 } else if (!field_b && b_valid) {
1795                     px = B[0];
1796                     py = B[1];
1797                 } else if (c_valid) {
1798                     px = C[0];
1799                     py = C[1];
1800                 } else px = py = 0;
1801             } else {
1802                 if (field_a && a_valid) {
1803                     px = A[0];
1804                     py = A[1];
1805                 } else if (field_b && b_valid) {
1806                     px = B[0];
1807                     py = B[1];
1808                 } else if (c_valid) {
1809                     px = C[0];
1810                     py = C[1];
1811                 } else px = py = 0;
1812             }
1813         } else if (total_valid == 1) {
1814             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1815             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1816         } else
1817             px = py = 0;
1818     }
1819
1820     /* store MV using signed modulus of MV range defined in 4.11 */
1821     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;
1822     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;
1823     if (mvn == 1) { /* duplicate motion data for 1-MV block */
1824         s->current_picture.f.motion_val[0][xy +    1    ][0] = s->current_picture.f.motion_val[0][xy][0];
1825         s->current_picture.f.motion_val[0][xy +    1    ][1] = s->current_picture.f.motion_val[0][xy][1];
1826         s->current_picture.f.motion_val[0][xy + wrap    ][0] = s->current_picture.f.motion_val[0][xy][0];
1827         s->current_picture.f.motion_val[0][xy + wrap    ][1] = s->current_picture.f.motion_val[0][xy][1];
1828         s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1829         s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1830     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1831         s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1832         s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1833         s->mv[0][n + 1][0] = s->mv[0][n][0];
1834         s->mv[0][n + 1][1] = s->mv[0][n][1];
1835     }
1836 }
1837
1838 /** Motion compensation for direct or interpolated blocks in B-frames
1839  */
1840 static void vc1_interp_mc(VC1Context *v)
1841 {
1842     MpegEncContext *s = &v->s;
1843     DSPContext *dsp = &v->s.dsp;
1844     uint8_t *srcY, *srcU, *srcV;
1845     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1846     int off, off_uv;
1847     int v_edge_pos = s->v_edge_pos >> v->field_mode;
1848
1849     if (!v->field_mode && !v->s.next_picture.f.data[0])
1850         return;
1851
1852     mx   = s->mv[1][0][0];
1853     my   = s->mv[1][0][1];
1854     uvmx = (mx + ((mx & 3) == 3)) >> 1;
1855     uvmy = (my + ((my & 3) == 3)) >> 1;
1856     if (v->field_mode) {
1857         if (v->cur_field_type != v->ref_field_type[1])
1858             my   = my   - 2 + 4 * v->cur_field_type;
1859             uvmy = uvmy - 2 + 4 * v->cur_field_type;
1860     }
1861     if (v->fastuvmc) {
1862         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1863         uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1864     }
1865     srcY = s->next_picture.f.data[0];
1866     srcU = s->next_picture.f.data[1];
1867     srcV = s->next_picture.f.data[2];
1868
1869     src_x   = s->mb_x * 16 + (mx   >> 2);
1870     src_y   = s->mb_y * 16 + (my   >> 2);
1871     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
1872     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
1873
1874     if (v->profile != PROFILE_ADVANCED) {
1875         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
1876         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
1877         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
1878         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
1879     } else {
1880         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
1881         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
1882         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
1883         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
1884     }
1885
1886     srcY += src_y   * s->linesize   + src_x;
1887     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1888     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1889
1890     if (v->field_mode && v->ref_field_type[1]) {
1891         srcY += s->current_picture_ptr->f.linesize[0];
1892         srcU += s->current_picture_ptr->f.linesize[1];
1893         srcV += s->current_picture_ptr->f.linesize[2];
1894     }
1895
1896     /* for grayscale we should not try to read from unknown area */
1897     if (s->flags & CODEC_FLAG_GRAY) {
1898         srcU = s->edge_emu_buffer + 18 * s->linesize;
1899         srcV = s->edge_emu_buffer + 18 * s->linesize;
1900     }
1901
1902     if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1903         || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1904         || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1905         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1906
1907         srcY -= s->mspel * (1 + s->linesize);
1908         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1909                                 17 + s->mspel * 2, 17 + s->mspel * 2,
1910                                 src_x - s->mspel, src_y - s->mspel,
1911                                 s->h_edge_pos, v_edge_pos);
1912         srcY = s->edge_emu_buffer;
1913         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1914                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1915         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1916                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1917         srcU = uvbuf;
1918         srcV = uvbuf + 16;
1919         /* if we deal with range reduction we need to scale source blocks */
1920         if (v->rangeredfrm) {
1921             int i, j;
1922             uint8_t *src, *src2;
1923
1924             src = srcY;
1925             for (j = 0; j < 17 + s->mspel * 2; j++) {
1926                 for (i = 0; i < 17 + s->mspel * 2; i++)
1927                     src[i] = ((src[i] - 128) >> 1) + 128;
1928                 src += s->linesize;
1929             }
1930             src = srcU;
1931             src2 = srcV;
1932             for (j = 0; j < 9; j++) {
1933                 for (i = 0; i < 9; i++) {
1934                     src[i]  = ((src[i]  - 128) >> 1) + 128;
1935                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1936                 }
1937                 src  += s->uvlinesize;
1938                 src2 += s->uvlinesize;
1939             }
1940         }
1941         srcY += s->mspel * (1 + s->linesize);
1942     }
1943
1944     if (v->field_mode && v->second_field) {
1945         off    = s->current_picture_ptr->f.linesize[0];
1946         off_uv = s->current_picture_ptr->f.linesize[1];
1947     } else {
1948         off    = 0;
1949         off_uv = 0;
1950     }
1951
1952     if (s->mspel) {
1953         dxy = ((my & 3) << 2) | (mx & 3);
1954         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
1955         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1956         srcY += s->linesize * 8;
1957         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
1958         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1959     } else { // hpel mc
1960         dxy = (my & 2) | ((mx & 2) >> 1);
1961
1962         if (!v->rnd)
1963             dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1964         else
1965             dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1966     }
1967
1968     if (s->flags & CODEC_FLAG_GRAY) return;
1969     /* Chroma MC always uses qpel blilinear */
1970     uvmx = (uvmx & 3) << 1;
1971     uvmy = (uvmy & 3) << 1;
1972     if (!v->rnd) {
1973         dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1974         dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1975     } else {
1976         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1977         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1978     }
1979 }
1980
1981 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1982 {
1983     int n = bfrac;
1984
1985 #if B_FRACTION_DEN==256
1986     if (inv)
1987         n -= 256;
1988     if (!qs)
1989         return 2 * ((value * n + 255) >> 9);
1990     return (value * n + 128) >> 8;
1991 #else
1992     if (inv)
1993         n -= B_FRACTION_DEN;
1994     if (!qs)
1995         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1996     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1997 #endif
1998 }
1999
2000 /** Reconstruct motion vector for B-frame and do motion compensation
2001  */
2002 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2003                             int direct, int mode)
2004 {
2005     if (v->use_ic) {
2006         v->mv_mode2 = v->mv_mode;
2007         v->mv_mode  = MV_PMODE_INTENSITY_COMP;
2008     }
2009     if (direct) {
2010         vc1_mc_1mv(v, 0);
2011         vc1_interp_mc(v);
2012         if (v->use_ic)
2013             v->mv_mode = v->mv_mode2;
2014         return;
2015     }
2016     if (mode == BMV_TYPE_INTERPOLATED) {
2017         vc1_mc_1mv(v, 0);
2018         vc1_interp_mc(v);
2019         if (v->use_ic)
2020             v->mv_mode = v->mv_mode2;
2021         return;
2022     }
2023
2024     if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2025         v->mv_mode = v->mv_mode2;
2026     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2027     if (v->use_ic)
2028         v->mv_mode = v->mv_mode2;
2029 }
2030
2031 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2032                                  int direct, int mvtype)
2033 {
2034     MpegEncContext *s = &v->s;
2035     int xy, wrap, off = 0;
2036     int16_t *A, *B, *C;
2037     int px, py;
2038     int sum;
2039     int r_x, r_y;
2040     const uint8_t *is_intra = v->mb_type[0];
2041
2042     r_x = v->range_x;
2043     r_y = v->range_y;
2044     /* scale MV difference to be quad-pel */
2045     dmv_x[0] <<= 1 - s->quarter_sample;
2046     dmv_y[0] <<= 1 - s->quarter_sample;
2047     dmv_x[1] <<= 1 - s->quarter_sample;
2048     dmv_y[1] <<= 1 - s->quarter_sample;
2049
2050     wrap = s->b8_stride;
2051     xy = s->block_index[0];
2052
2053     if (s->mb_intra) {
2054         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2055         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2056         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2057         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2058         return;
2059     }
2060     if (!v->field_mode) {
2061         s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2062         s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2063         s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2064         s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2065
2066         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2067         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));
2068         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));
2069         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));
2070         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));
2071     }
2072     if (direct) {
2073         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2074         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2075         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2076         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2077         return;
2078     }
2079
2080     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2081         C   = s->current_picture.f.motion_val[0][xy - 2];
2082         A   = s->current_picture.f.motion_val[0][xy - wrap * 2];
2083         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2084         B   = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2085
2086         if (!s->mb_x) C[0] = C[1] = 0;
2087         if (!s->first_slice_line) { // predictor A is not out of bounds
2088             if (s->mb_width == 1) {
2089                 px = A[0];
2090                 py = A[1];
2091             } else {
2092                 px = mid_pred(A[0], B[0], C[0]);
2093                 py = mid_pred(A[1], B[1], C[1]);
2094             }
2095         } else if (s->mb_x) { // predictor C is not out of bounds
2096             px = C[0];
2097             py = C[1];
2098         } else {
2099             px = py = 0;
2100         }
2101         /* Pullback MV as specified in 8.3.5.3.4 */
2102         {
2103             int qx, qy, X, Y;
2104             if (v->profile < PROFILE_ADVANCED) {
2105                 qx = (s->mb_x << 5);
2106                 qy = (s->mb_y << 5);
2107                 X  = (s->mb_width  << 5) - 4;
2108                 Y  = (s->mb_height << 5) - 4;
2109                 if (qx + px < -28) px = -28 - qx;
2110                 if (qy + py < -28) py = -28 - qy;
2111                 if (qx + px > X) px = X - qx;
2112                 if (qy + py > Y) py = Y - qy;
2113             } else {
2114                 qx = (s->mb_x << 6);
2115                 qy = (s->mb_y << 6);
2116                 X  = (s->mb_width  << 6) - 4;
2117                 Y  = (s->mb_height << 6) - 4;
2118                 if (qx + px < -60) px = -60 - qx;
2119                 if (qy + py < -60) py = -60 - qy;
2120                 if (qx + px > X) px = X - qx;
2121                 if (qy + py > Y) py = Y - qy;
2122             }
2123         }
2124         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2125         if (0 && !s->first_slice_line && s->mb_x) {
2126             if (is_intra[xy - wrap])
2127                 sum = FFABS(px) + FFABS(py);
2128             else
2129                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2130             if (sum > 32) {
2131                 if (get_bits1(&s->gb)) {
2132                     px = A[0];
2133                     py = A[1];
2134                 } else {
2135                     px = C[0];
2136                     py = C[1];
2137                 }
2138             } else {
2139                 if (is_intra[xy - 2])
2140                     sum = FFABS(px) + FFABS(py);
2141                 else
2142                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2143                 if (sum > 32) {
2144                     if (get_bits1(&s->gb)) {
2145                         px = A[0];
2146                         py = A[1];
2147                     } else {
2148                         px = C[0];
2149                         py = C[1];
2150                     }
2151                 }
2152             }
2153         }
2154         /* store MV using signed modulus of MV range defined in 4.11 */
2155         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2156         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2157     }
2158     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2159         C   = s->current_picture.f.motion_val[1][xy - 2];
2160         A   = s->current_picture.f.motion_val[1][xy - wrap * 2];
2161         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2162         B   = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2163
2164         if (!s->mb_x)
2165             C[0] = C[1] = 0;
2166         if (!s->first_slice_line) { // predictor A is not out of bounds
2167             if (s->mb_width == 1) {
2168                 px = A[0];
2169                 py = A[1];
2170             } else {
2171                 px = mid_pred(A[0], B[0], C[0]);
2172                 py = mid_pred(A[1], B[1], C[1]);
2173             }
2174         } else if (s->mb_x) { // predictor C is not out of bounds
2175             px = C[0];
2176             py = C[1];
2177         } else {
2178             px = py = 0;
2179         }
2180         /* Pullback MV as specified in 8.3.5.3.4 */
2181         {
2182             int qx, qy, X, Y;
2183             if (v->profile < PROFILE_ADVANCED) {
2184                 qx = (s->mb_x << 5);
2185                 qy = (s->mb_y << 5);
2186                 X  = (s->mb_width  << 5) - 4;
2187                 Y  = (s->mb_height << 5) - 4;
2188                 if (qx + px < -28) px = -28 - qx;
2189                 if (qy + py < -28) py = -28 - qy;
2190                 if (qx + px > X) px = X - qx;
2191                 if (qy + py > Y) py = Y - qy;
2192             } else {
2193                 qx = (s->mb_x << 6);
2194                 qy = (s->mb_y << 6);
2195                 X  = (s->mb_width  << 6) - 4;
2196                 Y  = (s->mb_height << 6) - 4;
2197                 if (qx + px < -60) px = -60 - qx;
2198                 if (qy + py < -60) py = -60 - qy;
2199                 if (qx + px > X) px = X - qx;
2200                 if (qy + py > Y) py = Y - qy;
2201             }
2202         }
2203         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2204         if (0 && !s->first_slice_line && s->mb_x) {
2205             if (is_intra[xy - wrap])
2206                 sum = FFABS(px) + FFABS(py);
2207             else
2208                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2209             if (sum > 32) {
2210                 if (get_bits1(&s->gb)) {
2211                     px = A[0];
2212                     py = A[1];
2213                 } else {
2214                     px = C[0];
2215                     py = C[1];
2216                 }
2217             } else {
2218                 if (is_intra[xy - 2])
2219                     sum = FFABS(px) + FFABS(py);
2220                 else
2221                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2222                 if (sum > 32) {
2223                     if (get_bits1(&s->gb)) {
2224                         px = A[0];
2225                         py = A[1];
2226                     } else {
2227                         px = C[0];
2228                         py = C[1];
2229                     }
2230                 }
2231             }
2232         }
2233         /* store MV using signed modulus of MV range defined in 4.11 */
2234
2235         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2236         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2237     }
2238     s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2239     s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2240     s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2241     s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2242 }
2243
2244 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2245 {
2246     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2247     MpegEncContext *s = &v->s;
2248     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2249
2250     if (v->bmvtype == BMV_TYPE_DIRECT) {
2251         int total_opp, k, f;
2252         if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2253             s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2254                                       v->bfraction, 0, s->quarter_sample);
2255             s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2256                                       v->bfraction, 0, s->quarter_sample);
2257             s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2258                                       v->bfraction, 1, s->quarter_sample);
2259             s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2260                                       v->bfraction, 1, s->quarter_sample);
2261
2262             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2263                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2264                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2265                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2266             f = (total_opp > 2) ? 1 : 0;
2267         } else {
2268             s->mv[0][0][0] = s->mv[0][0][1] = 0;
2269             s->mv[1][0][0] = s->mv[1][0][1] = 0;
2270             f = 0;
2271         }
2272         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2273         for (k = 0; k < 4; k++) {
2274             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2275             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2276             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2277             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2278             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2279             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2280         }
2281         return;
2282     }
2283     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2284         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);
2285         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);
2286         return;
2287     }
2288     if (dir) { // backward
2289         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);
2290         if (n == 3 || mv1) {
2291             vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2292         }
2293     } else { // forward
2294         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);
2295         if (n == 3 || mv1) {
2296             vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2297         }
2298     }
2299 }
2300
2301 /** Get predicted DC value for I-frames only
2302  * prediction dir: left=0, top=1
2303  * @param s MpegEncContext
2304  * @param overlap flag indicating that overlap filtering is used
2305  * @param pq integer part of picture quantizer
2306  * @param[in] n block index in the current MB
2307  * @param dc_val_ptr Pointer to DC predictor
2308  * @param dir_ptr Prediction direction for use in AC prediction
2309  */
2310 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2311                                 int16_t **dc_val_ptr, int *dir_ptr)
2312 {
2313     int a, b, c, wrap, pred, scale;
2314     int16_t *dc_val;
2315     static const uint16_t dcpred[32] = {
2316         -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2317              114,  102,   93,   85,   79,   73,   68,   64,
2318               60,   57,   54,   51,   49,   47,   45,   43,
2319               41,   39,   38,   37,   35,   34,   33
2320     };
2321
2322     /* find prediction - wmv3_dc_scale always used here in fact */
2323     if (n < 4) scale = s->y_dc_scale;
2324     else       scale = s->c_dc_scale;
2325
2326     wrap   = s->block_wrap[n];
2327     dc_val = s->dc_val[0] + s->block_index[n];
2328
2329     /* B A
2330      * C X
2331      */
2332     c = dc_val[ - 1];
2333     b = dc_val[ - 1 - wrap];
2334     a = dc_val[ - wrap];
2335
2336     if (pq < 9 || !overlap) {
2337         /* Set outer values */
2338         if (s->first_slice_line && (n != 2 && n != 3))
2339             b = a = dcpred[scale];
2340         if (s->mb_x == 0 && (n != 1 && n != 3))
2341             b = c = dcpred[scale];
2342     } else {
2343         /* Set outer values */
2344         if (s->first_slice_line && (n != 2 && n != 3))
2345             b = a = 0;
2346         if (s->mb_x == 0 && (n != 1 && n != 3))
2347             b = c = 0;
2348     }
2349
2350     if (abs(a - b) <= abs(b - c)) {
2351         pred     = c;
2352         *dir_ptr = 1; // left
2353     } else {
2354         pred     = a;
2355         *dir_ptr = 0; // top
2356     }
2357
2358     /* update predictor */
2359     *dc_val_ptr = &dc_val[0];
2360     return pred;
2361 }
2362
2363
2364 /** Get predicted DC value
2365  * prediction dir: left=0, top=1
2366  * @param s MpegEncContext
2367  * @param overlap flag indicating that overlap filtering is used
2368  * @param pq integer part of picture quantizer
2369  * @param[in] n block index in the current MB
2370  * @param a_avail flag indicating top block availability
2371  * @param c_avail flag indicating left block availability
2372  * @param dc_val_ptr Pointer to DC predictor
2373  * @param dir_ptr Prediction direction for use in AC prediction
2374  */
2375 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2376                               int a_avail, int c_avail,
2377                               int16_t **dc_val_ptr, int *dir_ptr)
2378 {
2379     int a, b, c, wrap, pred;
2380     int16_t *dc_val;
2381     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2382     int q1, q2 = 0;
2383     int dqscale_index;
2384
2385     wrap = s->block_wrap[n];
2386     dc_val = s->dc_val[0] + s->block_index[n];
2387
2388     /* B A
2389      * C X
2390      */
2391     c = dc_val[ - 1];
2392     b = dc_val[ - 1 - wrap];
2393     a = dc_val[ - wrap];
2394     /* scale predictors if needed */
2395     q1 = s->current_picture.f.qscale_table[mb_pos];
2396     dqscale_index = s->y_dc_scale_table[q1] - 1;
2397     if (dqscale_index < 0)
2398         return 0;
2399     if (c_avail && (n != 1 && n != 3)) {
2400         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2401         if (q2 && q2 != q1)
2402             c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2403     }
2404     if (a_avail && (n != 2 && n != 3)) {
2405         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2406         if (q2 && q2 != q1)
2407             a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2408     }
2409     if (a_avail && c_avail && (n != 3)) {
2410         int off = mb_pos;
2411         if (n != 1)
2412             off--;
2413         if (n != 2)
2414             off -= s->mb_stride;
2415         q2 = s->current_picture.f.qscale_table[off];
2416         if (q2 && q2 != q1)
2417             b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2418     }
2419
2420     if (a_avail && c_avail) {
2421         if (abs(a - b) <= abs(b - c)) {
2422             pred     = c;
2423             *dir_ptr = 1; // left
2424         } else {
2425             pred     = a;
2426             *dir_ptr = 0; // top
2427         }
2428     } else if (a_avail) {
2429         pred     = a;
2430         *dir_ptr = 0; // top
2431     } else if (c_avail) {
2432         pred     = c;
2433         *dir_ptr = 1; // left
2434     } else {
2435         pred     = 0;
2436         *dir_ptr = 1; // left
2437     }
2438
2439     /* update predictor */
2440     *dc_val_ptr = &dc_val[0];
2441     return pred;
2442 }
2443
2444 /** @} */ // Block group
2445
2446 /**
2447  * @name VC1 Macroblock-level functions in Simple/Main Profiles
2448  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2449  * @{
2450  */
2451
2452 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2453                                        uint8_t **coded_block_ptr)
2454 {
2455     int xy, wrap, pred, a, b, c;
2456
2457     xy   = s->block_index[n];
2458     wrap = s->b8_stride;
2459
2460     /* B C
2461      * A X
2462      */
2463     a = s->coded_block[xy - 1       ];
2464     b = s->coded_block[xy - 1 - wrap];
2465     c = s->coded_block[xy     - wrap];
2466
2467     if (b == c) {
2468         pred = a;
2469     } else {
2470         pred = c;
2471     }
2472
2473     /* store value */
2474     *coded_block_ptr = &s->coded_block[xy];
2475
2476     return pred;
2477 }
2478
2479 /**
2480  * Decode one AC coefficient
2481  * @param v The VC1 context
2482  * @param last Last coefficient
2483  * @param skip How much zero coefficients to skip
2484  * @param value Decoded AC coefficient value
2485  * @param codingset set of VLC to decode data
2486  * @see 8.1.3.4
2487  */
2488 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2489                                 int *value, int codingset)
2490 {
2491     GetBitContext *gb = &v->s.gb;
2492     int index, escape, run = 0, level = 0, lst = 0;
2493
2494     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2495     if (index != ff_vc1_ac_sizes[codingset] - 1) {
2496         run   = vc1_index_decode_table[codingset][index][0];
2497         level = vc1_index_decode_table[codingset][index][1];
2498         lst   = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2499         if (get_bits1(gb))
2500             level = -level;
2501     } else {
2502         escape = decode210(gb);
2503         if (escape != 2) {
2504             index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2505             run   = vc1_index_decode_table[codingset][index][0];
2506             level = vc1_index_decode_table[codingset][index][1];
2507             lst   = index >= vc1_last_decode_table[codingset];
2508             if (escape == 0) {
2509                 if (lst)
2510                     level += vc1_last_delta_level_table[codingset][run];
2511                 else
2512                     level += vc1_delta_level_table[codingset][run];
2513             } else {
2514                 if (lst)
2515                     run += vc1_last_delta_run_table[codingset][level] + 1;
2516                 else
2517                     run += vc1_delta_run_table[codingset][level] + 1;
2518             }
2519             if (get_bits1(gb))
2520                 level = -level;
2521         } else {
2522             int sign;
2523             lst = get_bits1(gb);
2524             if (v->s.esc3_level_length == 0) {
2525                 if (v->pq < 8 || v->dquantfrm) { // table 59
2526                     v->s.esc3_level_length = get_bits(gb, 3);
2527                     if (!v->s.esc3_level_length)
2528                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2529                 } else { // table 60
2530                     v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2531                 }
2532                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2533             }
2534             run   = get_bits(gb, v->s.esc3_run_length);
2535             sign  = get_bits1(gb);
2536             level = get_bits(gb, v->s.esc3_level_length);
2537             if (sign)
2538                 level = -level;
2539         }
2540     }
2541
2542     *last  = lst;
2543     *skip  = run;
2544     *value = level;
2545 }
2546
2547 /** Decode intra block in intra frames - should be faster than decode_intra_block
2548  * @param v VC1Context
2549  * @param block block to decode
2550  * @param[in] n subblock index
2551  * @param coded are AC coeffs present or not
2552  * @param codingset set of VLC to decode data
2553  */
2554 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2555                               int coded, int codingset)
2556 {
2557     GetBitContext *gb = &v->s.gb;
2558     MpegEncContext *s = &v->s;
2559     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2560     int i;
2561     int16_t *dc_val;
2562     int16_t *ac_val, *ac_val2;
2563     int dcdiff;
2564
2565     /* Get DC differential */
2566     if (n < 4) {
2567         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2568     } else {
2569         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2570     }
2571     if (dcdiff < 0) {
2572         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2573         return -1;
2574     }
2575     if (dcdiff) {
2576         if (dcdiff == 119 /* ESC index value */) {
2577             /* TODO: Optimize */
2578             if (v->pq == 1)      dcdiff = get_bits(gb, 10);
2579             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2580             else                 dcdiff = get_bits(gb, 8);
2581         } else {
2582             if (v->pq == 1)
2583                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2584             else if (v->pq == 2)
2585                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2586         }
2587         if (get_bits1(gb))
2588             dcdiff = -dcdiff;
2589     }
2590
2591     /* Prediction */
2592     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2593     *dc_val = dcdiff;
2594
2595     /* Store the quantized DC coeff, used for prediction */
2596     if (n < 4) {
2597         block[0] = dcdiff * s->y_dc_scale;
2598     } else {
2599         block[0] = dcdiff * s->c_dc_scale;
2600     }
2601     /* Skip ? */
2602     if (!coded) {
2603         goto not_coded;
2604     }
2605
2606     // AC Decoding
2607     i = 1;
2608
2609     {
2610         int last = 0, skip, value;
2611         const uint8_t *zz_table;
2612         int scale;
2613         int k;
2614
2615         scale = v->pq * 2 + v->halfpq;
2616
2617         if (v->s.ac_pred) {
2618             if (!dc_pred_dir)
2619                 zz_table = v->zz_8x8[2];
2620             else
2621                 zz_table = v->zz_8x8[3];
2622         } else
2623             zz_table = v->zz_8x8[1];
2624
2625         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2626         ac_val2 = ac_val;
2627         if (dc_pred_dir) // left
2628             ac_val -= 16;
2629         else // top
2630             ac_val -= 16 * s->block_wrap[n];
2631
2632         while (!last) {
2633             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2634             i += skip;
2635             if (i > 63)
2636                 break;
2637             block[zz_table[i++]] = value;
2638         }
2639
2640         /* apply AC prediction if needed */
2641         if (s->ac_pred) {
2642             if (dc_pred_dir) { // left
2643                 for (k = 1; k < 8; k++)
2644                     block[k << v->left_blk_sh] += ac_val[k];
2645             } else { // top
2646                 for (k = 1; k < 8; k++)
2647                     block[k << v->top_blk_sh] += ac_val[k + 8];
2648             }
2649         }
2650         /* save AC coeffs for further prediction */
2651         for (k = 1; k < 8; k++) {
2652             ac_val2[k]     = block[k << v->left_blk_sh];
2653             ac_val2[k + 8] = block[k << v->top_blk_sh];
2654         }
2655
2656         /* scale AC coeffs */
2657         for (k = 1; k < 64; k++)
2658             if (block[k]) {
2659                 block[k] *= scale;
2660                 if (!v->pquantizer)
2661                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2662             }
2663
2664         if (s->ac_pred) i = 63;
2665     }
2666
2667 not_coded:
2668     if (!coded) {
2669         int k, scale;
2670         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2671         ac_val2 = ac_val;
2672
2673         i = 0;
2674         scale = v->pq * 2 + v->halfpq;
2675         memset(ac_val2, 0, 16 * 2);
2676         if (dc_pred_dir) { // left
2677             ac_val -= 16;
2678             if (s->ac_pred)
2679                 memcpy(ac_val2, ac_val, 8 * 2);
2680         } else { // top
2681             ac_val -= 16 * s->block_wrap[n];
2682             if (s->ac_pred)
2683                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2684         }
2685
2686         /* apply AC prediction if needed */
2687         if (s->ac_pred) {
2688             if (dc_pred_dir) { //left
2689                 for (k = 1; k < 8; k++) {
2690                     block[k << v->left_blk_sh] = ac_val[k] * scale;
2691                     if (!v->pquantizer && block[k << v->left_blk_sh])
2692                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2693                 }
2694             } else { // top
2695                 for (k = 1; k < 8; k++) {
2696                     block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2697                     if (!v->pquantizer && block[k << v->top_blk_sh])
2698                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2699                 }
2700             }
2701             i = 63;
2702         }
2703     }
2704     s->block_last_index[n] = i;
2705
2706     return 0;
2707 }
2708
2709 /** Decode intra block in intra frames - should be faster than decode_intra_block
2710  * @param v VC1Context
2711  * @param block block to decode
2712  * @param[in] n subblock number
2713  * @param coded are AC coeffs present or not
2714  * @param codingset set of VLC to decode data
2715  * @param mquant quantizer value for this macroblock
2716  */
2717 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2718                                   int coded, int codingset, int mquant)
2719 {
2720     GetBitContext *gb = &v->s.gb;
2721     MpegEncContext *s = &v->s;
2722     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2723     int i;
2724     int16_t *dc_val;
2725     int16_t *ac_val, *ac_val2;
2726     int dcdiff;
2727     int a_avail = v->a_avail, c_avail = v->c_avail;
2728     int use_pred = s->ac_pred;
2729     int scale;
2730     int q1, q2 = 0;
2731     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2732
2733     /* Get DC differential */
2734     if (n < 4) {
2735         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2736     } else {
2737         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2738     }
2739     if (dcdiff < 0) {
2740         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2741         return -1;
2742     }
2743     if (dcdiff) {
2744         if (dcdiff == 119 /* ESC index value */) {
2745             /* TODO: Optimize */
2746             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2747             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2748             else                  dcdiff = get_bits(gb, 8);
2749         } else {
2750             if (mquant == 1)
2751                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2752             else if (mquant == 2)
2753                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2754         }
2755         if (get_bits1(gb))
2756             dcdiff = -dcdiff;
2757     }
2758
2759     /* Prediction */
2760     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2761     *dc_val = dcdiff;
2762
2763     /* Store the quantized DC coeff, used for prediction */
2764     if (n < 4) {
2765         block[0] = dcdiff * s->y_dc_scale;
2766     } else {
2767         block[0] = dcdiff * s->c_dc_scale;
2768     }
2769
2770     //AC Decoding
2771     i = 1;
2772
2773     /* check if AC is needed at all */
2774     if (!a_avail && !c_avail)
2775         use_pred = 0;
2776     ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2777     ac_val2 = ac_val;
2778
2779     scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2780
2781     if (dc_pred_dir) // left
2782         ac_val -= 16;
2783     else // top
2784         ac_val -= 16 * s->block_wrap[n];
2785
2786     q1 = s->current_picture.f.qscale_table[mb_pos];
2787     if ( dc_pred_dir && c_avail && mb_pos)
2788         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2789     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2790         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2791     if ( dc_pred_dir && n == 1)
2792         q2 = q1;
2793     if (!dc_pred_dir && n == 2)
2794         q2 = q1;
2795     if (n == 3)
2796         q2 = q1;
2797
2798     if (coded) {
2799         int last = 0, skip, value;
2800         const uint8_t *zz_table;
2801         int k;
2802
2803         if (v->s.ac_pred) {
2804             if (!use_pred && v->fcm == ILACE_FRAME) {
2805                 zz_table = v->zzi_8x8;
2806             } else {
2807                 if (!dc_pred_dir) // top
2808                     zz_table = v->zz_8x8[2];
2809                 else // left
2810                     zz_table = v->zz_8x8[3];
2811             }
2812         } else {
2813             if (v->fcm != ILACE_FRAME)
2814                 zz_table = v->zz_8x8[1];
2815             else
2816                 zz_table = v->zzi_8x8;
2817         }
2818
2819         while (!last) {
2820             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2821             i += skip;
2822             if (i > 63)
2823                 break;
2824             block[zz_table[i++]] = value;
2825         }
2826
2827         /* apply AC prediction if needed */
2828         if (use_pred) {
2829             /* scale predictors if needed*/
2830             if (q2 && q1 != q2) {
2831                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2832                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2833
2834                 if (q1 < 1)
2835                     return AVERROR_INVALIDDATA;
2836                 if (dc_pred_dir) { // left
2837                     for (k = 1; k < 8; k++)
2838                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2839                 } else { // top
2840                     for (k = 1; k < 8; k++)
2841                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2842                 }
2843             } else {
2844                 if (dc_pred_dir) { //left
2845                     for (k = 1; k < 8; k++)
2846                         block[k << v->left_blk_sh] += ac_val[k];
2847                 } else { //top
2848                     for (k = 1; k < 8; k++)
2849                         block[k << v->top_blk_sh] += ac_val[k + 8];
2850                 }
2851             }
2852         }
2853         /* save AC coeffs for further prediction */
2854         for (k = 1; k < 8; k++) {
2855             ac_val2[k    ] = block[k << v->left_blk_sh];
2856             ac_val2[k + 8] = block[k << v->top_blk_sh];
2857         }
2858
2859         /* scale AC coeffs */
2860         for (k = 1; k < 64; k++)
2861             if (block[k]) {
2862                 block[k] *= scale;
2863                 if (!v->pquantizer)
2864                     block[k] += (block[k] < 0) ? -mquant : mquant;
2865             }
2866
2867         if (use_pred) i = 63;
2868     } else { // no AC coeffs
2869         int k;
2870
2871         memset(ac_val2, 0, 16 * 2);
2872         if (dc_pred_dir) { // left
2873             if (use_pred) {
2874                 memcpy(ac_val2, ac_val, 8 * 2);
2875                 if (q2 && q1 != q2) {
2876                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2877                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2878                     if (q1 < 1)
2879                         return AVERROR_INVALIDDATA;
2880                     for (k = 1; k < 8; k++)
2881                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2882                 }
2883             }
2884         } else { // top
2885             if (use_pred) {
2886                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2887                 if (q2 && q1 != q2) {
2888                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2889                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2890                     if (q1 < 1)
2891                         return AVERROR_INVALIDDATA;
2892                     for (k = 1; k < 8; k++)
2893                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2894                 }
2895             }
2896         }
2897
2898         /* apply AC prediction if needed */
2899         if (use_pred) {
2900             if (dc_pred_dir) { // left
2901                 for (k = 1; k < 8; k++) {
2902                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
2903                     if (!v->pquantizer && block[k << v->left_blk_sh])
2904                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2905                 }
2906             } else { // top
2907                 for (k = 1; k < 8; k++) {
2908                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2909                     if (!v->pquantizer && block[k << v->top_blk_sh])
2910                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2911                 }
2912             }
2913             i = 63;
2914         }
2915     }
2916     s->block_last_index[n] = i;
2917
2918     return 0;
2919 }
2920
2921 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2922  * @param v VC1Context
2923  * @param block block to decode
2924  * @param[in] n subblock index
2925  * @param coded are AC coeffs present or not
2926  * @param mquant block quantizer
2927  * @param codingset set of VLC to decode data
2928  */
2929 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2930                                   int coded, int mquant, int codingset)
2931 {
2932     GetBitContext *gb = &v->s.gb;
2933     MpegEncContext *s = &v->s;
2934     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2935     int i;
2936     int16_t *dc_val;
2937     int16_t *ac_val, *ac_val2;
2938     int dcdiff;
2939     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2940     int a_avail = v->a_avail, c_avail = v->c_avail;
2941     int use_pred = s->ac_pred;
2942     int scale;
2943     int q1, q2 = 0;
2944
2945     s->dsp.clear_block(block);
2946
2947     /* XXX: Guard against dumb values of mquant */
2948     mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2949
2950     /* Set DC scale - y and c use the same */
2951     s->y_dc_scale = s->y_dc_scale_table[mquant];
2952     s->c_dc_scale = s->c_dc_scale_table[mquant];
2953
2954     /* Get DC differential */
2955     if (n < 4) {
2956         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2957     } else {
2958         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2959     }
2960     if (dcdiff < 0) {
2961         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2962         return -1;
2963     }
2964     if (dcdiff) {
2965         if (dcdiff == 119 /* ESC index value */) {
2966             /* TODO: Optimize */
2967             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2968             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2969             else                  dcdiff = get_bits(gb, 8);
2970         } else {
2971             if (mquant == 1)
2972                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2973             else if (mquant == 2)
2974                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2975         }
2976         if (get_bits1(gb))
2977             dcdiff = -dcdiff;
2978     }
2979
2980     /* Prediction */
2981     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2982     *dc_val = dcdiff;
2983
2984     /* Store the quantized DC coeff, used for prediction */
2985
2986     if (n < 4) {
2987         block[0] = dcdiff * s->y_dc_scale;
2988     } else {
2989         block[0] = dcdiff * s->c_dc_scale;
2990     }
2991
2992     //AC Decoding
2993     i = 1;
2994
2995     /* check if AC is needed at all and adjust direction if needed */
2996     if (!a_avail) dc_pred_dir = 1;
2997     if (!c_avail) dc_pred_dir = 0;
2998     if (!a_avail && !c_avail) use_pred = 0;
2999     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3000     ac_val2 = ac_val;
3001
3002     scale = mquant * 2 + v->halfpq;
3003
3004     if (dc_pred_dir) //left
3005         ac_val -= 16;
3006     else //top
3007         ac_val -= 16 * s->block_wrap[n];
3008
3009     q1 = s->current_picture.f.qscale_table[mb_pos];
3010     if (dc_pred_dir && c_avail && mb_pos)
3011         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
3012     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3013         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
3014     if ( dc_pred_dir && n == 1)
3015         q2 = q1;
3016     if (!dc_pred_dir && n == 2)
3017         q2 = q1;
3018     if (n == 3) q2 = q1;
3019
3020     if (coded) {
3021         int last = 0, skip, value;
3022         int k;
3023
3024         while (!last) {
3025             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3026             i += skip;
3027             if (i > 63)
3028                 break;
3029             if (v->fcm == PROGRESSIVE)
3030                 block[v->zz_8x8[0][i++]] = value;
3031             else {
3032                 if (use_pred && (v->fcm == ILACE_FRAME)) {
3033                     if (!dc_pred_dir) // top
3034                         block[v->zz_8x8[2][i++]] = value;
3035                     else // left
3036                         block[v->zz_8x8[3][i++]] = value;
3037                 } else {
3038                     block[v->zzi_8x8[i++]] = value;
3039                 }
3040             }
3041         }
3042
3043         /* apply AC prediction if needed */
3044         if (use_pred) {
3045             /* scale predictors if needed*/
3046             if (q2 && q1 != q2) {
3047                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3048                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3049
3050                 if (q1 < 1)
3051                     return AVERROR_INVALIDDATA;
3052                 if (dc_pred_dir) { // left
3053                     for (k = 1; k < 8; k++)
3054                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3055                 } else { //top
3056                     for (k = 1; k < 8; k++)
3057                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3058                 }
3059             } else {
3060                 if (dc_pred_dir) { // left
3061                     for (k = 1; k < 8; k++)
3062                         block[k << v->left_blk_sh] += ac_val[k];
3063                 } else { // top
3064                     for (k = 1; k < 8; k++)
3065                         block[k << v->top_blk_sh] += ac_val[k + 8];
3066                 }
3067             }
3068         }
3069         /* save AC coeffs for further prediction */
3070         for (k = 1; k < 8; k++) {
3071             ac_val2[k    ] = block[k << v->left_blk_sh];
3072             ac_val2[k + 8] = block[k << v->top_blk_sh];
3073         }
3074
3075         /* scale AC coeffs */
3076         for (k = 1; k < 64; k++)
3077             if (block[k]) {
3078                 block[k] *= scale;
3079                 if (!v->pquantizer)
3080                     block[k] += (block[k] < 0) ? -mquant : mquant;
3081             }
3082
3083         if (use_pred) i = 63;
3084     } else { // no AC coeffs
3085         int k;
3086
3087         memset(ac_val2, 0, 16 * 2);
3088         if (dc_pred_dir) { // left
3089             if (use_pred) {
3090                 memcpy(ac_val2, ac_val, 8 * 2);
3091                 if (q2 && q1 != q2) {
3092                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3093                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3094                     if (q1 < 1)
3095                         return AVERROR_INVALIDDATA;
3096                     for (k = 1; k < 8; k++)
3097                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3098                 }
3099             }
3100         } else { // top
3101             if (use_pred) {
3102                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3103                 if (q2 && q1 != q2) {
3104                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3105                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3106                     if (q1 < 1)
3107                         return AVERROR_INVALIDDATA;
3108                     for (k = 1; k < 8; k++)
3109                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3110                 }
3111             }
3112         }
3113
3114         /* apply AC prediction if needed */
3115         if (use_pred) {
3116             if (dc_pred_dir) { // left
3117                 for (k = 1; k < 8; k++) {
3118                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
3119                     if (!v->pquantizer && block[k << v->left_blk_sh])
3120                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3121                 }
3122             } else { // top
3123                 for (k = 1; k < 8; k++) {
3124                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3125                     if (!v->pquantizer && block[k << v->top_blk_sh])
3126                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3127                 }
3128             }
3129             i = 63;
3130         }
3131     }
3132     s->block_last_index[n] = i;
3133
3134     return 0;
3135 }
3136
3137 /** Decode P block
3138  */
3139 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3140                               int mquant, int ttmb, int first_block,
3141                               uint8_t *dst, int linesize, int skip_block,
3142                               int *ttmb_out)
3143 {
3144     MpegEncContext *s = &v->s;
3145     GetBitContext *gb = &s->gb;
3146     int i, j;
3147     int subblkpat = 0;
3148     int scale, off, idx, last, skip, value;
3149     int ttblk = ttmb & 7;
3150     int pat = 0;
3151
3152     s->dsp.clear_block(block);
3153
3154     if (ttmb == -1) {
3155         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)];
3156     }
3157     if (ttblk == TT_4X4) {
3158         subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3159     }
3160     if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3161         && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3162             || (!v->res_rtm_flag && !first_block))) {
3163         subblkpat = decode012(gb);
3164         if (subblkpat)
3165             subblkpat ^= 3; // swap decoded pattern bits
3166         if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3167             ttblk = TT_8X4;
3168         if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3169             ttblk = TT_4X8;
3170     }
3171     scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3172
3173     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3174     if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3175         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3176         ttblk     = TT_8X4;
3177     }
3178     if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3179         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3180         ttblk     = TT_4X8;
3181     }
3182     switch (ttblk) {
3183     case TT_8X8:
3184         pat  = 0xF;
3185         i    = 0;
3186         last = 0;
3187         while (!last) {
3188             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3189             i += skip;
3190             if (i > 63)
3191                 break;
3192             if (!v->fcm)
3193                 idx = v->zz_8x8[0][i++];
3194             else
3195                 idx = v->zzi_8x8[i++];
3196             block[idx] = value * scale;
3197             if (!v->pquantizer)
3198                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3199         }
3200         if (!skip_block) {
3201             if (i == 1)
3202                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3203             else {
3204                 v->vc1dsp.vc1_inv_trans_8x8(block);
3205                 s->dsp.add_pixels_clamped(block, dst, linesize);
3206             }
3207         }
3208         break;
3209     case TT_4X4:
3210         pat = ~subblkpat & 0xF;
3211         for (j = 0; j < 4; j++) {
3212             last = subblkpat & (1 << (3 - j));
3213             i    = 0;
3214             off  = (j & 1) * 4 + (j & 2) * 16;
3215             while (!last) {
3216                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3217                 i += skip;
3218                 if (i > 15)
3219                     break;
3220                 if (!v->fcm)
3221                     idx = ff_vc1_simple_progressive_4x4_zz[i++];
3222                 else
3223                     idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3224                 block[idx + off] = value * scale;
3225                 if (!v->pquantizer)
3226                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3227             }
3228             if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3229                 if (i == 1)
3230                     v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3231                 else
3232                     v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) *  2 * linesize, linesize, block + off);
3233             }
3234         }
3235         break;
3236     case TT_8X4:
3237         pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3238         for (j = 0; j < 2; j++) {
3239             last = subblkpat & (1 << (1 - j));
3240             i    = 0;
3241             off  = j * 32;
3242             while (!last) {
3243                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3244                 i += skip;
3245                 if (i > 31)
3246                     break;
3247                 if (!v->fcm)
3248                     idx = v->zz_8x4[i++] + off;
3249                 else
3250                     idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3251                 block[idx] = value * scale;
3252                 if (!v->pquantizer)
3253                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3254             }
3255             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3256                 if (i == 1)
3257                     v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3258                 else
3259                     v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3260             }
3261         }
3262         break;
3263     case TT_4X8:
3264         pat = ~(subblkpat * 5) & 0xF;
3265         for (j = 0; j < 2; j++) {
3266             last = subblkpat & (1 << (1 - j));
3267             i    = 0;
3268             off  = j * 4;
3269             while (!last) {
3270                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3271                 i += skip;
3272                 if (i > 31)
3273                     break;
3274                 if (!v->fcm)
3275                     idx = v->zz_4x8[i++] + off;
3276                 else
3277                     idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3278                 block[idx] = value * scale;
3279                 if (!v->pquantizer)
3280                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3281             }
3282             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3283                 if (i == 1)
3284                     v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3285                 else
3286                     v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3287             }
3288         }
3289         break;
3290     }
3291     if (ttmb_out)
3292         *ttmb_out |= ttblk << (n * 4);
3293     return pat;
3294 }
3295
3296 /** @} */ // Macroblock group
3297
3298 static const int size_table  [6] = { 0, 2, 3, 4,  5,  8 };
3299 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3300
3301 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3302 {
3303     MpegEncContext *s  = &v->s;
3304     int mb_cbp         = v->cbp[s->mb_x - s->mb_stride],
3305         block_cbp      = mb_cbp      >> (block_num * 4), bottom_cbp,
3306         mb_is_intra    = v->is_intra[s->mb_x - s->mb_stride],
3307         block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3308     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3309     uint8_t *dst;
3310
3311     if (block_num > 3) {
3312         dst      = s->dest[block_num - 3];
3313     } else {
3314         dst      = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3315     }
3316     if (s->mb_y != s->end_mb_y || block_num < 2) {
3317         int16_t (*mv)[2];
3318         int mv_stride;
3319
3320         if (block_num > 3) {
3321             bottom_cbp      = v->cbp[s->mb_x]      >> (block_num * 4);
3322             bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3323             mv              = &v->luma_mv[s->mb_x - s->mb_stride];
3324             mv_stride       = s->mb_stride;
3325         } else {
3326             bottom_cbp      = (block_num < 2) ? (mb_cbp               >> ((block_num + 2) * 4))
3327                                               : (v->cbp[s->mb_x]      >> ((block_num - 2) * 4));
3328             bottom_is_intra = (block_num < 2) ? (mb_is_intra          >> ((block_num + 2) * 4))
3329                                               : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3330             mv_stride       = s->b8_stride;