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