Merge commit '04d14c9b68b03e8dbc6e3003c1ee06892dd32576'
[ffmpeg.git] / libavcodec / vc1_pred.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 block decoding routines
27  */
28
29 #include "mathops.h"
30 #include "mpegutils.h"
31 #include "mpegvideo.h"
32 #include "vc1.h"
33 #include "vc1_pred.h"
34 #include "vc1data.h"
35
36 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
37 {
38     int scaledvalue, refdist;
39     int scalesame1, scalesame2;
40     int scalezone1_x, zone1offset_x;
41     int table_index = dir ^ v->second_field;
42
43     if (v->s.pict_type != AV_PICTURE_TYPE_B)
44         refdist = v->refdist;
45     else
46         refdist = dir ? v->brfd : v->frfd;
47     if (refdist > 3)
48         refdist = 3;
49     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
50     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
51     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
52     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
53
54     if (FFABS(n) > 255)
55         scaledvalue = n;
56     else {
57         if (FFABS(n) < scalezone1_x)
58             scaledvalue = (n * scalesame1) >> 8;
59         else {
60             if (n < 0)
61                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
62             else
63                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
64         }
65     }
66     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
67 }
68
69 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
70 {
71     int scaledvalue, refdist;
72     int scalesame1, scalesame2;
73     int scalezone1_y, zone1offset_y;
74     int table_index = dir ^ v->second_field;
75
76     if (v->s.pict_type != AV_PICTURE_TYPE_B)
77         refdist = v->refdist;
78     else
79         refdist = dir ? v->brfd : v->frfd;
80     if (refdist > 3)
81         refdist = 3;
82     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
83     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
84     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
85     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
86
87     if (FFABS(n) > 63)
88         scaledvalue = n;
89     else {
90         if (FFABS(n) < scalezone1_y)
91             scaledvalue = (n * scalesame1) >> 8;
92         else {
93             if (n < 0)
94                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
95             else
96                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
97         }
98     }
99
100     if (v->cur_field_type && !v->ref_field_type[dir])
101         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
102     else
103         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
104 }
105
106 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
107 {
108     int scalezone1_x, zone1offset_x;
109     int scaleopp1, scaleopp2, brfd;
110     int scaledvalue;
111
112     brfd = FFMIN(v->brfd, 3);
113     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
114     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
115     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
116     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
117
118     if (FFABS(n) > 255)
119         scaledvalue = n;
120     else {
121         if (FFABS(n) < scalezone1_x)
122             scaledvalue = (n * scaleopp1) >> 8;
123         else {
124             if (n < 0)
125                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
126             else
127                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
128         }
129     }
130     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
131 }
132
133 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
134 {
135     int scalezone1_y, zone1offset_y;
136     int scaleopp1, scaleopp2, brfd;
137     int scaledvalue;
138
139     brfd = FFMIN(v->brfd, 3);
140     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
141     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
142     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
143     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
144
145     if (FFABS(n) > 63)
146         scaledvalue = n;
147     else {
148         if (FFABS(n) < scalezone1_y)
149             scaledvalue = (n * scaleopp1) >> 8;
150         else {
151             if (n < 0)
152                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
153             else
154                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
155         }
156     }
157     if (v->cur_field_type && !v->ref_field_type[dir]) {
158         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
159     } else {
160         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
161     }
162 }
163
164 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
165                                          int dim, int dir)
166 {
167     int brfd, scalesame;
168     int hpel = 1 - v->s.quarter_sample;
169
170     n >>= hpel;
171     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
172         if (dim)
173             n = scaleforsame_y(v, i, n, dir) << hpel;
174         else
175             n = scaleforsame_x(v, n, dir) << hpel;
176         return n;
177     }
178     brfd      = FFMIN(v->brfd, 3);
179     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
180
181     n = (n * scalesame >> 8) << hpel;
182     return n;
183 }
184
185 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
186                                         int dim, int dir)
187 {
188     int refdist, scaleopp;
189     int hpel = 1 - v->s.quarter_sample;
190
191     n >>= hpel;
192     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
193         if (dim)
194             n = scaleforopp_y(v, n, dir) << hpel;
195         else
196             n = scaleforopp_x(v, n) << hpel;
197         return n;
198     }
199     if (v->s.pict_type != AV_PICTURE_TYPE_B)
200         refdist = FFMIN(v->refdist, 3);
201     else
202         refdist = dir ? v->brfd : v->frfd;
203     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
204
205     n = (n * scaleopp >> 8) << hpel;
206     return n;
207 }
208
209 /** Predict and set motion vector
210  */
211 void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
212                     int mv1, int r_x, int r_y, uint8_t* is_intra,
213                     int pred_flag, int dir)
214 {
215     MpegEncContext *s = &v->s;
216     int xy, wrap, off = 0;
217     int16_t *A, *B, *C;
218     int px, py;
219     int sum;
220     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
221     int opposite, a_f, b_f, c_f;
222     int16_t field_predA[2];
223     int16_t field_predB[2];
224     int16_t field_predC[2];
225     int a_valid, b_valid, c_valid;
226     int hybridmv_thresh, y_bias = 0;
227
228     if (v->mv_mode == MV_PMODE_MIXED_MV ||
229         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
230         mixedmv_pic = 1;
231     else
232         mixedmv_pic = 0;
233     /* scale MV difference to be quad-pel */
234     dmv_x <<= 1 - s->quarter_sample;
235     dmv_y <<= 1 - s->quarter_sample;
236
237     wrap = s->b8_stride;
238     xy   = s->block_index[n];
239
240     if (s->mb_intra) {
241         s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
242         s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
243         s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
244         s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
245         if (mv1) { /* duplicate motion data for 1-MV block */
246             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
247             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
248             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
249             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
250             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
251             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
252             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
253             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
254             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
255             s->current_picture.motion_val[1][xy + wrap][0]                     = 0;
256             s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
257             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
258             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
259         }
260         return;
261     }
262
263     C = s->current_picture.motion_val[dir][xy -    1 + v->blocks_off];
264     A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
265     if (mv1) {
266         if (v->field_mode && mixedmv_pic)
267             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
268         else
269             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
270     } else {
271         //in 4-MV mode different blocks have different B predictor position
272         switch (n) {
273         case 0:
274             off = (s->mb_x > 0) ? -1 : 1;
275             break;
276         case 1:
277             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
278             break;
279         case 2:
280             off = 1;
281             break;
282         case 3:
283             off = -1;
284         }
285     }
286     B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
287
288     a_valid = !s->first_slice_line || (n == 2 || n == 3);
289     b_valid = a_valid && (s->mb_width > 1);
290     c_valid = s->mb_x || (n == 1 || n == 3);
291     if (v->field_mode) {
292         a_valid = a_valid && !is_intra[xy - wrap];
293         b_valid = b_valid && !is_intra[xy - wrap + off];
294         c_valid = c_valid && !is_intra[xy - 1];
295     }
296
297     if (a_valid) {
298         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
299         num_oppfield  += a_f;
300         num_samefield += 1 - a_f;
301         field_predA[0] = A[0];
302         field_predA[1] = A[1];
303     } else {
304         field_predA[0] = field_predA[1] = 0;
305         a_f = 0;
306     }
307     if (b_valid) {
308         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
309         num_oppfield  += b_f;
310         num_samefield += 1 - b_f;
311         field_predB[0] = B[0];
312         field_predB[1] = B[1];
313     } else {
314         field_predB[0] = field_predB[1] = 0;
315         b_f = 0;
316     }
317     if (c_valid) {
318         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
319         num_oppfield  += c_f;
320         num_samefield += 1 - c_f;
321         field_predC[0] = C[0];
322         field_predC[1] = C[1];
323     } else {
324         field_predC[0] = field_predC[1] = 0;
325         c_f = 0;
326     }
327
328     if (v->field_mode) {
329         if (!v->numref)
330             // REFFIELD determines if the last field or the second-last field is
331             // to be used as reference
332             opposite = 1 - v->reffield;
333         else {
334             if (num_samefield <= num_oppfield)
335                 opposite = 1 - pred_flag;
336             else
337                 opposite = pred_flag;
338         }
339     } else
340         opposite = 0;
341     if (opposite) {
342         if (a_valid && !a_f) {
343             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
344             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
345         }
346         if (b_valid && !b_f) {
347             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
348             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
349         }
350         if (c_valid && !c_f) {
351             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
352             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
353         }
354         v->mv_f[dir][xy + v->blocks_off] = 1;
355         v->ref_field_type[dir] = !v->cur_field_type;
356     } else {
357         if (a_valid && a_f) {
358             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
359             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
360         }
361         if (b_valid && b_f) {
362             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
363             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
364         }
365         if (c_valid && c_f) {
366             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
367             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
368         }
369         v->mv_f[dir][xy + v->blocks_off] = 0;
370         v->ref_field_type[dir] = v->cur_field_type;
371     }
372
373     if (a_valid) {
374         px = field_predA[0];
375         py = field_predA[1];
376     } else if (c_valid) {
377         px = field_predC[0];
378         py = field_predC[1];
379     } else if (b_valid) {
380         px = field_predB[0];
381         py = field_predB[1];
382     } else {
383         px = 0;
384         py = 0;
385     }
386
387     if (num_samefield + num_oppfield > 1) {
388         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
389         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
390     }
391
392     /* Pullback MV as specified in 8.3.5.3.4 */
393     if (!v->field_mode) {
394         int qx, qy, X, Y;
395         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
396         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
397         X  = (s->mb_width  << 6) - 4;
398         Y  = (s->mb_height << 6) - 4;
399         if (mv1) {
400             if (qx + px < -60) px = -60 - qx;
401             if (qy + py < -60) py = -60 - qy;
402         } else {
403             if (qx + px < -28) px = -28 - qx;
404             if (qy + py < -28) py = -28 - qy;
405         }
406         if (qx + px > X) px = X - qx;
407         if (qy + py > Y) py = Y - qy;
408     }
409
410     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
411         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
412         hybridmv_thresh = 32;
413         if (a_valid && c_valid) {
414             if (is_intra[xy - wrap])
415                 sum = FFABS(px) + FFABS(py);
416             else
417                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
418             if (sum > hybridmv_thresh) {
419                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
420                     px = field_predA[0];
421                     py = field_predA[1];
422                 } else {
423                     px = field_predC[0];
424                     py = field_predC[1];
425                 }
426             } else {
427                 if (is_intra[xy - 1])
428                     sum = FFABS(px) + FFABS(py);
429                 else
430                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
431                 if (sum > hybridmv_thresh) {
432                     if (get_bits1(&s->gb)) {
433                         px = field_predA[0];
434                         py = field_predA[1];
435                     } else {
436                         px = field_predC[0];
437                         py = field_predC[1];
438                     }
439                 }
440             }
441         }
442     }
443
444     if (v->field_mode && v->numref)
445         r_y >>= 1;
446     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
447         y_bias = 1;
448     /* store MV using signed modulus of MV range defined in 4.11 */
449     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
450     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
451     if (mv1) { /* duplicate motion data for 1-MV block */
452         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
453         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
454         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
455         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
456         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
457         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
458         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
459         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];
460     }
461 }
462
463 /** Predict and set motion vector for interlaced frame picture MBs
464  */
465 void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
466                           int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
467 {
468     MpegEncContext *s = &v->s;
469     int xy, wrap, off = 0;
470     int A[2], B[2], C[2];
471     int px = 0, py = 0;
472     int a_valid = 0, b_valid = 0, c_valid = 0;
473     int field_a, field_b, field_c; // 0: same, 1: opposit
474     int total_valid, num_samefield, num_oppfield;
475     int pos_c, pos_b, n_adj;
476
477     wrap = s->b8_stride;
478     xy = s->block_index[n];
479
480     if (s->mb_intra) {
481         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
482         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
483         s->current_picture.motion_val[1][xy][0] = 0;
484         s->current_picture.motion_val[1][xy][1] = 0;
485         if (mvn == 1) { /* duplicate motion data for 1-MV block */
486             s->current_picture.motion_val[0][xy + 1][0]        = 0;
487             s->current_picture.motion_val[0][xy + 1][1]        = 0;
488             s->current_picture.motion_val[0][xy + wrap][0]     = 0;
489             s->current_picture.motion_val[0][xy + wrap][1]     = 0;
490             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
491             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
492             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
493             s->current_picture.motion_val[1][xy + 1][0]        = 0;
494             s->current_picture.motion_val[1][xy + 1][1]        = 0;
495             s->current_picture.motion_val[1][xy + wrap][0]     = 0;
496             s->current_picture.motion_val[1][xy + wrap][1]     = 0;
497             s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
498             s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
499         }
500         return;
501     }
502
503     off = ((n == 0) || (n == 1)) ? 1 : -1;
504     /* predict A */
505     if (s->mb_x || (n == 1) || (n == 3)) {
506         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
507             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
508             A[0] = s->current_picture.motion_val[dir][xy - 1][0];
509             A[1] = s->current_picture.motion_val[dir][xy - 1][1];
510             a_valid = 1;
511         } else { // current block has frame mv and cand. has field MV (so average)
512             A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
513                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
514             A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
515                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
516             a_valid = 1;
517         }
518         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
519             a_valid = 0;
520             A[0] = A[1] = 0;
521         }
522     } else
523         A[0] = A[1] = 0;
524     /* Predict B and C */
525     B[0] = B[1] = C[0] = C[1] = 0;
526     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
527         if (!s->first_slice_line) {
528             if (!v->is_intra[s->mb_x - s->mb_stride]) {
529                 b_valid = 1;
530                 n_adj   = n | 2;
531                 pos_b   = s->block_index[n_adj] - 2 * wrap;
532                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
533                     n_adj = (n & 2) | (n & 1);
534                 }
535                 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
536                 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
537                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
538                     B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
539                     B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
540                 }
541             }
542             if (s->mb_width > 1) {
543                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
544                     c_valid = 1;
545                     n_adj   = 2;
546                     pos_c   = s->block_index[2] - 2 * wrap + 2;
547                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
548                         n_adj = n & 2;
549                     }
550                     C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
551                     C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
552                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
553                         C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
554                         C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
555                     }
556                     if (s->mb_x == s->mb_width - 1) {
557                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
558                             c_valid = 1;
559                             n_adj   = 3;
560                             pos_c   = s->block_index[3] - 2 * wrap - 2;
561                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
562                                 n_adj = n | 1;
563                             }
564                             C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
565                             C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
566                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
567                                 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
568                                 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
569                             }
570                         } else
571                             c_valid = 0;
572                     }
573                 }
574             }
575         }
576     } else {
577         pos_b   = s->block_index[1];
578         b_valid = 1;
579         B[0]    = s->current_picture.motion_val[dir][pos_b][0];
580         B[1]    = s->current_picture.motion_val[dir][pos_b][1];
581         pos_c   = s->block_index[0];
582         c_valid = 1;
583         C[0]    = s->current_picture.motion_val[dir][pos_c][0];
584         C[1]    = s->current_picture.motion_val[dir][pos_c][1];
585     }
586
587     total_valid = a_valid + b_valid + c_valid;
588     // check if predictor A is out of bounds
589     if (!s->mb_x && !(n == 1 || n == 3)) {
590         A[0] = A[1] = 0;
591     }
592     // check if predictor B is out of bounds
593     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
594         B[0] = B[1] = C[0] = C[1] = 0;
595     }
596     if (!v->blk_mv_type[xy]) {
597         if (s->mb_width == 1) {
598             px = B[0];
599             py = B[1];
600         } else {
601             if (total_valid >= 2) {
602                 px = mid_pred(A[0], B[0], C[0]);
603                 py = mid_pred(A[1], B[1], C[1]);
604             } else if (total_valid) {
605                 if      (a_valid) { px = A[0]; py = A[1]; }
606                 else if (b_valid) { px = B[0]; py = B[1]; }
607                 else              { px = C[0]; py = C[1]; }
608             }
609         }
610     } else {
611         if (a_valid)
612             field_a = (A[1] & 4) ? 1 : 0;
613         else
614             field_a = 0;
615         if (b_valid)
616             field_b = (B[1] & 4) ? 1 : 0;
617         else
618             field_b = 0;
619         if (c_valid)
620             field_c = (C[1] & 4) ? 1 : 0;
621         else
622             field_c = 0;
623
624         num_oppfield  = field_a + field_b + field_c;
625         num_samefield = total_valid - num_oppfield;
626         if (total_valid == 3) {
627             if ((num_samefield == 3) || (num_oppfield == 3)) {
628                 px = mid_pred(A[0], B[0], C[0]);
629                 py = mid_pred(A[1], B[1], C[1]);
630             } else if (num_samefield >= num_oppfield) {
631                 /* take one MV from same field set depending on priority
632                 the check for B may not be necessary */
633                 px = !field_a ? A[0] : B[0];
634                 py = !field_a ? A[1] : B[1];
635             } else {
636                 px =  field_a ? A[0] : B[0];
637                 py =  field_a ? A[1] : B[1];
638             }
639         } else if (total_valid == 2) {
640             if (num_samefield >= num_oppfield) {
641                 if (!field_a && a_valid) {
642                     px = A[0];
643                     py = A[1];
644                 } else if (!field_b && b_valid) {
645                     px = B[0];
646                     py = B[1];
647                 } else /*if (c_valid)*/ {
648                     av_assert1(c_valid);
649                     px = C[0];
650                     py = C[1];
651                 } /*else px = py = 0;*/
652             } else {
653                 if (field_a && a_valid) {
654                     px = A[0];
655                     py = A[1];
656                 } else /*if (field_b && b_valid)*/ {
657                     av_assert1(field_b && b_valid);
658                     px = B[0];
659                     py = B[1];
660                 } /*else if (c_valid) {
661                     px = C[0];
662                     py = C[1];
663                 }*/
664             }
665         } else if (total_valid == 1) {
666             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
667             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
668         }
669     }
670
671     /* store MV using signed modulus of MV range defined in 4.11 */
672     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
673     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
674     if (mvn == 1) { /* duplicate motion data for 1-MV block */
675         s->current_picture.motion_val[dir][xy +    1    ][0] = s->current_picture.motion_val[dir][xy][0];
676         s->current_picture.motion_val[dir][xy +    1    ][1] = s->current_picture.motion_val[dir][xy][1];
677         s->current_picture.motion_val[dir][xy + wrap    ][0] = s->current_picture.motion_val[dir][xy][0];
678         s->current_picture.motion_val[dir][xy + wrap    ][1] = s->current_picture.motion_val[dir][xy][1];
679         s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
680         s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
681     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
682         s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
683         s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
684         s->mv[dir][n + 1][0] = s->mv[dir][n][0];
685         s->mv[dir][n + 1][1] = s->mv[dir][n][1];
686     }
687 }
688
689 void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
690                       int direct, int mvtype)
691 {
692     MpegEncContext *s = &v->s;
693     int xy, wrap, off = 0;
694     int16_t *A, *B, *C;
695     int px, py;
696     int sum;
697     int r_x, r_y;
698     const uint8_t *is_intra = v->mb_type[0];
699
700     av_assert0(!v->field_mode);
701
702     r_x = v->range_x;
703     r_y = v->range_y;
704     /* scale MV difference to be quad-pel */
705     dmv_x[0] <<= 1 - s->quarter_sample;
706     dmv_y[0] <<= 1 - s->quarter_sample;
707     dmv_x[1] <<= 1 - s->quarter_sample;
708     dmv_y[1] <<= 1 - s->quarter_sample;
709
710     wrap = s->b8_stride;
711     xy = s->block_index[0];
712
713     if (s->mb_intra) {
714         s->current_picture.motion_val[0][xy][0] =
715         s->current_picture.motion_val[0][xy][1] =
716         s->current_picture.motion_val[1][xy][0] =
717         s->current_picture.motion_val[1][xy][1] = 0;
718         return;
719     }
720         if (direct && s->next_picture_ptr->field_picture)
721             av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
722
723         s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
724         s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
725         s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
726         s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
727
728         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
729         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));
730         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));
731         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));
732         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));
733     if (direct) {
734         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
735         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
736         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
737         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
738         return;
739     }
740
741     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
742         C   = s->current_picture.motion_val[0][xy - 2];
743         A   = s->current_picture.motion_val[0][xy - wrap * 2];
744         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
745         B   = s->current_picture.motion_val[0][xy - wrap * 2 + off];
746
747         if (!s->mb_x) C[0] = C[1] = 0;
748         if (!s->first_slice_line) { // predictor A is not out of bounds
749             if (s->mb_width == 1) {
750                 px = A[0];
751                 py = A[1];
752             } else {
753                 px = mid_pred(A[0], B[0], C[0]);
754                 py = mid_pred(A[1], B[1], C[1]);
755             }
756         } else if (s->mb_x) { // predictor C is not out of bounds
757             px = C[0];
758             py = C[1];
759         } else {
760             px = py = 0;
761         }
762         /* Pullback MV as specified in 8.3.5.3.4 */
763         {
764             int qx, qy, X, Y;
765             if (v->profile < PROFILE_ADVANCED) {
766                 qx = (s->mb_x << 5);
767                 qy = (s->mb_y << 5);
768                 X  = (s->mb_width  << 5) - 4;
769                 Y  = (s->mb_height << 5) - 4;
770                 if (qx + px < -28) px = -28 - qx;
771                 if (qy + py < -28) py = -28 - qy;
772                 if (qx + px > X) px = X - qx;
773                 if (qy + py > Y) py = Y - qy;
774             } else {
775                 qx = (s->mb_x << 6);
776                 qy = (s->mb_y << 6);
777                 X  = (s->mb_width  << 6) - 4;
778                 Y  = (s->mb_height << 6) - 4;
779                 if (qx + px < -60) px = -60 - qx;
780                 if (qy + py < -60) py = -60 - qy;
781                 if (qx + px > X) px = X - qx;
782                 if (qy + py > Y) py = Y - qy;
783             }
784         }
785         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
786         if (0 && !s->first_slice_line && s->mb_x) {
787             if (is_intra[xy - wrap])
788                 sum = FFABS(px) + FFABS(py);
789             else
790                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
791             if (sum > 32) {
792                 if (get_bits1(&s->gb)) {
793                     px = A[0];
794                     py = A[1];
795                 } else {
796                     px = C[0];
797                     py = C[1];
798                 }
799             } else {
800                 if (is_intra[xy - 2])
801                     sum = FFABS(px) + FFABS(py);
802                 else
803                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
804                 if (sum > 32) {
805                     if (get_bits1(&s->gb)) {
806                         px = A[0];
807                         py = A[1];
808                     } else {
809                         px = C[0];
810                         py = C[1];
811                     }
812                 }
813             }
814         }
815         /* store MV using signed modulus of MV range defined in 4.11 */
816         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
817         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
818     }
819     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
820         C   = s->current_picture.motion_val[1][xy - 2];
821         A   = s->current_picture.motion_val[1][xy - wrap * 2];
822         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
823         B   = s->current_picture.motion_val[1][xy - wrap * 2 + off];
824
825         if (!s->mb_x)
826             C[0] = C[1] = 0;
827         if (!s->first_slice_line) { // predictor A is not out of bounds
828             if (s->mb_width == 1) {
829                 px = A[0];
830                 py = A[1];
831             } else {
832                 px = mid_pred(A[0], B[0], C[0]);
833                 py = mid_pred(A[1], B[1], C[1]);
834             }
835         } else if (s->mb_x) { // predictor C is not out of bounds
836             px = C[0];
837             py = C[1];
838         } else {
839             px = py = 0;
840         }
841         /* Pullback MV as specified in 8.3.5.3.4 */
842         {
843             int qx, qy, X, Y;
844             if (v->profile < PROFILE_ADVANCED) {
845                 qx = (s->mb_x << 5);
846                 qy = (s->mb_y << 5);
847                 X  = (s->mb_width  << 5) - 4;
848                 Y  = (s->mb_height << 5) - 4;
849                 if (qx + px < -28) px = -28 - qx;
850                 if (qy + py < -28) py = -28 - qy;
851                 if (qx + px > X) px = X - qx;
852                 if (qy + py > Y) py = Y - qy;
853             } else {
854                 qx = (s->mb_x << 6);
855                 qy = (s->mb_y << 6);
856                 X  = (s->mb_width  << 6) - 4;
857                 Y  = (s->mb_height << 6) - 4;
858                 if (qx + px < -60) px = -60 - qx;
859                 if (qy + py < -60) py = -60 - qy;
860                 if (qx + px > X) px = X - qx;
861                 if (qy + py > Y) py = Y - qy;
862             }
863         }
864         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
865         if (0 && !s->first_slice_line && s->mb_x) {
866             if (is_intra[xy - wrap])
867                 sum = FFABS(px) + FFABS(py);
868             else
869                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
870             if (sum > 32) {
871                 if (get_bits1(&s->gb)) {
872                     px = A[0];
873                     py = A[1];
874                 } else {
875                     px = C[0];
876                     py = C[1];
877                 }
878             } else {
879                 if (is_intra[xy - 2])
880                     sum = FFABS(px) + FFABS(py);
881                 else
882                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
883                 if (sum > 32) {
884                     if (get_bits1(&s->gb)) {
885                         px = A[0];
886                         py = A[1];
887                     } else {
888                         px = C[0];
889                         py = C[1];
890                     }
891                 }
892             }
893         }
894         /* store MV using signed modulus of MV range defined in 4.11 */
895
896         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
897         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
898     }
899     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
900     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
901     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
902     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
903 }
904
905 void ff_vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y,
906                             int mv1, int *pred_flag)
907 {
908     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
909     MpegEncContext *s = &v->s;
910     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
911
912     if (v->bmvtype == BMV_TYPE_DIRECT) {
913         int total_opp, k, f;
914         if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
915             s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
916                                       v->bfraction, 0, s->quarter_sample);
917             s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
918                                       v->bfraction, 0, s->quarter_sample);
919             s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
920                                       v->bfraction, 1, s->quarter_sample);
921             s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
922                                       v->bfraction, 1, s->quarter_sample);
923
924             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
925                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
926                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
927                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
928             f = (total_opp > 2) ? 1 : 0;
929         } else {
930             s->mv[0][0][0] = s->mv[0][0][1] = 0;
931             s->mv[1][0][0] = s->mv[1][0][1] = 0;
932             f = 0;
933         }
934         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
935         for (k = 0; k < 4; k++) {
936             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
937             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
938             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
939             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
940             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
941             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
942         }
943         return;
944     }
945     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
946         ff_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);
947         ff_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);
948         return;
949     }
950     if (dir) { // backward
951         ff_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);
952         if (n == 3 || mv1) {
953             ff_vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
954         }
955     } else { // forward
956         ff_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);
957         if (n == 3 || mv1) {
958             ff_vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
959         }
960     }
961 }