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  vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4389  }
4390  mb_has_coeffs = idx_mbmode & 1;
4391  }
4392  if (mb_has_coeffs)
4393  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4394  if (cbp) {
4395  GET_MQUANT();
4396  }
4397  s->current_picture.qscale_table[mb_pos] = mquant;
4398  if (!v->ttmbf && cbp) {
4399  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4400  }
4401  dst_idx = 0;
4402  for (i = 0; i < 6; i++) {
4403  s->dc_val[0][s->block_index[i]] = 0;
4404  dst_idx += i >> 2;
4405  val = ((cbp >> (5 - i)) & 1);
4406  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4407  if (val) {
4408  vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4409  first_block, s->dest[dst_idx] + off,
4410  (i & 4) ? s->uvlinesize : s->linesize,
4411  (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4412  if (!v->ttmbf && ttmb < 8)
4413  ttmb = -1;
4414  first_block = 0;
4415  }
4416  }
4417  }
4418 }
4419 
4420 /** Decode one B-frame MB (in interlaced frame B picture)
4421  */
4422 static int vc1_decode_b_mb_intfr(VC1Context *v)
4423 {
4424  MpegEncContext *s = &v->s;
4425  GetBitContext *gb = &s->gb;
4426  int i, j;
4427  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4428  int cbp = 0; /* cbp decoding stuff */
4429  int mqdiff, mquant; /* MB quantization */
4430  int ttmb = v->ttfrm; /* MB Transform type */
4431  int mvsw = 0; /* motion vector switch */
4432  int mb_has_coeffs = 1; /* last_flag */
4433  int dmv_x, dmv_y; /* Differential MV components */
4434  int val; /* temp value */
4435  int first_block = 1;
4436  int dst_idx, off;
4437  int skipped, direct, twomv = 0;
4438  int block_cbp = 0, pat, block_tt = 0;
4439  int idx_mbmode = 0, mvbp;
4440  int stride_y, fieldtx;
4441  int bmvtype = BMV_TYPE_BACKWARD;
4442  int dir, dir2;
4443 
4444  mquant = v->pq; /* Lossy initialization */
4445  s->mb_intra = 0;
4446  if (v->skip_is_raw)
4447  skipped = get_bits1(gb);
4448  else
4449  skipped = v->s.mbskip_table[mb_pos];
4450 
4451  if (!skipped) {
4452  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4453  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4454  twomv = 1;
4455  v->blk_mv_type[s->block_index[0]] = 1;
4456  v->blk_mv_type[s->block_index[1]] = 1;
4457  v->blk_mv_type[s->block_index[2]] = 1;
4458  v->blk_mv_type[s->block_index[3]] = 1;
4459  } else {
4460  v->blk_mv_type[s->block_index[0]] = 0;
4461  v->blk_mv_type[s->block_index[1]] = 0;
4462  v->blk_mv_type[s->block_index[2]] = 0;
4463  v->blk_mv_type[s->block_index[3]] = 0;
4464  }
4465  }
4466 
4467  if (v->dmb_is_raw)
4468  direct = get_bits1(gb);
4469  else
4470  direct = v->direct_mb_plane[mb_pos];
4471 
4472  if (direct) {
4473  if (s->next_picture_ptr->field_picture)
4474  av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
4475  s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
4476  s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
4477  s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
4478  s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
4479 
4480  if (twomv) {
4481  s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
4482  s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
4483  s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
4484  s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
4485 
4486  for (i = 1; i < 4; i += 2) {
4487  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4488  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4489  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4490  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4491  }
4492  } else {
4493  for (i = 1; i < 4; i++) {
4494  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4495  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4496  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4497  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4498  }
4499  }
4500  }
4501 
4502  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4503  for (i = 0; i < 4; i++) {
4504  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4505  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4506  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4507  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4508  }
4509  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4510  s->mb_intra = v->is_intra[s->mb_x] = 1;
4511  for (i = 0; i < 6; i++)
4512  v->mb_type[0][s->block_index[i]] = 1;
4513  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4514  mb_has_coeffs = get_bits1(gb);
4515  if (mb_has_coeffs)
4516  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4517  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4518  GET_MQUANT();
4519  s->current_picture.qscale_table[mb_pos] = mquant;
4520  /* Set DC scale - y and c use the same (not sure if necessary here) */
4521  s->y_dc_scale = s->y_dc_scale_table[mquant];
4522  s->c_dc_scale = s->c_dc_scale_table[mquant];
4523  dst_idx = 0;
4524  for (i = 0; i < 6; i++) {
4525  s->dc_val[0][s->block_index[i]] = 0;
4526  dst_idx += i >> 2;
4527  val = ((cbp >> (5 - i)) & 1);
4528  v->mb_type[0][s->block_index[i]] = s->mb_intra;
4529  v->a_avail = v->c_avail = 0;
4530  if (i == 2 || i == 3 || !s->first_slice_line)
4531  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4532  if (i == 1 || i == 3 || s->mb_x)
4533  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4534 
4535  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4536  (i & 4) ? v->codingset2 : v->codingset);
4537  if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4538  continue;
4539  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4540  if (i < 4) {
4541  stride_y = s->linesize << fieldtx;
4542  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4543  } else {
4544  stride_y = s->uvlinesize;
4545  off = 0;
4546  }
4547  s->idsp.put_signed_pixels_clamped(s->block[i],
4548  s->dest[dst_idx] + off,
4549  stride_y);
4550  }
4551  } else {
4552  s->mb_intra = v->is_intra[s->mb_x] = 0;
4553  if (!direct) {
4554  if (skipped || !s->mb_intra) {
4555  bmvtype = decode012(gb);
4556  switch (bmvtype) {
4557  case 0:
4558  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4559  break;
4560  case 1:
4561  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4562  break;
4563  case 2:
4564  bmvtype = BMV_TYPE_INTERPOLATED;
4565  }
4566  }
4567 
4568  if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4569  mvsw = get_bits1(gb);
4570  }
4571 
4572  if (!skipped) { // inter MB
4573  mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4574  if (mb_has_coeffs)
4575  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4576  if (!direct) {
4577  if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
4578  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4579  } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
4580  v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4581  }
4582  }
4583 
4584  for (i = 0; i < 6; i++)
4585  v->mb_type[0][s->block_index[i]] = 0;
4586  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4587  /* for all motion vector read MVDATA and motion compensate each block */
4588  dst_idx = 0;
4589  if (direct) {
4590  if (twomv) {
4591  for (i = 0; i < 4; i++) {
4592  vc1_mc_4mv_luma(v, i, 0, 0);
4593  vc1_mc_4mv_luma(v, i, 1, 1);
4594  }
4595  vc1_mc_4mv_chroma4(v, 0, 0, 0);
4596  vc1_mc_4mv_chroma4(v, 1, 1, 1);
4597  } else {
4598  vc1_mc_1mv(v, 0);
4599  vc1_interp_mc(v);
4600  }
4601  } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4602  mvbp = v->fourmvbp;
4603  for (i = 0; i < 4; i++) {
4604  dir = i==1 || i==3;
4605  dmv_x = dmv_y = 0;
4606  val = ((mvbp >> (3 - i)) & 1);
4607  if (val)
4608  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4609  j = i > 1 ? 2 : 0;
4610  vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4611  vc1_mc_4mv_luma(v, j, dir, dir);
4612  vc1_mc_4mv_luma(v, j+1, dir, dir);
4613  }
4614 
4615  vc1_mc_4mv_chroma4(v, 0, 0, 0);
4616  vc1_mc_4mv_chroma4(v, 1, 1, 1);
4617  } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4618  mvbp = v->twomvbp;
4619  dmv_x = dmv_y = 0;
4620  if (mvbp & 2)
4621  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4622 
4623  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4624  vc1_mc_1mv(v, 0);
4625 
4626  dmv_x = dmv_y = 0;
4627  if (mvbp & 1)
4628  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4629 
4630  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4631  vc1_interp_mc(v);
4632  } else if (twomv) {
4633  dir = bmvtype == BMV_TYPE_BACKWARD;
4634  dir2 = dir;
4635  if (mvsw)
4636  dir2 = !dir;
4637  mvbp = v->twomvbp;
4638  dmv_x = dmv_y = 0;
4639  if (mvbp & 2)
4640  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4641  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4642 
4643  dmv_x = dmv_y = 0;
4644  if (mvbp & 1)
4645  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4646  vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4647 
4648  if (mvsw) {
4649  for (i = 0; i < 2; i++) {
4650  s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4651  s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4652  s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4653  s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4654  }
4655  } else {
4656  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4657  vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4658  }
4659 
4660  vc1_mc_4mv_luma(v, 0, dir, 0);
4661  vc1_mc_4mv_luma(v, 1, dir, 0);
4662  vc1_mc_4mv_luma(v, 2, dir2, 0);
4663  vc1_mc_4mv_luma(v, 3, dir2, 0);
4664  vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4665  } else {
4666  dir = bmvtype == BMV_TYPE_BACKWARD;
4667 
4668  mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4669  dmv_x = dmv_y = 0;
4670  if (mvbp)
4671  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4672 
4673  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4674  v->blk_mv_type[s->block_index[0]] = 1;
4675  v->blk_mv_type[s->block_index[1]] = 1;
4676  v->blk_mv_type[s->block_index[2]] = 1;
4677  v->blk_mv_type[s->block_index[3]] = 1;
4678  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4679  for (i = 0; i < 2; i++) {
4680  s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4681  s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4682  }
4683  vc1_mc_1mv(v, dir);
4684  }
4685 
4686  if (cbp)
4687  GET_MQUANT(); // p. 227
4688  s->current_picture.qscale_table[mb_pos] = mquant;
4689  if (!v->ttmbf && cbp)
4690  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4691  for (i = 0; i < 6; i++) {
4692  s->dc_val[0][s->block_index[i]] = 0;
4693  dst_idx += i >> 2;
4694  val = ((cbp >> (5 - i)) & 1);
4695  if (!fieldtx)
4696  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4697  else
4698  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4699  if (val) {
4700  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4701  first_block, s->dest[dst_idx] + off,
4702  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4703  (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4704  block_cbp |= pat << (i << 2);
4705  if (!v->ttmbf && ttmb < 8)
4706  ttmb = -1;
4707  first_block = 0;
4708  }
4709  }
4710 
4711  } else { // skipped
4712  dir = 0;
4713  for (i = 0; i < 6; i++) {
4714  v->mb_type[0][s->block_index[i]] = 0;
4715  s->dc_val[0][s->block_index[i]] = 0;
4716  }
4717  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4718  s->current_picture.qscale_table[mb_pos] = 0;
4719  v->blk_mv_type[s->block_index[0]] = 0;
4720  v->blk_mv_type[s->block_index[1]] = 0;
4721  v->blk_mv_type[s->block_index[2]] = 0;
4722  v->blk_mv_type[s->block_index[3]] = 0;
4723 
4724  if (!direct) {
4725  if (bmvtype == BMV_TYPE_INTERPOLATED) {
4726  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4727  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4728  } else {
4729  dir = bmvtype == BMV_TYPE_BACKWARD;
4730  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4731  if (mvsw) {
4732  int dir2 = dir;
4733  if (mvsw)
4734  dir2 = !dir;
4735  for (i = 0; i < 2; i++) {
4736  s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
4737  s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
4738  s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
4739  s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
4740  }
4741  } else {
4742  v->blk_mv_type[s->block_index[0]] = 1;
4743  v->blk_mv_type[s->block_index[1]] = 1;
4744  v->blk_mv_type[s->block_index[2]] = 1;
4745  v->blk_mv_type[s->block_index[3]] = 1;
4746  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4747  for (i = 0; i < 2; i++) {
4748  s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
4749  s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
4750  }
4751  }
4752  }
4753  }
4754 
4755  vc1_mc_1mv(v, dir);
4756  if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4757  vc1_interp_mc(v);
4758  }
4759  }
4760  }
4761  if (s->mb_x == s->mb_width - 1)
4762  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4763  v->cbp[s->mb_x] = block_cbp;
4764  v->ttblk[s->mb_x] = block_tt;
4765  return 0;
4766 }
4767 
4768 /** Decode blocks of I-frame
4769  */
4770 static void vc1_decode_i_blocks(VC1Context *v)
4771 {
4772  int k, j;
4773  MpegEncContext *s = &v->s;
4774  int cbp, val;
4775  uint8_t *coded_val;
4776  int mb_pos;
4777 
4778  /* select codingmode used for VLC tables selection */
4779  switch (v->y_ac_table_index) {
4780  case 0:
4781  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4782  break;
4783  case 1:
4784  v->codingset = CS_HIGH_MOT_INTRA;
4785  break;
4786  case 2:
4787  v->codingset = CS_MID_RATE_INTRA;
4788  break;
4789  }
4790 
4791  switch (v->c_ac_table_index) {
4792  case 0:
4793  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4794  break;
4795  case 1:
4796  v->codingset2 = CS_HIGH_MOT_INTER;
4797  break;
4798  case 2:
4799  v->codingset2 = CS_MID_RATE_INTER;
4800  break;
4801  }
4802 
4803  /* Set DC scale - y and c use the same */
4804  s->y_dc_scale = s->y_dc_scale_table[v->pq];
4805  s->c_dc_scale = s->c_dc_scale_table[v->pq];
4806 
4807  //do frame decode
4808  s->mb_x = s->mb_y = 0;
4809  s->mb_intra = 1;
4810  s->first_slice_line = 1;
4811  for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4812  s->mb_x = 0;
4813  init_block_index(v);
4814  for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4815  uint8_t *dst[6];
4816  ff_update_block_index(s);
4817  dst[0] = s->dest[0];
4818  dst[1] = dst[0] + 8;
4819  dst[2] = s->dest[0] + s->linesize * 8;
4820  dst[3] = dst[2] + 8;
4821  dst[4] = s->dest[1];
4822  dst[5] = s->dest[2];
4823  s->bdsp.clear_blocks(s->block[0]);
4824  mb_pos = s->mb_x + s->mb_y * s->mb_width;
4825  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4826  s->current_picture.qscale_table[mb_pos] = v->pq;
4827  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4828  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4829 
4830  // do actual MB decoding and displaying
4831  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4832  v->s.ac_pred = get_bits1(&v->s.gb);
4833 
4834  for (k = 0; k < 6; k++) {
4835  val = ((cbp >> (5 - k)) & 1);
4836 
4837  if (k < 4) {
4838  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4839  val = val ^ pred;
4840  *coded_val = val;
4841  }
4842  cbp |= val << (5 - k);
4843 
4844  vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4845 
4846  if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4847  continue;
4848  v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4849  if (v->pq >= 9 && v->overlap) {
4850  if (v->rangeredfrm)
4851  for (j = 0; j < 64; j++)
4852  s->block[k][j] <<= 1;
4853  s->idsp.put_signed_pixels_clamped(s->block[k], dst[k],
4854  k & 4 ? s->uvlinesize
4855  : s->linesize);
4856  } else {
4857  if (v->rangeredfrm)
4858  for (j = 0; j < 64; j++)
4859  s->block[k][j] = (s->block[k][j] - 64) << 1;
4860  s->idsp.put_pixels_clamped(s->block[k], dst[k],
4861  k & 4 ? s->uvlinesize
4862  : s->linesize);
4863  }
4864  }
4865 
4866  if (v->pq >= 9 && v->overlap) {
4867  if (s->mb_x) {
4868  v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4869  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4870  if (!(s->flags & CODEC_FLAG_GRAY)) {
4871  v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4872  v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4873  }
4874  }
4875  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4876  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4877  if (!s->first_slice_line) {
4878  v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4879  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4880  if (!(s->flags & CODEC_FLAG_GRAY)) {
4881  v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4882  v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4883  }
4884  }
4885  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4886  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4887  }
4888  if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4889 
4890  if (get_bits_count(&s->gb) > v->bits) {
4891  ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4892  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4893  get_bits_count(&s->gb), v->bits);
4894  return;
4895  }
4896  }
4897  if (!v->s.loop_filter)
4898  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4899  else if (s->mb_y)
4900  ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4901 
4902  s->first_slice_line = 0;
4903  }
4904  if (v->s.loop_filter)
4905  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4906 
4907  /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4908  * profile, these only differ are when decoding MSS2 rectangles. */
4909  ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4910 }
4911 
4912 /** Decode blocks of I-frame for advanced profile
4913  */
4914 static void vc1_decode_i_blocks_adv(VC1Context *v)
4915 {
4916  int k;
4917  MpegEncContext *s = &v->s;
4918  int cbp, val;
4919  uint8_t *coded_val;
4920  int mb_pos;
4921  int mquant = v->pq;
4922  int mqdiff;
4923  GetBitContext *gb = &s->gb;
4924 
4925  /* select codingmode used for VLC tables selection */
4926  switch (v->y_ac_table_index) {
4927  case 0:
4928  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4929  break;
4930  case 1:
4931  v->codingset = CS_HIGH_MOT_INTRA;
4932  break;
4933  case 2:
4934  v->codingset = CS_MID_RATE_INTRA;
4935  break;
4936  }
4937 
4938  switch (v->c_ac_table_index) {
4939  case 0:
4940  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4941  break;
4942  case 1:
4943  v->codingset2 = CS_HIGH_MOT_INTER;
4944  break;
4945  case 2:
4946  v->codingset2 = CS_MID_RATE_INTER;
4947  break;
4948  }
4949 
4950  // do frame decode
4951  s->mb_x = s->mb_y = 0;
4952  s->mb_intra = 1;
4953  s->first_slice_line = 1;
4954  s->mb_y = s->start_mb_y;
4955  if (s->start_mb_y) {
4956  s->mb_x = 0;
4957  init_block_index(v);
4958  memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4959  (1 + s->b8_stride) * sizeof(*s->coded_block));
4960  }
4961  for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4962  s->mb_x = 0;
4963  init_block_index(v);
4964  for (;s->mb_x < s->mb_width; s->mb_x++) {
4965  int16_t (*block)[64] = v->block[v->cur_blk_idx];
4966  ff_update_block_index(s);
4967  s->bdsp.clear_blocks(block[0]);
4968  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4969  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4970  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4971  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4972 
4973  // do actual MB decoding and displaying
4974  if (v->fieldtx_is_raw)
4975  v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4976  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4977  if ( v->acpred_is_raw)
4978  v->s.ac_pred = get_bits1(&v->s.gb);
4979  else
4980  v->s.ac_pred = v->acpred_plane[mb_pos];
4981 
4982  if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4983  v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4984 
4985  GET_MQUANT();
4986 
4987  s->current_picture.qscale_table[mb_pos] = mquant;
4988  /* Set DC scale - y and c use the same */
4989  s->y_dc_scale = s->y_dc_scale_table[mquant];
4990  s->c_dc_scale = s->c_dc_scale_table[mquant];
4991 
4992  for (k = 0; k < 6; k++) {
4993  val = ((cbp >> (5 - k)) & 1);
4994 
4995  if (k < 4) {
4996  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4997  val = val ^ pred;
4998  *coded_val = val;
4999  }
5000  cbp |= val << (5 - k);
5001 
5002  v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
5003  v->c_avail = !!s->mb_x || (k == 1 || k == 3);
5004 
5005  vc1_decode_i_block_adv(v, block[k], k, val,
5006  (k < 4) ? v->codingset : v->codingset2, mquant);
5007 
5008  if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
5009  continue;
5010  v->vc1dsp.vc1_inv_trans_8x8(block[k]);
5011  }
5012 
5013  vc1_smooth_overlap_filter_iblk(v);
5014  vc1_put_signed_blocks_clamped(v);
5015  if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
5016 
5017  if (get_bits_count(&s->gb) > v->bits) {
5018  // TODO: may need modification to handle slice coding
5019  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5020  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
5021  get_bits_count(&s->gb), v->bits);
5022  return;
5023  }
5024  }
5025  if (!v->s.loop_filter)
5026  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5027  else if (s->mb_y)
5028  ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
5029  s->first_slice_line = 0;
5030  }
5031 
5032  /* raw bottom MB row */
5033  s->mb_x = 0;
5034  init_block_index(v);
5035 
5036  for (;s->mb_x < s->mb_width; s->mb_x++) {
5037  ff_update_block_index(s);
5038  vc1_put_signed_blocks_clamped(v);
5039  if (v->s.loop_filter)
5040  vc1_loop_filter_iblk_delayed(v, v->pq);
5041  }
5042  if (v->s.loop_filter)
5043  ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5044  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5045  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5046 }
5047 
5048 static void vc1_decode_p_blocks(VC1Context *v)
5049 {
5050  MpegEncContext *s = &v->s;
5051  int apply_loop_filter;
5052 
5053  /* select codingmode used for VLC tables selection */
5054  switch (v->c_ac_table_index) {
5055  case 0:
5056  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5057  break;
5058  case 1:
5059  v->codingset = CS_HIGH_MOT_INTRA;
5060  break;
5061  case 2:
5062  v->codingset = CS_MID_RATE_INTRA;
5063  break;
5064  }
5065 
5066  switch (v->c_ac_table_index) {
5067  case 0:
5068  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5069  break;
5070  case 1:
5071  v->codingset2 = CS_HIGH_MOT_INTER;
5072  break;
5073  case 2:
5074  v->codingset2 = CS_MID_RATE_INTER;
5075  break;
5076  }
5077 
5078  apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5079  v->fcm == PROGRESSIVE;
5080  s->first_slice_line = 1;
5081  memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5082  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5083  s->mb_x = 0;
5084  init_block_index(v);
5085  for (; s->mb_x < s->mb_width; s->mb_x++) {
5086  ff_update_block_index(s);
5087 
5088  if (v->fcm == ILACE_FIELD)
5089  vc1_decode_p_mb_intfi(v);
5090  else if (v->fcm == ILACE_FRAME)
5091  vc1_decode_p_mb_intfr(v);
5092  else vc1_decode_p_mb(v);
5093  if (s->mb_y != s->start_mb_y && apply_loop_filter)
5094  vc1_apply_p_loop_filter(v);
5095  if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5096  // TODO: may need modification to handle slice coding
5097  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5098  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5099  get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5100  return;
5101  }
5102  }
5103  memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5104  memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5105  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5106  memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5107  if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5108  s->first_slice_line = 0;
5109  }
5110  if (apply_loop_filter) {
5111  s->mb_x = 0;
5112  init_block_index(v);
5113  for (; s->mb_x < s->mb_width; s->mb_x++) {
5114  ff_update_block_index(s);
5115  vc1_apply_p_loop_filter(v);
5116  }
5117  }
5118  if (s->end_mb_y >= s->start_mb_y)
5119  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5120  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5121  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5122 }
5123 
5124 static void vc1_decode_b_blocks(VC1Context *v)
5125 {
5126  MpegEncContext *s = &v->s;
5127 
5128  /* select codingmode used for VLC tables selection */
5129  switch (v->c_ac_table_index) {
5130  case 0:
5131  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5132  break;
5133  case 1:
5134  v->codingset = CS_HIGH_MOT_INTRA;
5135  break;
5136  case 2:
5137  v->codingset = CS_MID_RATE_INTRA;
5138  break;
5139  }
5140 
5141  switch (v->c_ac_table_index) {
5142  case 0:
5143  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5144  break;
5145  case 1:
5146  v->codingset2 = CS_HIGH_MOT_INTER;
5147  break;
5148  case 2:
5149  v->codingset2 = CS_MID_RATE_INTER;
5150  break;
5151  }
5152 
5153  s->first_slice_line = 1;
5154  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5155  s->mb_x = 0;
5156  init_block_index(v);
5157  for (; s->mb_x < s->mb_width; s->mb_x++) {
5158  ff_update_block_index(s);
5159 
5160  if (v->fcm == ILACE_FIELD)
5161  vc1_decode_b_mb_intfi(v);
5162  else if (v->fcm == ILACE_FRAME)
5163  vc1_decode_b_mb_intfr(v);
5164  else
5165  vc1_decode_b_mb(v);
5166  if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5167  // TODO: may need modification to handle slice coding
5168  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5169  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5170  get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5171  return;
5172  }
5173  if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5174  }
5175  if (!v->s.loop_filter)
5176  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5177  else if (s->mb_y)
5178  ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5179  s->first_slice_line = 0;
5180  }
5181  if (v->s.loop_filter)
5182  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5183  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5184  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5185 }
5186 
5187 static void vc1_decode_skip_blocks(VC1Context *v)
5188 {
5189  MpegEncContext *s = &v->s;
5190 
5191  if (!v->s.last_picture.f->data[0])
5192  return;
5193 
5194  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5195  s->first_slice_line = 1;
5196  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5197  s->mb_x = 0;
5198  init_block_index(v);
5199  ff_update_block_index(s);
5200  memcpy(s->dest[0], s->last_picture.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5201  memcpy(s->dest[1], s->last_picture.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5202  memcpy(s->dest[2], s->last_picture.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5203  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5204  s->first_slice_line = 0;
5205  }
5206  s->pict_type = AV_PICTURE_TYPE_P;
5207 }
5208 
5209 void ff_vc1_decode_blocks(VC1Context *v)
5210 {
5211 
5212  v->s.esc3_level_length = 0;
5213  if (v->x8_type) {
5214  ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5215  } else {
5216  v->cur_blk_idx = 0;
5217  v->left_blk_idx = -1;
5218  v->topleft_blk_idx = 1;
5219  v->top_blk_idx = 2;
5220  switch (v->s.pict_type) {
5221  case AV_PICTURE_TYPE_I:
5222  if (v->profile == PROFILE_ADVANCED)
5223  vc1_decode_i_blocks_adv(v);
5224  else
5225  vc1_decode_i_blocks(v);
5226  break;
5227  case AV_PICTURE_TYPE_P:
5228  if (v->p_frame_skipped)
5229  vc1_decode_skip_blocks(v);
5230  else
5231  vc1_decode_p_blocks(v);
5232  break;
5233  case AV_PICTURE_TYPE_B:
5234  if (v->bi_type) {
5235  if (v->profile == PROFILE_ADVANCED)
5236  vc1_decode_i_blocks_adv(v);
5237  else
5238  vc1_decode_i_blocks(v);
5239  } else
5240  vc1_decode_b_blocks(v);
5241  break;
5242  }
5243  }
5244 }
5245 
5246 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5247 
5248 typedef struct {
5249  /**
5250  * Transform coefficients for both sprites in 16.16 fixed point format,
5251  * in the order they appear in the bitstream:
5252  * x scale
5253  * rotation 1 (unused)
5254  * x offset
5255  * rotation 2 (unused)
5256  * y scale
5257  * y offset
5258  * alpha
5259  */
5260  int coefs[2][7];
5261 
5262  int effect_type, effect_flag;
5263  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5264  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5265 } SpriteData;
5266 
5267 static inline int get_fp_val(GetBitContext* gb)
5268 {
5269  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5270 }
5271 
5272 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5273 {
5274  c[1] = c[3] = 0;
5275 
5276  switch (get_bits(gb, 2)) {
5277  case 0:
5278  c[0] = 1 << 16;
5279  c[2] = get_fp_val(gb);
5280  c[4] = 1 << 16;
5281  break;
5282  case 1:
5283  c[0] = c[4] = get_fp_val(gb);
5284  c[2] = get_fp_val(gb);
5285  break;
5286  case 2:
5287  c[0] = get_fp_val(gb);
5288  c[2] = get_fp_val(gb);
5289  c[4] = get_fp_val(gb);
5290  break;
5291  case 3:
5292  c[0] = get_fp_val(gb);
5293  c[1] = get_fp_val(gb);
5294  c[2] = get_fp_val(gb);
5295  c[3] = get_fp_val(gb);
5296  c[4] = get_fp_val(gb);
5297  break;
5298  }
5299  c[5] = get_fp_val(gb);
5300  if (get_bits1(gb))
5301  c[6] = get_fp_val(gb);
5302  else
5303  c[6] = 1 << 16;
5304 }
5305 
5306 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5307 {
5308  AVCodecContext *avctx = v->s.avctx;
5309  int sprite, i;
5310 
5311  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5312  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5313  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5314  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5315  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5316  for (i = 0; i < 7; i++)
5317  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5318  sd->coefs[sprite][i] / (1<<16),
5319  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5320  av_log(avctx, AV_LOG_DEBUG, "\n");
5321  }
5322 
5323  skip_bits(gb, 2);
5324  if (sd->effect_type = get_bits_long(gb, 30)) {
5325  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5326  case 7:
5327  vc1_sprite_parse_transform(gb, sd->effect_params1);
5328  break;
5329  case 14:
5330  vc1_sprite_parse_transform(gb, sd->effect_params1);
5331  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5332  break;
5333  default:
5334  for (i = 0; i < sd->effect_pcount1; i++)
5335  sd->effect_params1[i] = get_fp_val(gb);
5336  }
5337  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5338  // effect 13 is simple alpha blending and matches the opacity above
5339  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5340  for (i = 0; i < sd->effect_pcount1; i++)
5341  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5342  sd->effect_params1[i] / (1 << 16),
5343  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5344  av_log(avctx, AV_LOG_DEBUG, "\n");
5345  }
5346 
5347  sd->effect_pcount2 = get_bits(gb, 16);
5348  if (sd->effect_pcount2 > 10) {
5349  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5350  return AVERROR_INVALIDDATA;
5351  } else if (sd->effect_pcount2) {
5352  i = -1;
5353  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5354  while (++i < sd->effect_pcount2) {
5355  sd->effect_params2[i] = get_fp_val(gb);
5356  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5357  sd->effect_params2[i] / (1 << 16),
5358  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5359  }
5360  av_log(avctx, AV_LOG_DEBUG, "\n");
5361  }
5362  }
5363  if (sd->effect_flag = get_bits1(gb))
5364  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5365 
5366  if (get_bits_count(gb) >= gb->size_in_bits +
5367  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
5368  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5369  return AVERROR_INVALIDDATA;
5370  }
5371  if (get_bits_count(gb) < gb->size_in_bits - 8)
5372  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5373 
5374  return 0;
5375 }
5376 
5377 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5378 {
5379  int i, plane, row, sprite;
5380  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5381  uint8_t* src_h[2][2];
5382  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5383  int ysub[2];
5384  MpegEncContext *s = &v->s;
5385 
5386  for (i = 0; i <= v->two_sprites; i++) {
5387  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5388  xadv[i] = sd->coefs[i][0];
5389  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5390  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5391 
5392  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5393  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5394  }
5395  alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5396 
5397  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5398  int width = v->output_width>>!!plane;
5399 
5400  for (row = 0; row < v->output_height>>!!plane; row++) {
5401  uint8_t *dst = v->sprite_output_frame->data[plane] +
5402  v->sprite_output_frame->linesize[plane] * row;
5403 
5404  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5405  uint8_t *iplane = s->current_picture.f->data[plane];
5406  int iline = s->current_picture.f->linesize[plane];
5407  int ycoord = yoff[sprite] + yadv[sprite] * row;
5408  int yline = ycoord >> 16;
5409  int next_line;
5410  ysub[sprite] = ycoord & 0xFFFF;
5411  if (sprite) {
5412  iplane = s->last_picture.f->data[plane];
5413  iline = s->last_picture.f->linesize[plane];
5414  }
5415  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5416  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5417  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5418  if (ysub[sprite])
5419  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5420  } else {
5421  if (sr_cache[sprite][0] != yline) {
5422  if (sr_cache[sprite][1] == yline) {
5423  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5424  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5425  } else {
5426  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5427  sr_cache[sprite][0] = yline;
5428  }
5429  }
5430  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5431  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5432  iplane + next_line, xoff[sprite],
5433  xadv[sprite], width);
5434  sr_cache[sprite][1] = yline + 1;
5435  }
5436  src_h[sprite][0] = v->sr_rows[sprite][0];
5437  src_h[sprite][1] = v->sr_rows[sprite][1];
5438  }
5439  }
5440 
5441  if (!v->two_sprites) {
5442  if (ysub[0]) {
5443  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5444  } else {
5445  memcpy(dst, src_h[0][0], width);
5446  }
5447  } else {
5448  if (ysub[0] && ysub[1]) {
5449  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5450  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5451  } else if (ysub[0]) {
5452  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5453  src_h[1][0], alpha, width);
5454  } else if (ysub[1]) {
5455  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5456  src_h[0][0], (1<<16)-1-alpha, width);
5457  } else {
5458  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5459  }
5460  }
5461  }
5462 
5463  if (!plane) {
5464  for (i = 0; i <= v->two_sprites; i++) {
5465  xoff[i] >>= 1;
5466  yoff[i] >>= 1;
5467  }
5468  }
5469 
5470  }
5471 }
5472 
5473 
5474 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5475 {
5476  int ret;
5477  MpegEncContext *s = &v->s;
5478  AVCodecContext *avctx = s->avctx;
5479  SpriteData sd;
5480 
5481  memset(&sd, 0, sizeof(sd));
5482 
5483  ret = vc1_parse_sprites(v, gb, &sd);
5484  if (ret < 0)
5485  return ret;
5486 
5487  if (!s->current_picture.f->data[0]) {
5488  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5489  return -1;
5490  }
5491 
5492  if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
5493  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5494  v->two_sprites = 0;
5495  }
5496 
5497  av_frame_unref(v->sprite_output_frame);
5498  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
5499  return ret;
5500 
5501  vc1_draw_sprites(v, &sd);
5502 
5503  return 0;
5504 }
5505 
5506 static void vc1_sprite_flush(AVCodecContext *avctx)
5507 {
5508  VC1Context *v = avctx->priv_data;
5509  MpegEncContext *s = &v->s;
5510  AVFrame *f = s->current_picture.f;
5511  int plane, i;
5512 
5513  /* Windows Media Image codecs have a convergence interval of two keyframes.
5514  Since we can't enforce it, clear to black the missing sprite. This is
5515  wrong but it looks better than doing nothing. */
5516 
5517  if (f->data[0])
5518  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5519  for (i = 0; i < v->sprite_height>>!!plane; i++)
5520  memset(f->data[plane] + i * f->linesize[plane],
5521  plane ? 128 : 0, f->linesize[plane]);
5522 }
5523 
5524 #endif
5525 
5526 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5527 {
5528  MpegEncContext *s = &v->s;
5529  int i;
5530  int mb_height = FFALIGN(s->mb_height, 2);
5531 
5532  /* Allocate mb bitplanes */
5533  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
5534  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
5535  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
5536  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
5537  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
5538  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
5539 
5540  v->n_allocated_blks = s->mb_width + 2;
5541  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5542  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5543  v->cbp = v->cbp_base + s->mb_stride;
5544  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5545  v->ttblk = v->ttblk_base + s->mb_stride;
5546  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5547  v->is_intra = v->is_intra_base + s->mb_stride;
5548  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5549  v->luma_mv = v->luma_mv_base + s->mb_stride;
5550 
5551  /* allocate block type info in that way so it could be used with s->block_index[] */
5552  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5553  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5554  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
5555  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
5556 
5557  /* allocate memory to store block level MV info */
5558  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5559  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5560  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5561  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5562  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5563  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5564  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5565  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5566 
5567  /* Init coded blocks info */
5568  if (v->profile == PROFILE_ADVANCED) {
5569 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5570 // return -1;
5571 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5572 // return -1;
5573  }
5574 
5575  ff_intrax8_common_init(&v->x8,s);
5576 
5577  if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5578  for (i = 0; i < 4; i++)
5579  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5580  return AVERROR(ENOMEM);
5581  }
5582 
5583  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5584  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5585  !v->mb_type_base) {
5586  av_freep(&v->mv_type_mb_plane);
5587  av_freep(&v->direct_mb_plane);
5588  av_freep(&v->acpred_plane);
5589  av_freep(&v->over_flags_plane);
5590  av_freep(&v->block);
5591  av_freep(&v->cbp_base);
5592  av_freep(&v->ttblk_base);
5593  av_freep(&v->is_intra_base);
5594  av_freep(&v->luma_mv_base);
5595  av_freep(&v->mb_type_base);
5596  return AVERROR(ENOMEM);
5597  }
5598 
5599  return 0;
5600 }
5601 
5602 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5603 {
5604  int i;
5605  for (i = 0; i < 64; i++) {
5606 #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
5607  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5608  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5609  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5610  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5611  v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5612  }
5613  v->left_blk_sh = 0;
5614  v->top_blk_sh = 3;
5615 }
5616 
5617 /** Initialize a VC1/WMV3 decoder
5618  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5619  * @todo TODO: Decypher remaining bits in extra_data
5620  */
5621 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5622 {
5623  VC1Context *v = avctx->priv_data;
5624  MpegEncContext *s = &v->s;
5625  GetBitContext gb;
5626  int ret;
5627 
5628  /* save the container output size for WMImage */
5629  v->output_width = avctx->width;
5630  v->output_height = avctx->height;
5631 
5632  if (!avctx->extradata_size || !avctx->extradata)
5633  return -1;
5634  if (!(avctx->flags & CODEC_FLAG_GRAY))
5635  avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
5636  else
5637  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5638  v->s.avctx = avctx;
5639 
5640  if ((ret = ff_vc1_init_common(v)) < 0)
5641  return ret;
5642  // ensure static VLC tables are initialized
5643  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5644  return ret;
5645  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5646  return ret;
5647  // Hack to ensure the above functions will be called
5648  // again once we know all necessary settings.
5649  // That this is necessary might indicate a bug.
5650  ff_vc1_decode_end(avctx);
5651 
5652  ff_blockdsp_init(&s->bdsp, avctx);
5653  ff_h264chroma_init(&v->h264chroma, 8);
5654  ff_qpeldsp_init(&s->qdsp);
5655 
5656  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5657  int count = 0;
5658 
5659  // looks like WMV3 has a sequence header stored in the extradata
5660  // advanced sequence header may be before the first frame
5661  // the last byte of the extradata is a version number, 1 for the
5662  // samples we can decode
5663 
5664  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5665 
5666  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5667  return ret;
5668 
5669  count = avctx->extradata_size*8 - get_bits_count(&gb);
5670  if (count > 0) {
5671  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5672  count, get_bits(&gb, count));
5673  } else if (count < 0) {
5674  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5675  }
5676  } else { // VC1/WVC1/WVP2
5677  const uint8_t *start = avctx->extradata;
5678  uint8_t *end = avctx->extradata + avctx->extradata_size;
5679  const uint8_t *next;
5680  int size, buf2_size;
5681  uint8_t *buf2 = NULL;
5682  int seq_initialized = 0, ep_initialized = 0;
5683 
5684  if (avctx->extradata_size < 16) {
5685  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5686  return -1;
5687  }
5688 
5689  buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5690  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5691  next = start;
5692  for (; next < end; start = next) {
5693  next = find_next_marker(start + 4, end);
5694  size = next - start - 4;
5695  if (size <= 0)
5696  continue;
5697  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5698  init_get_bits(&gb, buf2, buf2_size * 8);
5699  switch (AV_RB32(start)) {
5700  case VC1_CODE_SEQHDR:
5701  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5702  av_free(buf2);
5703  return ret;
5704  }
5705  seq_initialized = 1;
5706  break;
5707  case VC1_CODE_ENTRYPOINT:
5708  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5709  av_free(buf2);
5710  return ret;
5711  }
5712  ep_initialized = 1;
5713  break;
5714  }
5715  }
5716  av_free(buf2);
5717  if (!seq_initialized || !ep_initialized) {
5718  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5719  return -1;
5720  }
5721  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5722  }
5723 
5724  v->sprite_output_frame = av_frame_alloc();
5725  if (!v->sprite_output_frame)
5726  return AVERROR(ENOMEM);
5727 
5728  avctx->profile = v->profile;
5729  if (v->profile == PROFILE_ADVANCED)
5730  avctx->level = v->level;
5731 
5732  avctx->has_b_frames = !!avctx->max_b_frames;
5733 
5734  s->mb_width = (avctx->coded_width + 15) >> 4;
5735  s->mb_height = (avctx->coded_height + 15) >> 4;
5736 
5737  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5738  ff_vc1_init_transposed_scantables(v);
5739  } else {
5740  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5741  v->left_blk_sh = 3;
5742  v->top_blk_sh = 0;
5743  }
5744 
5745  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5746  v->sprite_width = avctx->coded_width;
5747  v->sprite_height = avctx->coded_height;
5748 
5749  avctx->coded_width = avctx->width = v->output_width;
5750  avctx->coded_height = avctx->height = v->output_height;
5751 
5752  // prevent 16.16 overflows
5753  if (v->sprite_width > 1 << 14 ||
5754  v->sprite_height > 1 << 14 ||
5755  v->output_width > 1 << 14 ||
5756  v->output_height > 1 << 14) return -1;
5757 
5758  if ((v->sprite_width&1) || (v->sprite_height&1)) {
5759  avpriv_request_sample(avctx, "odd sprites support");
5760  return AVERROR_PATCHWELCOME;
5761  }
5762  }
5763  return 0;
5764 }
5765 
5766 /** Close a VC1/WMV3 decoder
5767  * @warning Initial try at using MpegEncContext stuff
5768  */
5769 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5770 {
5771  VC1Context *v = avctx->priv_data;
5772  int i;
5773 
5774  av_frame_free(&v->sprite_output_frame);
5775 
5776  for (i = 0; i < 4; i++)
5777  av_freep(&v->sr_rows[i >> 1][i & 1]);
5778  av_freep(&v->hrd_rate);
5779  av_freep(&v->hrd_buffer);
5780  ff_MPV_common_end(&v->s);
5781  av_freep(&v->mv_type_mb_plane);
5782  av_freep(&v->direct_mb_plane);
5783  av_freep(&v->forward_mb_plane);
5784  av_freep(&v->fieldtx_plane);
5785  av_freep(&v->acpred_plane);
5786  av_freep(&v->over_flags_plane);
5787  av_freep(&v->mb_type_base);
5788  av_freep(&v->blk_mv_type_base);
5789  av_freep(&v->mv_f_base);
5790  av_freep(&v->mv_f_next_base);
5791  av_freep(&v->block);
5792  av_freep(&v->cbp_base);
5793  av_freep(&v->ttblk_base);
5794  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5795  av_freep(&v->luma_mv_base);
5796  ff_intrax8_common_end(&v->x8);
5797  return 0;
5798 }
5799 
5800 
5801 /** Decode a VC1/WMV3 frame
5802  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5803  */
5804 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5805  int *got_frame, AVPacket *avpkt)
5806 {
5807  const uint8_t *buf = avpkt->data;
5808  int buf_size = avpkt->size, n_slices = 0, i, ret;
5809  VC1Context *v = avctx->priv_data;
5810  MpegEncContext *s = &v->s;
5811  AVFrame *pict = data;
5812  uint8_t *buf2 = NULL;
5813  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5814  int mb_height, n_slices1=-1;
5815  struct {
5816  uint8_t *buf;
5817  GetBitContext gb;
5818  int mby_start;
5819  } *slices = NULL, *tmp;
5820 
5821  v->second_field = 0;
5822 
5823  if(s->flags & CODEC_FLAG_LOW_DELAY)
5824  s->low_delay = 1;
5825 
5826  /* no supplementary picture */
5827  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5828  /* special case for last picture */
5829  if (s->low_delay == 0 && s->next_picture_ptr) {
5830  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
5831  return ret;
5832  s->next_picture_ptr = NULL;
5833 
5834  *got_frame = 1;
5835  }
5836 
5837  return buf_size;
5838  }
5839 
5840  if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5841  if (v->profile < PROFILE_ADVANCED)
5842  avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5843  else
5844  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5845  }
5846 
5847  //for advanced profile we may need to parse and unescape data
5848  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5849  int buf_size2 = 0;
5850  buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5851  if (!buf2)
5852  return AVERROR(ENOMEM);
5853 
5854  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5855  const uint8_t *start, *end, *next;
5856  int size;
5857 
5858  next = buf;
5859  for (start = buf, end = buf + buf_size; next < end; start = next) {
5860  next = find_next_marker(start + 4, end);
5861  size = next - start - 4;
5862  if (size <= 0) continue;
5863  switch (AV_RB32(start)) {
5864  case VC1_CODE_FRAME:
5865  if (avctx->hwaccel ||
5866  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5867  buf_start = start;
5868  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5869  break;
5870  case VC1_CODE_FIELD: {
5871  int buf_size3;
5872  if (avctx->hwaccel ||
5873  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5874  buf_start_second_field = start;
5875  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
5876  if (!tmp)
5877  goto err;
5878  slices = tmp;
5879  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5880  if (!slices[n_slices].buf)
5881  goto err;
5882  buf_size3 = vc1_unescape_buffer(start + 4, size,
5883  slices[n_slices].buf);
5884  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5885  buf_size3 << 3);
5886  /* assuming that the field marker is at the exact middle,
5887  hope it's correct */
5888  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5889  n_slices1 = n_slices - 1; // index of the last slice of the first field
5890  n_slices++;
5891  break;
5892  }
5893  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5894  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5895  init_get_bits(&s->gb, buf2, buf_size2 * 8);
5896  ff_vc1_decode_entry_point(avctx, v, &s->gb);
5897  break;
5898  case VC1_CODE_SLICE: {
5899  int buf_size3;
5900  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
5901  if (!tmp)
5902  goto err;
5903  slices = tmp;
5904  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5905  if (!slices[n_slices].buf)
5906  goto err;
5907  buf_size3 = vc1_unescape_buffer(start + 4, size,
5908  slices[n_slices].buf);
5909  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5910  buf_size3 << 3);
5911  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5912  n_slices++;
5913  break;
5914  }
5915  }
5916  }
5917  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5918  const uint8_t *divider;
5919  int buf_size3;
5920 
5921  divider = find_next_marker(buf, buf + buf_size);
5922  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5923  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5924  goto err;
5925  } else { // found field marker, unescape second field
5926  if (avctx->hwaccel ||
5927  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5928  buf_start_second_field = divider;
5929  tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
5930  if (!tmp)
5931  goto err;
5932  slices = tmp;
5933  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5934  if (!slices[n_slices].buf)
5935  goto err;
5936  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5937  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5938  buf_size3 << 3);
5939  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5940  n_slices1 = n_slices - 1;
5941  n_slices++;
5942  }
5943  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5944  } else {
5945  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5946  }
5947  init_get_bits(&s->gb, buf2, buf_size2*8);
5948  } else
5949  init_get_bits(&s->gb, buf, buf_size*8);
5950 
5951  if (v->res_sprite) {
5952  v->new_sprite = !get_bits1(&s->gb);
5953  v->two_sprites = get_bits1(&s->gb);
5954  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5955  we're using the sprite compositor. These are intentionally kept separate
5956  so you can get the raw sprites by using the wmv3 decoder for WMVP or
5957  the vc1 one for WVP2 */
5958  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5959  if (v->new_sprite) {
5960  // switch AVCodecContext parameters to those of the sprites
5961  avctx->width = avctx->coded_width = v->sprite_width;
5962  avctx->height = avctx->coded_height = v->sprite_height;
5963  } else {
5964  goto image;
5965  }
5966  }
5967  }
5968 
5969  if (s->context_initialized &&
5970  (s->width != avctx->coded_width ||
5971  s->height != avctx->coded_height)) {
5972  ff_vc1_decode_end(avctx);
5973  }
5974 
5975  if (!s->context_initialized) {
5976  if (ff_msmpeg4_decode_init(avctx) < 0)
5977  goto err;
5978  if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5979  ff_MPV_common_end(s);
5980  goto err;
5981  }
5982 
5983  s->low_delay = !avctx->has_b_frames || v->res_sprite;
5984 
5985  if (v->profile == PROFILE_ADVANCED) {
5986  if(avctx->coded_width<=1 || avctx->coded_height<=1)
5987  goto err;
5988  s->h_edge_pos = avctx->coded_width;
5989  s->v_edge_pos = avctx->coded_height;
5990  }
5991  }
5992 
5993  // do parse frame header
5994  v->pic_header_flag = 0;
5995  v->first_pic_header_flag = 1;
5996  if (v->profile < PROFILE_ADVANCED) {
5997  if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5998  goto err;
5999  }
6000  } else {
6001  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6002  goto err;
6003  }
6004  }
6005  v->first_pic_header_flag = 0;
6006 
6007  if (avctx->debug & FF_DEBUG_PICT_INFO)
6008  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
6009 
6010  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
6011  && s->pict_type != AV_PICTURE_TYPE_I) {
6012  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
6013  goto err;
6014  }
6015 
6016  if ((s->mb_height >> v->field_mode) == 0) {
6017  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
6018  goto err;
6019  }
6020 
6021  // for skipping the frame
6022  s->current_picture.f->pict_type = s->pict_type;
6023  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
6024 
6025  /* skip B-frames if we don't have reference frames */
6026  if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6027  av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
6028  goto end;
6029  }
6030  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6031  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6032  avctx->skip_frame >= AVDISCARD_ALL) {
6033  goto end;
6034  }
6035 
6036  if (s->next_p_frame_damaged) {
6037  if (s->pict_type == AV_PICTURE_TYPE_B)
6038  goto end;
6039  else
6040  s->next_p_frame_damaged = 0;
6041  }
6042 
6043  if (ff_MPV_frame_start(s, avctx) < 0) {
6044  goto err;
6045  }
6046 
6047  v->s.current_picture_ptr->field_picture = v->field_mode;
6048  v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
6049  v->s.current_picture_ptr->f->top_field_first = v->tff;
6050 
6051  // process pulldown flags
6052  s->current_picture_ptr->f->repeat_pict = 0;
6053  // Pulldown flags are only valid when 'broadcast' has been set.
6054  // So ticks_per_frame will be 2
6055  if (v->rff) {
6056  // repeat field
6057  s->current_picture_ptr->f->repeat_pict = 1;
6058  } else if (v->rptfrm) {
6059  // repeat frames
6060  s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
6061  }
6062 
6063  s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
6064  s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
6065 
6066  if ((CONFIG_VC1_VDPAU_DECODER)
6067  &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6068  if (v->field_mode && buf_start_second_field) {
6069  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6070  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6071  } else {
6072  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6073  }
6074  } else if (avctx->hwaccel) {
6075  if (v->field_mode && buf_start_second_field) {
6076  // decode first field
6077  s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6078  if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6079  goto err;
6080  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6081  goto err;
6082  if (avctx->hwaccel->end_frame(avctx) < 0)
6083  goto err;
6084 
6085  // decode second field
6086  s->gb = slices[n_slices1 + 1].gb;
6087  s->picture_structure = PICT_TOP_FIELD + v->tff;
6088  v->second_field = 1;
6089  v->pic_header_flag = 0;
6090  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6091  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6092  goto err;
6093  }
6094  v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
6095 
6096  if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6097  goto err;
6098  if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6099  goto err;
6100  if (avctx->hwaccel->end_frame(avctx) < 0)
6101  goto err;
6102  } else {
6103  s->picture_structure = PICT_FRAME;
6104  if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6105  goto err;
6106  if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6107  goto err;
6108  if (avctx->hwaccel->end_frame(avctx) < 0)
6109  goto err;
6110  }
6111  } else {
6112  int header_ret = 0;
6113 
6114  ff_mpeg_er_frame_start(s);
6115 
6116  v->bits = buf_size * 8;
6117  v->end_mb_x = s->mb_width;
6118  if (v->field_mode) {
6119  s->current_picture.f->linesize[0] <<= 1;
6120  s->current_picture.f->linesize[1] <<= 1;
6121  s->current_picture.f->linesize[2] <<= 1;
6122  s->linesize <<= 1;
6123  s->uvlinesize <<= 1;
6124  }
6125  mb_height = s->mb_height >> v->field_mode;
6126 
6127  av_assert0 (mb_height > 0);
6128 
6129  for (i = 0; i <= n_slices; i++) {
6130  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6131  if (v->field_mode <= 0) {
6132  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6133  "picture boundary (%d >= %d)\n", i,
6134  slices[i - 1].mby_start, mb_height);
6135  continue;
6136  }
6137  v->second_field = 1;
6138  av_assert0((s->mb_height & 1) == 0);
6139  v->blocks_off = s->b8_stride * (s->mb_height&~1);
6140  v->mb_off = s->mb_stride * s->mb_height >> 1;
6141  } else {
6142  v->second_field = 0;
6143  v->blocks_off = 0;
6144  v->mb_off = 0;
6145  }
6146  if (i) {
6147  v->pic_header_flag = 0;
6148  if (v->field_mode && i == n_slices1 + 2) {
6149  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6150  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6151  if (avctx->err_recognition & AV_EF_EXPLODE)
6152  goto err;
6153  continue;
6154  }
6155  } else if (get_bits1(&s->gb)) {
6156  v->pic_header_flag = 1;
6157  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6158  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6159  if (avctx->err_recognition & AV_EF_EXPLODE)
6160  goto err;
6161  continue;
6162  }
6163  }
6164  }
6165  if (header_ret < 0)
6166  continue;
6167  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6168  if (!v->field_mode || v->second_field)
6169  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6170  else {
6171  if (i >= n_slices) {
6172  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6173  continue;
6174  }
6175  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6176  }
6177  if (s->end_mb_y <= s->start_mb_y) {
6178  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6179  continue;
6180  }
6181  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6182  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6183  continue;
6184  }
6185  ff_vc1_decode_blocks(v);
6186  if (i != n_slices)
6187  s->gb = slices[i].gb;
6188  }
6189  if (v->field_mode) {
6190  v->second_field = 0;
6191  s->current_picture.f->linesize[0] >>= 1;
6192  s->current_picture.f->linesize[1] >>= 1;
6193  s->current_picture.f->linesize[2] >>= 1;
6194  s->linesize >>= 1;
6195  s->uvlinesize >>= 1;
6196  if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6197  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6198  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6199  }
6200  }
6201  av_dlog(s->avctx, "Consumed %i/%i bits\n",
6202  get_bits_count(&s->gb), s->gb.size_in_bits);
6203 // if (get_bits_count(&s->gb) > buf_size * 8)
6204 // return -1;
6205  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6206  goto err;
6207  if (!v->field_mode)
6208  ff_er_frame_end(&s->er);
6209  }
6210 
6211  ff_MPV_frame_end(s);
6212 
6213  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6214 image:
6215  avctx->width = avctx->coded_width = v->output_width;
6216  avctx->height = avctx->coded_height = v->output_height;
6217  if (avctx->skip_frame >= AVDISCARD_NONREF)
6218  goto end;
6219 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6220  if (vc1_decode_sprites(v, &s->gb))
6221  goto err;
6222 #endif
6223  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
6224  goto err;
6225  *got_frame = 1;
6226  } else {
6227  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6228  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
6229  goto err;
6230  ff_print_debug_info(s, s->current_picture_ptr, pict);
6231  *got_frame = 1;
6232  } else if (s->last_picture_ptr != NULL) {
6233  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
6234  goto err;
6235  ff_print_debug_info(s, s->last_picture_ptr, pict);
6236  *got_frame = 1;
6237  }
6238  }
6239 
6240 end:
6241  av_free(buf2);
6242  for (i = 0; i < n_slices; i++)
6243  av_free(slices[i].buf);
6244  av_free(slices);
6245  return buf_size;
6246 
6247 err:
6248  av_free(buf2);
6249  for (i = 0; i < n_slices; i++)
6250  av_free(slices[i].buf);
6251  av_free(slices);
6252  return -1;
6253 }
6254 
6255 
6256 static const AVProfile profiles[] = {
6257  { FF_PROFILE_VC1_SIMPLE, "Simple" },
6258  { FF_PROFILE_VC1_MAIN, "Main" },
6259  { FF_PROFILE_VC1_COMPLEX, "Complex" },
6260  { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6261  { FF_PROFILE_UNKNOWN },
6262 };
6263 
6264 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6265 #if CONFIG_VC1_DXVA2_HWACCEL
6266  AV_PIX_FMT_DXVA2_VLD,
6267 #endif
6268 #if CONFIG_VC1_VAAPI_HWACCEL
6269  AV_PIX_FMT_VAAPI_VLD,
6270 #endif
6271 #if CONFIG_VC1_VDPAU_HWACCEL
6272  AV_PIX_FMT_VDPAU,
6273 #endif
6274  AV_PIX_FMT_YUV420P,
6275  AV_PIX_FMT_NONE
6276 };
6277 
6278 AVCodec ff_vc1_decoder = {
6279  .name = "vc1",
6280  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6281  .type = AVMEDIA_TYPE_VIDEO,
6282  .id = AV_CODEC_ID_VC1,
6283  .priv_data_size = sizeof(VC1Context),
6284  .init = vc1_decode_init,
6285  .close = ff_vc1_decode_end,
6286  .decode = vc1_decode_frame,
6287  .flush = ff_mpeg_flush,
6288  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6289  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6290  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6291 };
6292 
6293 #if CONFIG_WMV3_DECODER
6294 AVCodec ff_wmv3_decoder = {
6295  .name = "wmv3",
6296  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6297  .type = AVMEDIA_TYPE_VIDEO,
6298  .id = AV_CODEC_ID_WMV3,
6299  .priv_data_size = sizeof(VC1Context),
6300  .init = vc1_decode_init,
6301  .close = ff_vc1_decode_end,
6302  .decode = vc1_decode_frame,
6303  .flush = ff_mpeg_flush,
6304  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6305  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6306  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6307 };
6308 #endif
6309 
6310 #if CONFIG_WMV3_VDPAU_DECODER
6311 AVCodec ff_wmv3_vdpau_decoder = {
6312  .name = "wmv3_vdpau",
6313  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6314  .type = AVMEDIA_TYPE_VIDEO,
6315  .id = AV_CODEC_ID_WMV3,
6316  .priv_data_size = sizeof(VC1Context),
6317  .init = vc1_decode_init,
6318  .close = ff_vc1_decode_end,
6319  .decode = vc1_decode_frame,
6320  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6321  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6322  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6323 };
6324 #endif
6325 
6326 #if CONFIG_VC1_VDPAU_DECODER
6327 AVCodec ff_vc1_vdpau_decoder = {
6328  .name = "vc1_vdpau",
6329  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6330  .type = AVMEDIA_TYPE_VIDEO,
6331  .id = AV_CODEC_ID_VC1,
6332  .priv_data_size = sizeof(VC1Context),
6333  .init = vc1_decode_init,
6334  .close = ff_vc1_decode_end,
6335  .decode = vc1_decode_frame,
6336  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6337  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6338  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6339 };
6340 #endif
6341 
6342 #if CONFIG_WMV3IMAGE_DECODER
6343 AVCodec ff_wmv3image_decoder = {
6344  .name = "wmv3image",
6345  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6346  .type = AVMEDIA_TYPE_VIDEO,
6347  .id = AV_CODEC_ID_WMV3IMAGE,
6348  .priv_data_size = sizeof(VC1Context),
6349  .init = vc1_decode_init,
6350  .close = ff_vc1_decode_end,
6351  .decode = vc1_decode_frame,
6352  .capabilities = CODEC_CAP_DR1,
6353  .flush = vc1_sprite_flush,
6354  .pix_fmts = (const enum AVPixelFormat[]) {
6355  AV_PIX_FMT_YUV420P,
6356  AV_PIX_FMT_NONE
6357  },
6358 };
6359 #endif
6360 
6361 #if CONFIG_VC1IMAGE_DECODER
6362 AVCodec ff_vc1image_decoder = {
6363  .name = "vc1image",
6364  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6365  .type = AVMEDIA_TYPE_VIDEO,
6366  .id = AV_CODEC_ID_VC1IMAGE,
6367  .priv_data_size = sizeof(VC1Context),
6368  .init = vc1_decode_init,
6369  .close = ff_vc1_decode_end,
6370  .decode = vc1_decode_frame,
6371  .capabilities = CODEC_CAP_DR1,
6372  .flush = vc1_sprite_flush,
6373  .pix_fmts = (const enum AVPixelFormat[]) {
6374  AV_PIX_FMT_YUV420P,
6375  AV_PIX_FMT_NONE
6376  },
6377 };
6378 #endif
Generated on Sun Jul 20 2014 23:05:56 for FFmpeg by   doxygen 1.8.2