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 "mpegvideo.h"
33 #include "h263.h"
34 #include "h264chroma.h"
35 #include "vc1.h"
36 #include "vc1data.h"
37 #include "vc1acdata.h"
38 #include "msmpeg4data.h"
39 #include "unary.h"
40 #include "mathops.h"
41 #include "vdpau_internal.h"
42 #include "libavutil/avassert.h"
43 
44 #undef NDEBUG
45 #include <assert.h>
46 
47 #define MB_INTRA_VLC_BITS 9
48 #define DC_VLC_BITS 9
49 
50 
51 // offset tables for interlaced picture MVDATA decoding
52 static const int offset_table1[9] = { 0, 1, 2, 4, 8, 16, 32, 64, 128 };
53 static const int offset_table2[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
54 
55 /***********************************************************************/
56 /**
57  * @name VC-1 Bitplane decoding
58  * @see 8.7, p56
59  * @{
60  */
61 
62 
63 static void init_block_index(VC1Context *v)
64 {
65  MpegEncContext *s = &v->s;
66  ff_init_block_index(s);
67  if (v->field_mode && !(v->second_field ^ v->tff)) {
68  s->dest[0] += s->current_picture_ptr->f.linesize[0];
69  s->dest[1] += s->current_picture_ptr->f.linesize[1];
70  s->dest[2] += s->current_picture_ptr->f.linesize[2];
71  }
72 }
73 
74 /** @} */ //Bitplane group
75 
76 static void vc1_put_signed_blocks_clamped(VC1Context *v)
77 {
78  MpegEncContext *s = &v->s;
79  int topleft_mb_pos, top_mb_pos;
80  int stride_y, fieldtx = 0;
81  int v_dist;
82 
83  /* The put pixels loop is always one MB row behind the decoding loop,
84  * because we can only put pixels when overlap filtering is done, and
85  * for filtering of the bottom edge of a MB, we need the next MB row
86  * present as well.
87  * Within the row, the put pixels loop is also one MB col behind the
88  * decoding loop. The reason for this is again, because for filtering
89  * of the right MB edge, we need the next MB present. */
90  if (!s->first_slice_line) {
91  if (s->mb_x) {
92  topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
93  if (v->fcm == ILACE_FRAME)
94  fieldtx = v->fieldtx_plane[topleft_mb_pos];
95  stride_y = s->linesize << fieldtx;
96  v_dist = (16 - fieldtx) >> (fieldtx == 0);
97  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
98  s->dest[0] - 16 * s->linesize - 16,
99  stride_y);
100  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
101  s->dest[0] - 16 * s->linesize - 8,
102  stride_y);
103  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
104  s->dest[0] - v_dist * s->linesize - 16,
105  stride_y);
106  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
107  s->dest[0] - v_dist * s->linesize - 8,
108  stride_y);
109  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
110  s->dest[1] - 8 * s->uvlinesize - 8,
111  s->uvlinesize);
112  s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
113  s->dest[2] - 8 * s->uvlinesize - 8,
114  s->uvlinesize);
115  }
116  if (s->mb_x == s->mb_width - 1) {
117  top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
118  if (v->fcm == ILACE_FRAME)
119  fieldtx = v->fieldtx_plane[top_mb_pos];
120  stride_y = s->linesize << fieldtx;
121  v_dist = fieldtx ? 15 : 8;
122  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
123  s->dest[0] - 16 * s->linesize,
124  stride_y);
125  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
126  s->dest[0] - 16 * s->linesize + 8,
127  stride_y);
128  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
129  s->dest[0] - v_dist * s->linesize,
130  stride_y);
131  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
132  s->dest[0] - v_dist * s->linesize + 8,
133  stride_y);
134  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
135  s->dest[1] - 8 * s->uvlinesize,
136  s->uvlinesize);
137  s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
138  s->dest[2] - 8 * s->uvlinesize,
139  s->uvlinesize);
140  }
141  }
142 
143 #define inc_blk_idx(idx) do { \
144  idx++; \
145  if (idx >= v->n_allocated_blks) \
146  idx = 0; \
147  } while (0)
148 
149  inc_blk_idx(v->topleft_blk_idx);
150  inc_blk_idx(v->top_blk_idx);
151  inc_blk_idx(v->left_blk_idx);
152  inc_blk_idx(v->cur_blk_idx);
153 }
154 
155 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
156 {
157  MpegEncContext *s = &v->s;
158  int j;
159  if (!s->first_slice_line) {
160  v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
161  if (s->mb_x)
162  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
163  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
164  for (j = 0; j < 2; j++) {
165  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
166  if (s->mb_x)
167  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
168  }
169  }
170  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
171 
172  if (s->mb_y == s->end_mb_y - 1) {
173  if (s->mb_x) {
174  v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
175  v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
176  v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
177  }
178  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
179  }
180 }
181 
182 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
183 {
184  MpegEncContext *s = &v->s;
185  int j;
186 
187  /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
188  * means it runs two rows/cols behind the decoding loop. */
189  if (!s->first_slice_line) {
190  if (s->mb_x) {
191  if (s->mb_y >= s->start_mb_y + 2) {
192  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
193 
194  if (s->mb_x >= 2)
195  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
196  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
197  for (j = 0; j < 2; j++) {
198  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
199  if (s->mb_x >= 2) {
200  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
201  }
202  }
203  }
204  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
205  }
206 
207  if (s->mb_x == s->mb_width - 1) {
208  if (s->mb_y >= s->start_mb_y + 2) {
209  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
210 
211  if (s->mb_x)
212  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
213  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
214  for (j = 0; j < 2; j++) {
215  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
216  if (s->mb_x >= 2) {
217  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
218  }
219  }
220  }
221  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
222  }
223 
224  if (s->mb_y == s->end_mb_y) {
225  if (s->mb_x) {
226  if (s->mb_x >= 2)
227  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
228  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
229  if (s->mb_x >= 2) {
230  for (j = 0; j < 2; j++) {
231  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
232  }
233  }
234  }
235 
236  if (s->mb_x == s->mb_width - 1) {
237  if (s->mb_x)
238  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
239  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
240  if (s->mb_x) {
241  for (j = 0; j < 2; j++) {
242  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
243  }
244  }
245  }
246  }
247  }
248 }
249 
250 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
251 {
252  MpegEncContext *s = &v->s;
253  int mb_pos;
254 
255  if (v->condover == CONDOVER_NONE)
256  return;
257 
258  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
259 
260  /* Within a MB, the horizontal overlap always runs before the vertical.
261  * To accomplish that, we run the H on left and internal borders of the
262  * currently decoded MB. Then, we wait for the next overlap iteration
263  * to do H overlap on the right edge of this MB, before moving over and
264  * running the V overlap. Therefore, the V overlap makes us trail by one
265  * MB col and the H overlap filter makes us trail by one MB row. This
266  * is reflected in the time at which we run the put_pixels loop. */
267  if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
268  if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
269  v->over_flags_plane[mb_pos - 1])) {
270  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
271  v->block[v->cur_blk_idx][0]);
272  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
273  v->block[v->cur_blk_idx][2]);
274  if (!(s->flags & CODEC_FLAG_GRAY)) {
275  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
276  v->block[v->cur_blk_idx][4]);
277  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
278  v->block[v->cur_blk_idx][5]);
279  }
280  }
281  v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
282  v->block[v->cur_blk_idx][1]);
283  v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
284  v->block[v->cur_blk_idx][3]);
285 
286  if (s->mb_x == s->mb_width - 1) {
287  if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
288  v->over_flags_plane[mb_pos - s->mb_stride])) {
289  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
290  v->block[v->cur_blk_idx][0]);
291  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
292  v->block[v->cur_blk_idx][1]);
293  if (!(s->flags & CODEC_FLAG_GRAY)) {
294  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
295  v->block[v->cur_blk_idx][4]);
296  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
297  v->block[v->cur_blk_idx][5]);
298  }
299  }
300  v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
301  v->block[v->cur_blk_idx][2]);
302  v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
303  v->block[v->cur_blk_idx][3]);
304  }
305  }
306  if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
307  if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
308  v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
309  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
310  v->block[v->left_blk_idx][0]);
311  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
312  v->block[v->left_blk_idx][1]);
313  if (!(s->flags & CODEC_FLAG_GRAY)) {
314  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
315  v->block[v->left_blk_idx][4]);
316  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
317  v->block[v->left_blk_idx][5]);
318  }
319  }
320  v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
321  v->block[v->left_blk_idx][2]);
322  v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
323  v->block[v->left_blk_idx][3]);
324  }
325 }
326 
327 /** Do motion compensation over 1 macroblock
328  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
329  */
330 static void vc1_mc_1mv(VC1Context *v, int dir)
331 {
332  MpegEncContext *s = &v->s;
333  H264ChromaContext *h264chroma = &v->h264chroma;
334  uint8_t *srcY, *srcU, *srcV;
335  int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
336  int v_edge_pos = s->v_edge_pos >> v->field_mode;
337  int i;
338  uint8_t (*luty)[256], (*lutuv)[256];
339  int use_ic;
340 
341  if ((!v->field_mode ||
342  (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
343  !v->s.last_picture.f.data[0])
344  return;
345 
346  mx = s->mv[dir][0][0];
347  my = s->mv[dir][0][1];
348 
349  // store motion vectors for further use in B frames
350  if (s->pict_type == AV_PICTURE_TYPE_P) {
351  for (i = 0; i < 4; i++) {
352  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
353  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
354  }
355  }
356 
357  uvmx = (mx + ((mx & 3) == 3)) >> 1;
358  uvmy = (my + ((my & 3) == 3)) >> 1;
359  v->luma_mv[s->mb_x][0] = uvmx;
360  v->luma_mv[s->mb_x][1] = uvmy;
361 
362  if (v->field_mode &&
363  v->cur_field_type != v->ref_field_type[dir]) {
364  my = my - 2 + 4 * v->cur_field_type;
365  uvmy = uvmy - 2 + 4 * v->cur_field_type;
366  }
367 
368  // fastuvmc shall be ignored for interlaced frame picture
369  if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
370  uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
371  uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
372  }
373  if (!dir) {
374  if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
375  srcY = s->current_picture.f.data[0];
376  srcU = s->current_picture.f.data[1];
377  srcV = s->current_picture.f.data[2];
378  luty = v->curr_luty;
379  lutuv = v->curr_lutuv;
380  use_ic = *v->curr_use_ic;
381  } else {
382  srcY = s->last_picture.f.data[0];
383  srcU = s->last_picture.f.data[1];
384  srcV = s->last_picture.f.data[2];
385  luty = v->last_luty;
386  lutuv = v->last_lutuv;
387  use_ic = v->last_use_ic;
388  }
389  } else {
390  srcY = s->next_picture.f.data[0];
391  srcU = s->next_picture.f.data[1];
392  srcV = s->next_picture.f.data[2];
393  luty = v->next_luty;
394  lutuv = v->next_lutuv;
395  use_ic = v->next_use_ic;
396  }
397 
398  if (!srcY || !srcU) {
399  av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
400  return;
401  }
402 
403  src_x = s->mb_x * 16 + (mx >> 2);
404  src_y = s->mb_y * 16 + (my >> 2);
405  uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
406  uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
407 
408  if (v->profile != PROFILE_ADVANCED) {
409  src_x = av_clip( src_x, -16, s->mb_width * 16);
410  src_y = av_clip( src_y, -16, s->mb_height * 16);
411  uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
412  uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
413  } else {
414  src_x = av_clip( src_x, -17, s->avctx->coded_width);
415  src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
416  uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
417  uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
418  }
419 
420  srcY += src_y * s->linesize + src_x;
421  srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
422  srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
423 
424  if (v->field_mode && v->ref_field_type[dir]) {
425  srcY += s->current_picture_ptr->f.linesize[0];
426  srcU += s->current_picture_ptr->f.linesize[1];
427  srcV += s->current_picture_ptr->f.linesize[2];
428  }
429 
430  /* for grayscale we should not try to read from unknown area */
431  if (s->flags & CODEC_FLAG_GRAY) {
432  srcU = s->edge_emu_buffer + 18 * s->linesize;
433  srcV = s->edge_emu_buffer + 18 * s->linesize;
434  }
435 
436  if (v->rangeredfrm || use_ic
437  || s->h_edge_pos < 22 || v_edge_pos < 22
438  || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
439  || (unsigned)(src_y - 1) > v_edge_pos - (my&3) - 16 - 3) {
440  uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
441 
442  srcY -= s->mspel * (1 + s->linesize);
443  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
444  s->linesize, s->linesize,
445  17 + s->mspel * 2, 17 + s->mspel * 2,
446  src_x - s->mspel, src_y - s->mspel,
447  s->h_edge_pos, v_edge_pos);
448  srcY = s->edge_emu_buffer;
449  s->vdsp.emulated_edge_mc(uvbuf, srcU,
450  s->uvlinesize, s->uvlinesize,
451  8 + 1, 8 + 1,
452  uvsrc_x, uvsrc_y,
453  s->h_edge_pos >> 1, v_edge_pos >> 1);
454  s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
455  s->uvlinesize, s->uvlinesize,
456  8 + 1, 8 + 1,
457  uvsrc_x, uvsrc_y,
458  s->h_edge_pos >> 1, v_edge_pos >> 1);
459  srcU = uvbuf;
460  srcV = uvbuf + 16;
461  /* if we deal with range reduction we need to scale source blocks */
462  if (v->rangeredfrm) {
463  int i, j;
464  uint8_t *src, *src2;
465 
466  src = srcY;
467  for (j = 0; j < 17 + s->mspel * 2; j++) {
468  for (i = 0; i < 17 + s->mspel * 2; i++)
469  src[i] = ((src[i] - 128) >> 1) + 128;
470  src += s->linesize;
471  }
472  src = srcU;
473  src2 = srcV;
474  for (j = 0; j < 9; j++) {
475  for (i = 0; i < 9; i++) {
476  src[i] = ((src[i] - 128) >> 1) + 128;
477  src2[i] = ((src2[i] - 128) >> 1) + 128;
478  }
479  src += s->uvlinesize;
480  src2 += s->uvlinesize;
481  }
482  }
483  /* if we deal with intensity compensation we need to scale source blocks */
484  if (use_ic) {
485  int i, j;
486  uint8_t *src, *src2;
487 
488  src = srcY;
489  for (j = 0; j < 17 + s->mspel * 2; j++) {
490  int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
491  for (i = 0; i < 17 + s->mspel * 2; i++)
492  src[i] = luty[f][src[i]];
493  src += s->linesize;
494  }
495  src = srcU;
496  src2 = srcV;
497  for (j = 0; j < 9; j++) {
498  int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
499  for (i = 0; i < 9; i++) {
500  src[i] = lutuv[f][src[i]];
501  src2[i] = lutuv[f][src2[i]];
502  }
503  src += s->uvlinesize;
504  src2 += s->uvlinesize;
505  }
506  }
507  srcY += s->mspel * (1 + s->linesize);
508  }
509 
510  if (s->mspel) {
511  dxy = ((my & 3) << 2) | (mx & 3);
512  v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
513  v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
514  srcY += s->linesize * 8;
515  v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
516  v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, 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[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
731  else
732  v->vc1dsp.put_vc1_mspel_pixels_tab[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  if (v->fastuvmc) {
1920  uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1921  uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1922  }
1923  srcY = s->next_picture.f.data[0];
1924  srcU = s->next_picture.f.data[1];
1925  srcV = s->next_picture.f.data[2];
1926 
1927  src_x = s->mb_x * 16 + (mx >> 2);
1928  src_y = s->mb_y * 16 + (my >> 2);
1929  uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1930  uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1931 
1932  if (v->profile != PROFILE_ADVANCED) {
1933  src_x = av_clip( src_x, -16, s->mb_width * 16);
1934  src_y = av_clip( src_y, -16, s->mb_height * 16);
1935  uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1936  uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1937  } else {
1938  src_x = av_clip( src_x, -17, s->avctx->coded_width);
1939  src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
1940  uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1941  uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1942  }
1943 
1944  srcY += src_y * s->linesize + src_x;
1945  srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1946  srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1947 
1948  if (v->field_mode && v->ref_field_type[1]) {
1949  srcY += s->current_picture_ptr->f.linesize[0];
1950  srcU += s->current_picture_ptr->f.linesize[1];
1951  srcV += s->current_picture_ptr->f.linesize[2];
1952  }
1953 
1954  /* for grayscale we should not try to read from unknown area */
1955  if (s->flags & CODEC_FLAG_GRAY) {
1956  srcU = s->edge_emu_buffer + 18 * s->linesize;
1957  srcV = s->edge_emu_buffer + 18 * s->linesize;
1958  }
1959 
1960  if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1961  || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1962  || (unsigned)(src_y - 1) > v_edge_pos - (my & 3) - 16 - 3) {
1963  uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1964 
1965  srcY -= s->mspel * (1 + s->linesize);
1966  s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
1967  s->linesize, s->linesize,
1968  17 + s->mspel * 2, 17 + s->mspel * 2,
1969  src_x - s->mspel, src_y - s->mspel,
1970  s->h_edge_pos, v_edge_pos);
1971  srcY = s->edge_emu_buffer;
1972  s->vdsp.emulated_edge_mc(uvbuf, srcU,
1973  s->uvlinesize, s->uvlinesize,
1974  8 + 1, 8 + 1,
1975  uvsrc_x, uvsrc_y,
1976  s->h_edge_pos >> 1, v_edge_pos >> 1);
1977  s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
1978  s->uvlinesize, s->uvlinesize,
1979  8 + 1, 8 + 1,
1980  uvsrc_x, uvsrc_y,
1981  s->h_edge_pos >> 1, v_edge_pos >> 1);
1982  srcU = uvbuf;
1983  srcV = uvbuf + 16;
1984  /* if we deal with range reduction we need to scale source blocks */
1985  if (v->rangeredfrm) {
1986  int i, j;
1987  uint8_t *src, *src2;
1988 
1989  src = srcY;
1990  for (j = 0; j < 17 + s->mspel * 2; j++) {
1991  for (i = 0; i < 17 + s->mspel * 2; i++)
1992  src[i] = ((src[i] - 128) >> 1) + 128;
1993  src += s->linesize;
1994  }
1995  src = srcU;
1996  src2 = srcV;
1997  for (j = 0; j < 9; j++) {
1998  for (i = 0; i < 9; i++) {
1999  src[i] = ((src[i] - 128) >> 1) + 128;
2000  src2[i] = ((src2[i] - 128) >> 1) + 128;
2001  }
2002  src += s->uvlinesize;
2003  src2 += s->uvlinesize;
2004  }
2005  }
2006 
2007  if (use_ic) {
2008  uint8_t (*luty )[256] = v->next_luty;
2009  uint8_t (*lutuv)[256] = v->next_lutuv;
2010  int i, j;
2011  uint8_t *src, *src2;
2012 
2013  src = srcY;
2014  for (j = 0; j < 17 + s->mspel * 2; j++) {
2015  int f = v->field_mode ? v->ref_field_type[1] : ((j+src_y - s->mspel) & 1);
2016  for (i = 0; i < 17 + s->mspel * 2; i++)
2017  src[i] = luty[f][src[i]];
2018  src += s->linesize;
2019  }
2020  src = srcU;
2021  src2 = srcV;
2022  for (j = 0; j < 9; j++) {
2023  int f = v->field_mode ? v->ref_field_type[1] : ((j+uvsrc_y) & 1);
2024  for (i = 0; i < 9; i++) {
2025  src[i] = lutuv[f][src[i]];
2026  src2[i] = lutuv[f][src2[i]];
2027  }
2028  src += s->uvlinesize;
2029  src2 += s->uvlinesize;
2030  }
2031  }
2032  srcY += s->mspel * (1 + s->linesize);
2033  }
2034 
2035  off = 0;
2036  off_uv = 0;
2037 
2038  if (s->mspel) {
2039  dxy = ((my & 3) << 2) | (mx & 3);
2040  v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off , srcY , s->linesize, v->rnd);
2041  v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
2042  srcY += s->linesize * 8;
2043  v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize , srcY , s->linesize, v->rnd);
2044  v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
2045  } else { // hpel mc
2046  dxy = (my & 2) | ((mx & 2) >> 1);
2047 
2048  if (!v->rnd)
2049  s->hdsp.avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
2050  else
2051  s->hdsp.avg_no_rnd_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, 16);
2052  }
2053 
2054  if (s->flags & CODEC_FLAG_GRAY) return;
2055  /* Chroma MC always uses qpel blilinear */
2056  uvmx = (uvmx & 3) << 1;
2057  uvmy = (uvmy & 3) << 1;
2058  if (!v->rnd) {
2059  h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2060  h264chroma->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2061  } else {
2062  v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
2063  v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
2064  }
2065 }
2066 
2067 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2068 {
2069  int n = bfrac;
2070 
2071 #if B_FRACTION_DEN==256
2072  if (inv)
2073  n -= 256;
2074  if (!qs)
2075  return 2 * ((value * n + 255) >> 9);
2076  return (value * n + 128) >> 8;
2077 #else
2078  if (inv)
2079  n -= B_FRACTION_DEN;
2080  if (!qs)
2081  return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2082  return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2083 #endif
2084 }
2085 
2086 /** Reconstruct motion vector for B-frame and do motion compensation
2087  */
2088 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2089  int direct, int mode)
2090 {
2091  if (direct) {
2092  vc1_mc_1mv(v, 0);
2093  vc1_interp_mc(v);
2094  return;
2095  }
2096  if (mode == BMV_TYPE_INTERPOLATED) {
2097  vc1_mc_1mv(v, 0);
2098  vc1_interp_mc(v);
2099  return;
2100  }
2101 
2102  vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2103 }
2104 
2105 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2106  int direct, int mvtype)
2107 {
2108  MpegEncContext *s = &v->s;
2109  int xy, wrap, off = 0;
2110  int16_t *A, *B, *C;
2111  int px, py;
2112  int sum;
2113  int r_x, r_y;
2114  const uint8_t *is_intra = v->mb_type[0];
2115 
2116  av_assert0(!v->field_mode);
2117 
2118  r_x = v->range_x;
2119  r_y = v->range_y;
2120  /* scale MV difference to be quad-pel */
2121  dmv_x[0] <<= 1 - s->quarter_sample;
2122  dmv_y[0] <<= 1 - s->quarter_sample;
2123  dmv_x[1] <<= 1 - s->quarter_sample;
2124  dmv_y[1] <<= 1 - s->quarter_sample;
2125 
2126  wrap = s->b8_stride;
2127  xy = s->block_index[0];
2128 
2129  if (s->mb_intra) {
2130  s->current_picture.motion_val[0][xy][0] =
2131  s->current_picture.motion_val[0][xy][1] =
2132  s->current_picture.motion_val[1][xy][0] =
2133  s->current_picture.motion_val[1][xy][1] = 0;
2134  return;
2135  }
2136  if (direct && s->next_picture_ptr->field_picture)
2137  av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
2138 
2139  s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2140  s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2141  s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2142  s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2143 
2144  /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2145  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));
2146  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));
2147  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));
2148  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));
2149  if (direct) {
2150  s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2151  s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2152  s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2153  s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2154  return;
2155  }
2156 
2157  if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2158  C = s->current_picture.motion_val[0][xy - 2];
2159  A = s->current_picture.motion_val[0][xy - wrap * 2];
2160  off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2161  B = s->current_picture.motion_val[0][xy - wrap * 2 + off];
2162 
2163  if (!s->mb_x) C[0] = C[1] = 0;
2164  if (!s->first_slice_line) { // predictor A is not out of bounds
2165  if (s->mb_width == 1) {
2166  px = A[0];
2167  py = A[1];
2168  } else {
2169  px = mid_pred(A[0], B[0], C[0]);
2170  py = mid_pred(A[1], B[1], C[1]);
2171  }
2172  } else if (s->mb_x) { // predictor C is not out of bounds
2173  px = C[0];
2174  py = C[1];
2175  } else {
2176  px = py = 0;
2177  }
2178  /* Pullback MV as specified in 8.3.5.3.4 */
2179  {
2180  int qx, qy, X, Y;
2181  if (v->profile < PROFILE_ADVANCED) {
2182  qx = (s->mb_x << 5);
2183  qy = (s->mb_y << 5);
2184  X = (s->mb_width << 5) - 4;
2185  Y = (s->mb_height << 5) - 4;
2186  if (qx + px < -28) px = -28 - qx;
2187  if (qy + py < -28) py = -28 - qy;
2188  if (qx + px > X) px = X - qx;
2189  if (qy + py > Y) py = Y - qy;
2190  } else {
2191  qx = (s->mb_x << 6);
2192  qy = (s->mb_y << 6);
2193  X = (s->mb_width << 6) - 4;
2194  Y = (s->mb_height << 6) - 4;
2195  if (qx + px < -60) px = -60 - qx;
2196  if (qy + py < -60) py = -60 - qy;
2197  if (qx + px > X) px = X - qx;
2198  if (qy + py > Y) py = Y - qy;
2199  }
2200  }
2201  /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2202  if (0 && !s->first_slice_line && s->mb_x) {
2203  if (is_intra[xy - wrap])
2204  sum = FFABS(px) + FFABS(py);
2205  else
2206  sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2207  if (sum > 32) {
2208  if (get_bits1(&s->gb)) {
2209  px = A[0];
2210  py = A[1];
2211  } else {
2212  px = C[0];
2213  py = C[1];
2214  }
2215  } else {
2216  if (is_intra[xy - 2])
2217  sum = FFABS(px) + FFABS(py);
2218  else
2219  sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2220  if (sum > 32) {
2221  if (get_bits1(&s->gb)) {
2222  px = A[0];
2223  py = A[1];
2224  } else {
2225  px = C[0];
2226  py = C[1];
2227  }
2228  }
2229  }
2230  }
2231  /* store MV using signed modulus of MV range defined in 4.11 */
2232  s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2233  s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2234  }
2235  if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2236  C = s->current_picture.motion_val[1][xy - 2];
2237  A = s->current_picture.motion_val[1][xy - wrap * 2];
2238  off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2239  B = s->current_picture.motion_val[1][xy - wrap * 2 + off];
2240 
2241  if (!s->mb_x)
2242  C[0] = C[1] = 0;
2243  if (!s->first_slice_line) { // predictor A is not out of bounds
2244  if (s->mb_width == 1) {
2245  px = A[0];
2246  py = A[1];
2247  } else {
2248  px = mid_pred(A[0], B[0], C[0]);
2249  py = mid_pred(A[1], B[1], C[1]);
2250  }
2251  } else if (s->mb_x) { // predictor C is not out of bounds
2252  px = C[0];
2253  py = C[1];
2254  } else {
2255  px = py = 0;
2256  }
2257  /* Pullback MV as specified in 8.3.5.3.4 */
2258  {
2259  int qx, qy, X, Y;
2260  if (v->profile < PROFILE_ADVANCED) {
2261  qx = (s->mb_x << 5);
2262  qy = (s->mb_y << 5);
2263  X = (s->mb_width << 5) - 4;
2264  Y = (s->mb_height << 5) - 4;
2265  if (qx + px < -28) px = -28 - qx;
2266  if (qy + py < -28) py = -28 - qy;
2267  if (qx + px > X) px = X - qx;
2268  if (qy + py > Y) py = Y - qy;
2269  } else {
2270  qx = (s->mb_x << 6);
2271  qy = (s->mb_y << 6);
2272  X = (s->mb_width << 6) - 4;
2273  Y = (s->mb_height << 6) - 4;
2274  if (qx + px < -60) px = -60 - qx;
2275  if (qy + py < -60) py = -60 - qy;
2276  if (qx + px > X) px = X - qx;
2277  if (qy + py > Y) py = Y - qy;
2278  }
2279  }
2280  /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2281  if (0 && !s->first_slice_line && s->mb_x) {
2282  if (is_intra[xy - wrap])
2283  sum = FFABS(px) + FFABS(py);
2284  else
2285  sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2286  if (sum > 32) {
2287  if (get_bits1(&s->gb)) {
2288  px = A[0];
2289  py = A[1];
2290  } else {
2291  px = C[0];
2292  py = C[1];
2293  }
2294  } else {
2295  if (is_intra[xy - 2])
2296  sum = FFABS(px) + FFABS(py);
2297  else
2298  sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2299  if (sum > 32) {
2300  if (get_bits1(&s->gb)) {
2301  px = A[0];
2302  py = A[1];
2303  } else {
2304  px = C[0];
2305  py = C[1];
2306  }
2307  }
2308  }
2309  }
2310  /* store MV using signed modulus of MV range defined in 4.11 */
2311 
2312  s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2313  s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2314  }
2315  s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2316  s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2317  s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2318  s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2319 }
2320 
2321 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2322 {
2323  int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2324  MpegEncContext *s = &v->s;
2325  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2326 
2327  if (v->bmvtype == BMV_TYPE_DIRECT) {
2328  int total_opp, k, f;
2329  if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2330  s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2331  v->bfraction, 0, s->quarter_sample);
2332  s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2333  v->bfraction, 0, s->quarter_sample);
2334  s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
2335  v->bfraction, 1, s->quarter_sample);
2336  s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
2337  v->bfraction, 1, s->quarter_sample);
2338 
2339  total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2340  + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2341  + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2342  + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2343  f = (total_opp > 2) ? 1 : 0;
2344  } else {
2345  s->mv[0][0][0] = s->mv[0][0][1] = 0;
2346  s->mv[1][0][0] = s->mv[1][0][1] = 0;
2347  f = 0;
2348  }
2349  v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2350  for (k = 0; k < 4; k++) {
2351  s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2352  s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2353  s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2354  s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2355  v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2356  v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2357  }
2358  return;
2359  }
2360  if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2361  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);
2362  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);
2363  return;
2364  }
2365  if (dir) { // backward
2366  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);
2367  if (n == 3 || mv1) {
2368  vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0], 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2369  }
2370  } else { // forward
2371  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);
2372  if (n == 3 || mv1) {
2373  vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1], 1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2374  }
2375  }
2376 }
2377 
2378 /** Get predicted DC value for I-frames only
2379  * prediction dir: left=0, top=1
2380  * @param s MpegEncContext
2381  * @param overlap flag indicating that overlap filtering is used
2382  * @param pq integer part of picture quantizer
2383  * @param[in] n block index in the current MB
2384  * @param dc_val_ptr Pointer to DC predictor
2385  * @param dir_ptr Prediction direction for use in AC prediction
2386  */
2387 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2388  int16_t **dc_val_ptr, int *dir_ptr)
2389 {
2390  int a, b, c, wrap, pred, scale;
2391  int16_t *dc_val;
2392  static const uint16_t dcpred[32] = {
2393  -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2394  114, 102, 93, 85, 79, 73, 68, 64,
2395  60, 57, 54, 51, 49, 47, 45, 43,
2396  41, 39, 38, 37, 35, 34, 33
2397  };
2398 
2399  /* find prediction - wmv3_dc_scale always used here in fact */
2400  if (n < 4) scale = s->y_dc_scale;
2401  else scale = s->c_dc_scale;
2402 
2403  wrap = s->block_wrap[n];
2404  dc_val = s->dc_val[0] + s->block_index[n];
2405 
2406  /* B A
2407  * C X
2408  */
2409  c = dc_val[ - 1];
2410  b = dc_val[ - 1 - wrap];
2411  a = dc_val[ - wrap];
2412 
2413  if (pq < 9 || !overlap) {
2414  /* Set outer values */
2415  if (s->first_slice_line && (n != 2 && n != 3))
2416  b = a = dcpred[scale];
2417  if (s->mb_x == 0 && (n != 1 && n != 3))
2418  b = c = dcpred[scale];
2419  } else {
2420  /* Set outer values */
2421  if (s->first_slice_line && (n != 2 && n != 3))
2422  b = a = 0;
2423  if (s->mb_x == 0 && (n != 1 && n != 3))
2424  b = c = 0;
2425  }
2426 
2427  if (abs(a - b) <= abs(b - c)) {
2428  pred = c;
2429  *dir_ptr = 1; // left
2430  } else {
2431  pred = a;
2432  *dir_ptr = 0; // top
2433  }
2434 
2435  /* update predictor */
2436  *dc_val_ptr = &dc_val[0];
2437  return pred;
2438 }
2439 
2440 
2441 /** Get predicted DC value
2442  * prediction dir: left=0, top=1
2443  * @param s MpegEncContext
2444  * @param overlap flag indicating that overlap filtering is used
2445  * @param pq integer part of picture quantizer
2446  * @param[in] n block index in the current MB
2447  * @param a_avail flag indicating top block availability
2448  * @param c_avail flag indicating left block availability
2449  * @param dc_val_ptr Pointer to DC predictor
2450  * @param dir_ptr Prediction direction for use in AC prediction
2451  */
2452 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2453  int a_avail, int c_avail,
2454  int16_t **dc_val_ptr, int *dir_ptr)
2455 {
2456  int a, b, c, wrap, pred;
2457  int16_t *dc_val;
2458  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2459  int q1, q2 = 0;
2460  int dqscale_index;
2461 
2462  wrap = s->block_wrap[n];
2463  dc_val = s->dc_val[0] + s->block_index[n];
2464 
2465  /* B A
2466  * C X
2467  */
2468  c = dc_val[ - 1];
2469  b = dc_val[ - 1 - wrap];
2470  a = dc_val[ - wrap];
2471  /* scale predictors if needed */
2472  q1 = s->current_picture.qscale_table[mb_pos];
2473  dqscale_index = s->y_dc_scale_table[q1] - 1;
2474  if (dqscale_index < 0)
2475  return 0;
2476  if (c_avail && (n != 1 && n != 3)) {
2477  q2 = s->current_picture.qscale_table[mb_pos - 1];
2478  if (q2 && q2 != q1)
2479  c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2480  }
2481  if (a_avail && (n != 2 && n != 3)) {
2482  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2483  if (q2 && q2 != q1)
2484  a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2485  }
2486  if (a_avail && c_avail && (n != 3)) {
2487  int off = mb_pos;
2488  if (n != 1)
2489  off--;
2490  if (n != 2)
2491  off -= s->mb_stride;
2492  q2 = s->current_picture.qscale_table[off];
2493  if (q2 && q2 != q1)
2494  b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2495  }
2496 
2497  if (a_avail && c_avail) {
2498  if (abs(a - b) <= abs(b - c)) {
2499  pred = c;
2500  *dir_ptr = 1; // left
2501  } else {
2502  pred = a;
2503  *dir_ptr = 0; // top
2504  }
2505  } else if (a_avail) {
2506  pred = a;
2507  *dir_ptr = 0; // top
2508  } else if (c_avail) {
2509  pred = c;
2510  *dir_ptr = 1; // left
2511  } else {
2512  pred = 0;
2513  *dir_ptr = 1; // left
2514  }
2515 
2516  /* update predictor */
2517  *dc_val_ptr = &dc_val[0];
2518  return pred;
2519 }
2520 
2521 /** @} */ // Block group
2522 
2523 /**
2524  * @name VC1 Macroblock-level functions in Simple/Main Profiles
2525  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2526  * @{
2527  */
2528 
2529 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2530  uint8_t **coded_block_ptr)
2531 {
2532  int xy, wrap, pred, a, b, c;
2533 
2534  xy = s->block_index[n];
2535  wrap = s->b8_stride;
2536 
2537  /* B C
2538  * A X
2539  */
2540  a = s->coded_block[xy - 1 ];
2541  b = s->coded_block[xy - 1 - wrap];
2542  c = s->coded_block[xy - wrap];
2543 
2544  if (b == c) {
2545  pred = a;
2546  } else {
2547  pred = c;
2548  }
2549 
2550  /* store value */
2551  *coded_block_ptr = &s->coded_block[xy];
2552 
2553  return pred;
2554 }
2555 
2556 /**
2557  * Decode one AC coefficient
2558  * @param v The VC1 context
2559  * @param last Last coefficient
2560  * @param skip How much zero coefficients to skip
2561  * @param value Decoded AC coefficient value
2562  * @param codingset set of VLC to decode data
2563  * @see 8.1.3.4
2564  */
2565 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2566  int *value, int codingset)
2567 {
2568  GetBitContext *gb = &v->s.gb;
2569  int index, escape, run = 0, level = 0, lst = 0;
2570 
2571  index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2572  if (index != ff_vc1_ac_sizes[codingset] - 1) {
2573  run = vc1_index_decode_table[codingset][index][0];
2574  level = vc1_index_decode_table[codingset][index][1];
2575  lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2576  if (get_bits1(gb))
2577  level = -level;
2578  } else {
2579  escape = decode210(gb);
2580  if (escape != 2) {
2581  index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2582  run = vc1_index_decode_table[codingset][index][0];
2583  level = vc1_index_decode_table[codingset][index][1];
2584  lst = index >= vc1_last_decode_table[codingset];
2585  if (escape == 0) {
2586  if (lst)
2587  level += vc1_last_delta_level_table[codingset][run];
2588  else
2589  level += vc1_delta_level_table[codingset][run];
2590  } else {
2591  if (lst)
2592  run += vc1_last_delta_run_table[codingset][level] + 1;
2593  else
2594  run += vc1_delta_run_table[codingset][level] + 1;
2595  }
2596  if (get_bits1(gb))
2597  level = -level;
2598  } else {
2599  int sign;
2600  lst = get_bits1(gb);
2601  if (v->s.esc3_level_length == 0) {
2602  if (v->pq < 8 || v->dquantfrm) { // table 59
2603  v->s.esc3_level_length = get_bits(gb, 3);
2604  if (!v->s.esc3_level_length)
2605  v->s.esc3_level_length = get_bits(gb, 2) + 8;
2606  } else { // table 60
2607  v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2608  }
2609  v->s.esc3_run_length = 3 + get_bits(gb, 2);
2610  }
2611  run = get_bits(gb, v->s.esc3_run_length);
2612  sign = get_bits1(gb);
2613  level = get_bits(gb, v->s.esc3_level_length);
2614  if (sign)
2615  level = -level;
2616  }
2617  }
2618 
2619  *last = lst;
2620  *skip = run;
2621  *value = level;
2622 }
2623 
2624 /** Decode intra block in intra frames - should be faster than decode_intra_block
2625  * @param v VC1Context
2626  * @param block block to decode
2627  * @param[in] n subblock index
2628  * @param coded are AC coeffs present or not
2629  * @param codingset set of VLC to decode data
2630  */
2631 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
2632  int coded, int codingset)
2633 {
2634  GetBitContext *gb = &v->s.gb;
2635  MpegEncContext *s = &v->s;
2636  int dc_pred_dir = 0; /* Direction of the DC prediction used */
2637  int i;
2638  int16_t *dc_val;
2639  int16_t *ac_val, *ac_val2;
2640  int dcdiff;
2641 
2642  /* Get DC differential */
2643  if (n < 4) {
2644  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2645  } else {
2646  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2647  }
2648  if (dcdiff < 0) {
2649  av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2650  return -1;
2651  }
2652  if (dcdiff) {
2653  if (dcdiff == 119 /* ESC index value */) {
2654  /* TODO: Optimize */
2655  if (v->pq == 1) dcdiff = get_bits(gb, 10);
2656  else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2657  else dcdiff = get_bits(gb, 8);
2658  } else {
2659  if (v->pq == 1)
2660  dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2661  else if (v->pq == 2)
2662  dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2663  }
2664  if (get_bits1(gb))
2665  dcdiff = -dcdiff;
2666  }
2667 
2668  /* Prediction */
2669  dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2670  *dc_val = dcdiff;
2671 
2672  /* Store the quantized DC coeff, used for prediction */
2673  if (n < 4) {
2674  block[0] = dcdiff * s->y_dc_scale;
2675  } else {
2676  block[0] = dcdiff * s->c_dc_scale;
2677  }
2678  /* Skip ? */
2679  if (!coded) {
2680  goto not_coded;
2681  }
2682 
2683  // AC Decoding
2684  i = 1;
2685 
2686  {
2687  int last = 0, skip, value;
2688  const uint8_t *zz_table;
2689  int scale;
2690  int k;
2691 
2692  scale = v->pq * 2 + v->halfpq;
2693 
2694  if (v->s.ac_pred) {
2695  if (!dc_pred_dir)
2696  zz_table = v->zz_8x8[2];
2697  else
2698  zz_table = v->zz_8x8[3];
2699  } else
2700  zz_table = v->zz_8x8[1];
2701 
2702  ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2703  ac_val2 = ac_val;
2704  if (dc_pred_dir) // left
2705  ac_val -= 16;
2706  else // top
2707  ac_val -= 16 * s->block_wrap[n];
2708 
2709  while (!last) {
2710  vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2711  i += skip;
2712  if (i > 63)
2713  break;
2714  block[zz_table[i++]] = value;
2715  }
2716 
2717  /* apply AC prediction if needed */
2718  if (s->ac_pred) {
2719  if (dc_pred_dir) { // left
2720  for (k = 1; k < 8; k++)
2721  block[k << v->left_blk_sh] += ac_val[k];
2722  } else { // top
2723  for (k = 1; k < 8; k++)
2724  block[k << v->top_blk_sh] += ac_val[k + 8];
2725  }
2726  }
2727  /* save AC coeffs for further prediction */
2728  for (k = 1; k < 8; k++) {
2729  ac_val2[k] = block[k << v->left_blk_sh];
2730  ac_val2[k + 8] = block[k << v->top_blk_sh];
2731  }
2732 
2733  /* scale AC coeffs */
2734  for (k = 1; k < 64; k++)
2735  if (block[k]) {
2736  block[k] *= scale;
2737  if (!v->pquantizer)
2738  block[k] += (block[k] < 0) ? -v->pq : v->pq;
2739  }
2740 
2741  if (s->ac_pred) i = 63;
2742  }
2743 
2744 not_coded:
2745  if (!coded) {
2746  int k, scale;
2747  ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2748  ac_val2 = ac_val;
2749 
2750  i = 0;
2751  scale = v->pq * 2 + v->halfpq;
2752  memset(ac_val2, 0, 16 * 2);
2753  if (dc_pred_dir) { // left
2754  ac_val -= 16;
2755  if (s->ac_pred)
2756  memcpy(ac_val2, ac_val, 8 * 2);
2757  } else { // top
2758  ac_val -= 16 * s->block_wrap[n];
2759  if (s->ac_pred)
2760  memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2761  }
2762 
2763  /* apply AC prediction if needed */
2764  if (s->ac_pred) {
2765  if (dc_pred_dir) { //left
2766  for (k = 1; k < 8; k++) {
2767  block[k << v->left_blk_sh] = ac_val[k] * scale;
2768  if (!v->pquantizer && block[k << v->left_blk_sh])
2769  block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2770  }
2771  } else { // top
2772  for (k = 1; k < 8; k++) {
2773  block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2774  if (!v->pquantizer && block[k << v->top_blk_sh])
2775  block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2776  }
2777  }
2778  i = 63;
2779  }
2780  }
2781  s->block_last_index[n] = i;
2782 
2783  return 0;
2784 }
2785 
2786 /** Decode intra block in intra frames - should be faster than decode_intra_block
2787  * @param v VC1Context
2788  * @param block block to decode
2789  * @param[in] n subblock number
2790  * @param coded are AC coeffs present or not
2791  * @param codingset set of VLC to decode data
2792  * @param mquant quantizer value for this macroblock
2793  */
2794 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
2795  int coded, int codingset, int mquant)
2796 {
2797  GetBitContext *gb = &v->s.gb;
2798  MpegEncContext *s = &v->s;
2799  int dc_pred_dir = 0; /* Direction of the DC prediction used */
2800  int i;
2801  int16_t *dc_val = NULL;
2802  int16_t *ac_val, *ac_val2;
2803  int dcdiff;
2804  int a_avail = v->a_avail, c_avail = v->c_avail;
2805  int use_pred = s->ac_pred;
2806  int scale;
2807  int q1, q2 = 0;
2808  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2809 
2810  /* Get DC differential */
2811  if (n < 4) {
2812  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2813  } else {
2814  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2815  }
2816  if (dcdiff < 0) {
2817  av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2818  return -1;
2819  }
2820  if (dcdiff) {
2821  if (dcdiff == 119 /* ESC index value */) {
2822  /* TODO: Optimize */
2823  if (mquant == 1) dcdiff = get_bits(gb, 10);
2824  else if (mquant == 2) dcdiff = get_bits(gb, 9);
2825  else dcdiff = get_bits(gb, 8);
2826  } else {
2827  if (mquant == 1)
2828  dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2829  else if (mquant == 2)
2830  dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
2831  }
2832  if (get_bits1(gb))
2833  dcdiff = -dcdiff;
2834  }
2835 
2836  /* Prediction */
2837  dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2838  *dc_val = dcdiff;
2839 
2840  /* Store the quantized DC coeff, used for prediction */
2841  if (n < 4) {
2842  block[0] = dcdiff * s->y_dc_scale;
2843  } else {
2844  block[0] = dcdiff * s->c_dc_scale;
2845  }
2846 
2847  //AC Decoding
2848  i = 1;
2849 
2850  /* check if AC is needed at all */
2851  if (!a_avail && !c_avail)
2852  use_pred = 0;
2853  ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2854  ac_val2 = ac_val;
2855 
2856  scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2857 
2858  if (dc_pred_dir) // left
2859  ac_val -= 16;
2860  else // top
2861  ac_val -= 16 * s->block_wrap[n];
2862 
2863  q1 = s->current_picture.qscale_table[mb_pos];
2864  if ( dc_pred_dir && c_avail && mb_pos)
2865  q2 = s->current_picture.qscale_table[mb_pos - 1];
2866  if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2867  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2868  if ( dc_pred_dir && n == 1)
2869  q2 = q1;
2870  if (!dc_pred_dir && n == 2)
2871  q2 = q1;
2872  if (n == 3)
2873  q2 = q1;
2874 
2875  if (coded) {
2876  int last = 0, skip, value;
2877  const uint8_t *zz_table;
2878  int k;
2879 
2880  if (v->s.ac_pred) {
2881  if (!use_pred && v->fcm == ILACE_FRAME) {
2882  zz_table = v->zzi_8x8;
2883  } else {
2884  if (!dc_pred_dir) // top
2885  zz_table = v->zz_8x8[2];
2886  else // left
2887  zz_table = v->zz_8x8[3];
2888  }
2889  } else {
2890  if (v->fcm != ILACE_FRAME)
2891  zz_table = v->zz_8x8[1];
2892  else
2893  zz_table = v->zzi_8x8;
2894  }
2895 
2896  while (!last) {
2897  vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2898  i += skip;
2899  if (i > 63)
2900  break;
2901  block[zz_table[i++]] = value;
2902  }
2903 
2904  /* apply AC prediction if needed */
2905  if (use_pred) {
2906  /* scale predictors if needed*/
2907  if (q2 && q1 != q2) {
2908  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2909  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2910 
2911  if (q1 < 1)
2912  return AVERROR_INVALIDDATA;
2913  if (dc_pred_dir) { // left
2914  for (k = 1; k < 8; k++)
2915  block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2916  } else { // top
2917  for (k = 1; k < 8; k++)
2918  block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2919  }
2920  } else {
2921  if (dc_pred_dir) { //left
2922  for (k = 1; k < 8; k++)
2923  block[k << v->left_blk_sh] += ac_val[k];
2924  } else { //top
2925  for (k = 1; k < 8; k++)
2926  block[k << v->top_blk_sh] += ac_val[k + 8];
2927  }
2928  }
2929  }
2930  /* save AC coeffs for further prediction */
2931  for (k = 1; k < 8; k++) {
2932  ac_val2[k ] = block[k << v->left_blk_sh];
2933  ac_val2[k + 8] = block[k << v->top_blk_sh];
2934  }
2935 
2936  /* scale AC coeffs */
2937  for (k = 1; k < 64; k++)
2938  if (block[k]) {
2939  block[k] *= scale;
2940  if (!v->pquantizer)
2941  block[k] += (block[k] < 0) ? -mquant : mquant;
2942  }
2943 
2944  if (use_pred) i = 63;
2945  } else { // no AC coeffs
2946  int k;
2947 
2948  memset(ac_val2, 0, 16 * 2);
2949  if (dc_pred_dir) { // left
2950  if (use_pred) {
2951  memcpy(ac_val2, ac_val, 8 * 2);
2952  if (q2 && q1 != q2) {
2953  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2954  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2955  if (q1 < 1)
2956  return AVERROR_INVALIDDATA;
2957  for (k = 1; k < 8; k++)
2958  ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2959  }
2960  }
2961  } else { // top
2962  if (use_pred) {
2963  memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2964  if (q2 && q1 != q2) {
2965  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2966  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2967  if (q1 < 1)
2968  return AVERROR_INVALIDDATA;
2969  for (k = 1; k < 8; k++)
2970  ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2971  }
2972  }
2973  }
2974 
2975  /* apply AC prediction if needed */
2976  if (use_pred) {
2977  if (dc_pred_dir) { // left
2978  for (k = 1; k < 8; k++) {
2979  block[k << v->left_blk_sh] = ac_val2[k] * scale;
2980  if (!v->pquantizer && block[k << v->left_blk_sh])
2981  block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2982  }
2983  } else { // top
2984  for (k = 1; k < 8; k++) {
2985  block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2986  if (!v->pquantizer && block[k << v->top_blk_sh])
2987  block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2988  }
2989  }
2990  i = 63;
2991  }
2992  }
2993  s->block_last_index[n] = i;
2994 
2995  return 0;
2996 }
2997 
2998 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2999  * @param v VC1Context
3000  * @param block block to decode
3001  * @param[in] n subblock index
3002  * @param coded are AC coeffs present or not
3003  * @param mquant block quantizer
3004  * @param codingset set of VLC to decode data
3005  */
3006 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
3007  int coded, int mquant, int codingset)
3008 {
3009  GetBitContext *gb = &v->s.gb;
3010  MpegEncContext *s = &v->s;
3011  int dc_pred_dir = 0; /* Direction of the DC prediction used */
3012  int i;
3013  int16_t *dc_val = NULL;
3014  int16_t *ac_val, *ac_val2;
3015  int dcdiff;
3016  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3017  int a_avail = v->a_avail, c_avail = v->c_avail;
3018  int use_pred = s->ac_pred;
3019  int scale;
3020  int q1, q2 = 0;
3021 
3022  s->dsp.clear_block(block);
3023 
3024  /* XXX: Guard against dumb values of mquant */
3025  mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
3026 
3027  /* Set DC scale - y and c use the same */
3028  s->y_dc_scale = s->y_dc_scale_table[mquant];
3029  s->c_dc_scale = s->c_dc_scale_table[mquant];
3030 
3031  /* Get DC differential */
3032  if (n < 4) {
3033  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3034  } else {
3035  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3036  }
3037  if (dcdiff < 0) {
3038  av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3039  return -1;
3040  }
3041  if (dcdiff) {
3042  if (dcdiff == 119 /* ESC index value */) {
3043  /* TODO: Optimize */
3044  if (mquant == 1) dcdiff = get_bits(gb, 10);
3045  else if (mquant == 2) dcdiff = get_bits(gb, 9);
3046  else dcdiff = get_bits(gb, 8);
3047  } else {
3048  if (mquant == 1)
3049  dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
3050  else if (mquant == 2)
3051  dcdiff = (dcdiff << 1) + get_bits1(gb) - 1;
3052  }
3053  if (get_bits1(gb))
3054  dcdiff = -dcdiff;
3055  }
3056 
3057  /* Prediction */
3058  dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3059  *dc_val = dcdiff;
3060 
3061  /* Store the quantized DC coeff, used for prediction */
3062 
3063  if (n < 4) {
3064  block[0] = dcdiff * s->y_dc_scale;
3065  } else {
3066  block[0] = dcdiff * s->c_dc_scale;
3067  }
3068 
3069  //AC Decoding
3070  i = 1;
3071 
3072  /* check if AC is needed at all and adjust direction if needed */
3073  if (!a_avail) dc_pred_dir = 1;
3074  if (!c_avail) dc_pred_dir = 0;
3075  if (!a_avail && !c_avail) use_pred = 0;
3076  ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3077  ac_val2 = ac_val;
3078 
3079  scale = mquant * 2 + v->halfpq;
3080 
3081  if (dc_pred_dir) //left
3082  ac_val -= 16;
3083  else //top
3084  ac_val -= 16 * s->block_wrap[n];
3085 
3086  q1 = s->current_picture.qscale_table[mb_pos];
3087  if (dc_pred_dir && c_avail && mb_pos)
3088  q2 = s->current_picture.qscale_table[mb_pos - 1];
3089  if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
3090  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3091  if ( dc_pred_dir && n == 1)
3092  q2 = q1;
3093  if (!dc_pred_dir && n == 2)
3094  q2 = q1;
3095  if (n == 3) q2 = q1;
3096 
3097  if (coded) {
3098  int last = 0, skip, value;
3099  int k;
3100 
3101  while (!last) {
3102  vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3103  i += skip;
3104  if (i > 63)
3105  break;
3106  if (v->fcm == PROGRESSIVE)
3107  block[v->zz_8x8[0][i++]] = value;
3108  else {
3109  if (use_pred && (v->fcm == ILACE_FRAME)) {
3110  if (!dc_pred_dir) // top
3111  block[v->zz_8x8[2][i++]] = value;
3112  else // left
3113  block[v->zz_8x8[3][i++]] = value;
3114  } else {
3115  block[v->zzi_8x8[i++]] = value;
3116  }
3117  }
3118  }
3119 
3120  /* apply AC prediction if needed */
3121  if (use_pred) {
3122  /* scale predictors if needed*/
3123  if (q2 && q1 != q2) {
3124  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3125  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3126 
3127  if (q1 < 1)
3128  return AVERROR_INVALIDDATA;
3129  if (dc_pred_dir) { // left
3130  for (k = 1; k < 8; k++)
3131  block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3132  } else { //top
3133  for (k = 1; k < 8; k++)
3134  block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3135  }
3136  } else {
3137  if (dc_pred_dir) { // left
3138  for (k = 1; k < 8; k++)
3139  block[k << v->left_blk_sh] += ac_val[k];
3140  } else { // top
3141  for (k = 1; k < 8; k++)
3142  block[k << v->top_blk_sh] += ac_val[k + 8];
3143  }
3144  }
3145  }
3146  /* save AC coeffs for further prediction */
3147  for (k = 1; k < 8; k++) {
3148  ac_val2[k ] = block[k << v->left_blk_sh];
3149  ac_val2[k + 8] = block[k << v->top_blk_sh];
3150  }
3151 
3152  /* scale AC coeffs */
3153  for (k = 1; k < 64; k++)
3154  if (block[k]) {
3155  block[k] *= scale;
3156  if (!v->pquantizer)
3157  block[k] += (block[k] < 0) ? -mquant : mquant;
3158  }
3159 
3160  if (use_pred) i = 63;
3161  } else { // no AC coeffs
3162  int k;
3163 
3164  memset(ac_val2, 0, 16 * 2);
3165  if (dc_pred_dir) { // left
3166  if (use_pred) {
3167  memcpy(ac_val2, ac_val, 8 * 2);
3168  if (q2 && q1 != q2) {
3169  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3170  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3171  if (q1 < 1)
3172  return AVERROR_INVALIDDATA;
3173  for (k = 1; k < 8; k++)
3174  ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3175  }
3176  }
3177  } else { // top
3178  if (use_pred) {
3179  memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3180  if (q2 && q1 != q2) {
3181  q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3182  q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3183  if (q1 < 1)
3184  return AVERROR_INVALIDDATA;
3185  for (k = 1; k < 8; k++)
3186  ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3187  }
3188  }
3189  }
3190 
3191  /* apply AC prediction if needed */
3192  if (use_pred) {
3193  if (dc_pred_dir) { // left
3194  for (k = 1; k < 8; k++) {
3195  block[k << v->left_blk_sh] = ac_val2[k] * scale;
3196  if (!v->pquantizer && block[k << v->left_blk_sh])
3197  block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3198  }
3199  } else { // top
3200  for (k = 1; k < 8; k++) {
3201  block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3202  if (!v->pquantizer && block[k << v->top_blk_sh])
3203  block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3204  }
3205  }
3206  i = 63;
3207  }
3208  }
3209  s->block_last_index[n] = i;
3210 
3211  return 0;
3212 }
3213 
3214 /** Decode P block
3215  */
3216 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
3217  int mquant, int ttmb, int first_block,
3218  uint8_t *dst, int linesize, int skip_block,
3219  int *ttmb_out)
3220 {
3221  MpegEncContext *s = &v->s;
3222  GetBitContext *gb = &s->gb;
3223  int i, j;
3224  int subblkpat = 0;
3225  int scale, off, idx, last, skip, value;
3226  int ttblk = ttmb & 7;
3227  int pat = 0;
3228 
3229  s->dsp.clear_block(block);
3230 
3231  if (ttmb == -1) {
3232  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)];
3233  }
3234  if (ttblk == TT_4X4) {
3235  subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3236  }
3237  if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3238  && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3239  || (!v->res_rtm_flag && !first_block))) {
3240  subblkpat = decode012(gb);
3241  if (subblkpat)
3242  subblkpat ^= 3; // swap decoded pattern bits
3243  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3244  ttblk = TT_8X4;
3245  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3246  ttblk = TT_4X8;
3247  }
3248  scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3249 
3250  // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3251  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3252  subblkpat = 2 - (ttblk == TT_8X4_TOP);
3253  ttblk = TT_8X4;
3254  }
3255  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3256  subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3257  ttblk = TT_4X8;
3258  }
3259  switch (ttblk) {
3260  case TT_8X8:
3261  pat = 0xF;
3262  i = 0;
3263  last = 0;
3264  while (!last) {
3265  vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3266  i += skip;
3267  if (i > 63)
3268  break;
3269  if (!v->fcm)
3270  idx = v->zz_8x8[0][i++];
3271  else
3272  idx = v->zzi_8x8[i++];
3273  block[idx] = value * scale;
3274  if (!v->pquantizer)
3275  block[idx] += (block[idx] < 0) ? -mquant : mquant;
3276  }
3277  if (!skip_block) {
3278  if (i == 1)
3279  v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3280  else {
3281  v->vc1dsp.vc1_inv_trans_8x8(block);
3282  s->dsp.add_pixels_clamped(block, dst, linesize);
3283  }
3284  }
3285  break;
3286  case TT_4X4:
3287  pat = ~subblkpat & 0xF;
3288  for (j = 0; j < 4; j++) {
3289  last = subblkpat & (1 << (3 - j));
3290  i = 0;
3291  off = (j & 1) * 4 + (j & 2) * 16;
3292  while (!last) {
3293  vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3294  i += skip;
3295  if (i > 15)
3296  break;
3297  if (!v->fcm)
3298  idx = ff_vc1_simple_progressive_4x4_zz[i++];
3299  else
3300  idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3301  block[idx + off] = value * scale;
3302  if (!v->pquantizer)
3303  block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3304  }
3305  if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3306  if (i == 1)
3307  v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3308  else
3309  v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3310  }
3311  }
3312  break;
3313  case TT_8X4:
3314  pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3315  for (j = 0; j < 2; j++) {
3316  last = subblkpat & (1 << (1 - j));
3317  i = 0;
3318  off = j * 32;
3319  while (!last) {
3320  vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3321  i += skip;
3322  if (i > 31)
3323  break;
3324  if (!v->fcm)
3325  idx = v->zz_8x4[i++] + off;
3326  else
3327  idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3328  block[idx] = value * scale;
3329  if (!v->pquantizer)
3330  block[idx] += (block[idx] < 0) ? -mquant : mquant;
3331  }
3332  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3333  if (i == 1)
3334  v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3335  else
3336  v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3337  }
3338  }
3339  break;
3340  case TT_4X8:
3341  pat = ~(subblkpat * 5) & 0xF;
3342  for (j = 0; j < 2; j++) {
3343  last = subblkpat & (1 << (1 - j));
3344  i = 0;
3345  off = j * 4;
3346  while (!last) {
3347  vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3348  i += skip;
3349  if (i > 31)
3350  break;
3351  if (!v->fcm)
3352  idx = v->zz_4x8[i++] + off;
3353  else
3354  idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3355  block[idx] = value * scale;
3356  if (!v->pquantizer)
3357  block[idx] += (block[idx] < 0) ? -mquant : mquant;
3358  }
3359  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3360  if (i == 1)
3361  v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3362  else
3363  v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3364  }
3365  }
3366  break;
3367  }
3368  if (ttmb_out)
3369  *ttmb_out |= ttblk << (n * 4);
3370  return pat;
3371 }
3372 
3373 /** @} */ // Macroblock group
3374 
3375 static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
3376 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3377 
3378 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3379 {
3380  MpegEncContext *s = &v->s;
3381  int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
3382  block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
3383  mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
3384  block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3385  int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3386  uint8_t *dst;
3387 
3388  if (block_num > 3) {
3389  dst = s->dest[block_num - 3];
3390  } else {
3391  dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3392  }
3393  if (s->mb_y != s->end_mb_y || block_num < 2) {
3394  int16_t (*mv)[2];
3395  int mv_stride;
3396 
3397  if (block_num > 3) {
3398  bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
3399  bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3400  mv = &v->luma_mv[s->mb_x - s->mb_stride];
3401  mv_stride = s->mb_stride;
3402  } else {
3403  bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
3404  : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
3405  bottom_is_intra = (block_num < 2) ? (mb_is_intra >> ((block_num + 2) * 4))
3406  : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3407  mv_stride = s->b8_stride;
3408  mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3409  }
3410 
3411  if (bottom_is_intra & 1 || block_is_intra & 1 ||
3412  mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3413  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3414  } else {
3415  idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3416  if (idx == 3) {
3417  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3418  } else if (idx) {
3419  if (idx == 1)
3420  v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3421  else
3422  v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3423  }
3424  }
3425  }
3426 
3427  dst -= 4 * linesize;
3428  ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3429  if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3430  idx = (block_cbp | (block_cbp >> 2)) & 3;
3431  if (idx == 3) {
3432  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3433  } else if (idx) {
3434  if (idx == 1)
3435  v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3436  else
3437  v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
3438  }
3439  }
3440 }
3441 
3442 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3443 {
3444  MpegEncContext *s = &v->s;
3445  int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
3446  block_cbp = mb_cbp >> (block_num * 4), right_cbp,
3447  mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
3448  block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3449  int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3450  uint8_t *dst;
3451 
3452  if (block_num > 3) {
3453  dst = s->dest[block_num - 3] - 8 * linesize;
3454  } else {
3455  dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3456  }
3457 
3458  if (s->mb_x != s->mb_width || !(block_num & 5)) {
3459  int16_t (*mv)[2];
3460 
3461  if (block_num > 3) {
3462  right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3463  right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3464  mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3465  } else {
3466  right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3467  : (mb_cbp >> ((block_num + 1) * 4));
3468  right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3469  : (mb_is_intra >> ((block_num + 1) * 4));
3470  mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3471  }
3472  if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3473  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3474  } else {
3475  idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3476  if (idx == 5) {
3477  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3478  } else if (idx) {
3479  if (idx == 1)
3480  v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3481  else
3482  v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3483  }
3484  }
3485  }
3486 
3487  dst -= 4;
3488  ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3489  if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3490  idx = (block_cbp | (block_cbp >> 1)) & 5;
3491  if (idx == 5) {
3492  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3493  } else if (idx) {
3494  if (idx == 1)
3495  v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3496  else
3497  v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
3498  }
3499  }
3500 }
3501 
3502 static void vc1_apply_p_loop_filter(VC1Context *v)
3503 {
3504  MpegEncContext *s = &v->s;
3505  int i;
3506 
3507  for (i = 0; i < 6; i++) {
3508  vc1_apply_p_v_loop_filter(v, i);
3509  }
3510 
3511  /* V always precedes H, therefore we run H one MB before V;
3512  * at the end of a row, we catch up to complete the row */
3513  if (s->mb_x) {
3514  for (i = 0; i < 6; i++) {
3515  vc1_apply_p_h_loop_filter(v, i);
3516  }
3517  if (s->mb_x == s->mb_width - 1) {
3518  s->mb_x++;
3519  ff_update_block_index(s);
3520  for (i = 0; i < 6; i++) {
3521  vc1_apply_p_h_loop_filter(v, i);
3522  }
3523  }
3524  }
3525 }
3526 
3527 /** Decode one P-frame MB
3528  */
3529 static int vc1_decode_p_mb(VC1Context *v)
3530 {
3531  MpegEncContext *s = &v->s;
3532  GetBitContext *gb = &s->gb;
3533  int i, j;
3534  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3535  int cbp; /* cbp decoding stuff */
3536  int mqdiff, mquant; /* MB quantization */
3537  int ttmb = v->ttfrm; /* MB Transform type */
3538 
3539  int mb_has_coeffs = 1; /* last_flag */
3540  int dmv_x, dmv_y; /* Differential MV components */
3541  int index, index1; /* LUT indexes */
3542  int val, sign; /* temp values */
3543  int first_block = 1;
3544  int dst_idx, off;
3545  int skipped, fourmv;
3546  int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3547 
3548  mquant = v->pq; /* lossy initialization */
3549 
3550  if (v->mv_type_is_raw)
3551  fourmv = get_bits1(gb);
3552  else
3553  fourmv = v->mv_type_mb_plane[mb_pos];
3554  if (v->skip_is_raw)
3555  skipped = get_bits1(gb);
3556  else
3557  skipped = v->s.mbskip_table[mb_pos];
3558 
3559  if (!fourmv) { /* 1MV mode */
3560  if (!skipped) {
3561  GET_MVDATA(dmv_x, dmv_y);
3562 
3563  if (s->mb_intra) {
3564  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3565  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3566  }
3567  s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3568  vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3569 
3570  /* FIXME Set DC val for inter block ? */
3571  if (s->mb_intra && !mb_has_coeffs) {
3572  GET_MQUANT();
3573  s->ac_pred = get_bits1(gb);
3574  cbp = 0;
3575  } else if (mb_has_coeffs) {
3576  if (s->mb_intra)
3577  s->ac_pred = get_bits1(gb);
3578  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3579  GET_MQUANT();
3580  } else {
3581  mquant = v->pq;
3582  cbp = 0;
3583  }
3584  s->current_picture.qscale_table[mb_pos] = mquant;
3585 
3586  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3587  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3588  VC1_TTMB_VLC_BITS, 2);
3589  if (!s->mb_intra) vc1_mc_1mv(v, 0);
3590  dst_idx = 0;
3591  for (i = 0; i < 6; i++) {
3592  s->dc_val[0][s->block_index[i]] = 0;
3593  dst_idx += i >> 2;
3594  val = ((cbp >> (5 - i)) & 1);
3595  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3596  v->mb_type[0][s->block_index[i]] = s->mb_intra;
3597  if (s->mb_intra) {
3598  /* check if prediction blocks A and C are available */
3599  v->a_avail = v->c_avail = 0;
3600  if (i == 2 || i == 3 || !s->first_slice_line)
3601  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3602  if (i == 1 || i == 3 || s->mb_x)
3603  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3604 
3605  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3606  (i & 4) ? v->codingset2 : v->codingset);
3607  if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3608  continue;
3609  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3610  if (v->rangeredfrm)
3611  for (j = 0; j < 64; j++)
3612  s->block[i][j] <<= 1;
3613  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3614  if (v->pq >= 9 && v->overlap) {
3615  if (v->c_avail)
3616  v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3617  if (v->a_avail)
3618  v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3619  }
3620  block_cbp |= 0xF << (i << 2);
3621  block_intra |= 1 << i;
3622  } else if (val) {
3623  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3624  s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3625  (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3626  block_cbp |= pat << (i << 2);
3627  if (!v->ttmbf && ttmb < 8)
3628  ttmb = -1;
3629  first_block = 0;
3630  }
3631  }
3632  } else { // skipped
3633  s->mb_intra = 0;
3634  for (i = 0; i < 6; i++) {
3635  v->mb_type[0][s->block_index[i]] = 0;
3636  s->dc_val[0][s->block_index[i]] = 0;
3637  }
3638  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3639  s->current_picture.qscale_table[mb_pos] = 0;
3640  vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3641  vc1_mc_1mv(v, 0);
3642  }
3643  } else { // 4MV mode
3644  if (!skipped /* unskipped MB */) {
3645  int intra_count = 0, coded_inter = 0;
3646  int is_intra[6], is_coded[6];
3647  /* Get CBPCY */
3648  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3649  for (i = 0; i < 6; i++) {
3650  val = ((cbp >> (5 - i)) & 1);
3651  s->dc_val[0][s->block_index[i]] = 0;
3652  s->mb_intra = 0;
3653  if (i < 4) {
3654  dmv_x = dmv_y = 0;
3655  s->mb_intra = 0;
3656  mb_has_coeffs = 0;
3657  if (val) {
3658  GET_MVDATA(dmv_x, dmv_y);
3659  }
3660  vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3661  if (!s->mb_intra)
3662  vc1_mc_4mv_luma(v, i, 0, 0);
3663  intra_count += s->mb_intra;
3664  is_intra[i] = s->mb_intra;
3665  is_coded[i] = mb_has_coeffs;
3666  }
3667  if (i & 4) {
3668  is_intra[i] = (intra_count >= 3);
3669  is_coded[i] = val;
3670  }
3671  if (i == 4)
3672  vc1_mc_4mv_chroma(v, 0);
3673  v->mb_type[0][s->block_index[i]] = is_intra[i];
3674  if (!coded_inter)
3675  coded_inter = !is_intra[i] & is_coded[i];
3676  }
3677  // if there are no coded blocks then don't do anything more
3678  dst_idx = 0;
3679  if (!intra_count && !coded_inter)
3680  goto end;
3681  GET_MQUANT();
3682  s->current_picture.qscale_table[mb_pos] = mquant;
3683  /* test if block is intra and has pred */
3684  {
3685  int intrapred = 0;
3686  for (i = 0; i < 6; i++)
3687  if (is_intra[i]) {
3688  if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3689  || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3690  intrapred = 1;
3691  break;
3692  }
3693  }
3694  if (intrapred)
3695  s->ac_pred = get_bits1(gb);
3696  else
3697  s->ac_pred = 0;
3698  }
3699  if (!v->ttmbf && coded_inter)
3700  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3701  for (i = 0; i < 6; i++) {
3702  dst_idx += i >> 2;
3703  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3704  s->mb_intra = is_intra[i];
3705  if (is_intra[i]) {
3706  /* check if prediction blocks A and C are available */
3707  v->a_avail = v->c_avail = 0;
3708  if (i == 2 || i == 3 || !s->first_slice_line)
3709  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3710  if (i == 1 || i == 3 || s->mb_x)
3711  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3712 
3713  vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3714  (i & 4) ? v->codingset2 : v->codingset);
3715  if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3716  continue;
3717  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3718  if (v->rangeredfrm)
3719  for (j = 0; j < 64; j++)
3720  s->block[i][j] <<= 1;
3721  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3722  (i & 4) ? s->uvlinesize : s->linesize);
3723  if (v->pq >= 9 && v->overlap) {
3724  if (v->c_avail)
3725  v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3726  if (v->a_avail)
3727  v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3728  }
3729  block_cbp |= 0xF << (i << 2);
3730  block_intra |= 1 << i;
3731  } else if (is_coded[i]) {
3732  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3733  first_block, s->dest[dst_idx] + off,
3734  (i & 4) ? s->uvlinesize : s->linesize,
3735  (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3736  &block_tt);
3737  block_cbp |= pat << (i << 2);
3738  if (!v->ttmbf && ttmb < 8)
3739  ttmb = -1;
3740  first_block = 0;
3741  }
3742  }
3743  } else { // skipped MB
3744  s->mb_intra = 0;
3745  s->current_picture.qscale_table[mb_pos] = 0;
3746  for (i = 0; i < 6; i++) {
3747  v->mb_type[0][s->block_index[i]] = 0;
3748  s->dc_val[0][s->block_index[i]] = 0;
3749  }
3750  for (i = 0; i < 4; i++) {
3751  vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3752  vc1_mc_4mv_luma(v, i, 0, 0);
3753  }
3754  vc1_mc_4mv_chroma(v, 0);
3755  s->current_picture.qscale_table[mb_pos] = 0;
3756  }
3757  }
3758 end:
3759  v->cbp[s->mb_x] = block_cbp;
3760  v->ttblk[s->mb_x] = block_tt;
3761  v->is_intra[s->mb_x] = block_intra;
3762 
3763  return 0;
3764 }
3765 
3766 /* Decode one macroblock in an interlaced frame p picture */
3767 
3768 static int vc1_decode_p_mb_intfr(VC1Context *v)
3769 {
3770  MpegEncContext *s = &v->s;
3771  GetBitContext *gb = &s->gb;
3772  int i;
3773  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3774  int cbp = 0; /* cbp decoding stuff */
3775  int mqdiff, mquant; /* MB quantization */
3776  int ttmb = v->ttfrm; /* MB Transform type */
3777 
3778  int mb_has_coeffs = 1; /* last_flag */
3779  int dmv_x, dmv_y; /* Differential MV components */
3780  int val; /* temp value */
3781  int first_block = 1;
3782  int dst_idx, off;
3783  int skipped, fourmv = 0, twomv = 0;
3784  int block_cbp = 0, pat, block_tt = 0;
3785  int idx_mbmode = 0, mvbp;
3786  int stride_y, fieldtx;
3787 
3788  mquant = v->pq; /* Lossy initialization */
3789 
3790  if (v->skip_is_raw)
3791  skipped = get_bits1(gb);
3792  else
3793  skipped = v->s.mbskip_table[mb_pos];
3794  if (!skipped) {
3795  if (v->fourmvswitch)
3796  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3797  else
3798  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3799  switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3800  /* store the motion vector type in a flag (useful later) */
3801  case MV_PMODE_INTFR_4MV:
3802  fourmv = 1;
3803  v->blk_mv_type[s->block_index[0]] = 0;
3804  v->blk_mv_type[s->block_index[1]] = 0;
3805  v->blk_mv_type[s->block_index[2]] = 0;
3806  v->blk_mv_type[s->block_index[3]] = 0;
3807  break;
3808  case MV_PMODE_INTFR_4MV_FIELD:
3809  fourmv = 1;
3810  v->blk_mv_type[s->block_index[0]] = 1;
3811  v->blk_mv_type[s->block_index[1]] = 1;
3812  v->blk_mv_type[s->block_index[2]] = 1;
3813  v->blk_mv_type[s->block_index[3]] = 1;
3814  break;
3815  case MV_PMODE_INTFR_2MV_FIELD:
3816  twomv = 1;
3817  v->blk_mv_type[s->block_index[0]] = 1;
3818  v->blk_mv_type[s->block_index[1]] = 1;
3819  v->blk_mv_type[s->block_index[2]] = 1;
3820  v->blk_mv_type[s->block_index[3]] = 1;
3821  break;
3822  case MV_PMODE_INTFR_1MV:
3823  v->blk_mv_type[s->block_index[0]] = 0;
3824  v->blk_mv_type[s->block_index[1]] = 0;
3825  v->blk_mv_type[s->block_index[2]] = 0;
3826  v->blk_mv_type[s->block_index[3]] = 0;
3827  break;
3828  }
3829  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3830  for (i = 0; i < 4; i++) {
3831  s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
3832  s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
3833  }
3834  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3835  s->mb_intra = v->is_intra[s->mb_x] = 1;
3836  for (i = 0; i < 6; i++)
3837  v->mb_type[0][s->block_index[i]] = 1;
3838  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3839  mb_has_coeffs = get_bits1(gb);
3840  if (mb_has_coeffs)
3841  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3842  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3843  GET_MQUANT();
3844  s->current_picture.qscale_table[mb_pos] = mquant;
3845  /* Set DC scale - y and c use the same (not sure if necessary here) */
3846  s->y_dc_scale = s->y_dc_scale_table[mquant];
3847  s->c_dc_scale = s->c_dc_scale_table[mquant];
3848  dst_idx = 0;
3849  for (i = 0; i < 6; i++) {
3850  s->dc_val[0][s->block_index[i]] = 0;
3851  dst_idx += i >> 2;
3852  val = ((cbp >> (5 - i)) & 1);
3853  v->mb_type[0][s->block_index[i]] = s->mb_intra;
3854  v->a_avail = v->c_avail = 0;
3855  if (i == 2 || i == 3 || !s->first_slice_line)
3856  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3857  if (i == 1 || i == 3 || s->mb_x)
3858  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3859 
3860  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3861  (i & 4) ? v->codingset2 : v->codingset);
3862  if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3863  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3864  if (i < 4) {
3865  stride_y = s->linesize << fieldtx;
3866  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3867  } else {
3868  stride_y = s->uvlinesize;
3869  off = 0;
3870  }
3871  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3872  //TODO: loop filter
3873  }
3874 
3875  } else { // inter MB
3876  mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3877  if (mb_has_coeffs)
3878  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3879  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3880  v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3881  } else {
3882  if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3883  || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3884  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3885  }
3886  }
3887  s->mb_intra = v->is_intra[s->mb_x] = 0;
3888  for (i = 0; i < 6; i++)
3889  v->mb_type[0][s->block_index[i]] = 0;
3890  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3891  /* for all motion vector read MVDATA and motion compensate each block */
3892  dst_idx = 0;
3893  if (fourmv) {
3894  mvbp = v->fourmvbp;
3895  for (i = 0; i < 6; i++) {
3896  if (i < 4) {
3897  dmv_x = dmv_y = 0;
3898  val = ((mvbp >> (3 - i)) & 1);
3899  if (val) {
3900  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3901  }
3902  vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0);
3903  vc1_mc_4mv_luma(v, i, 0, 0);
3904  } else if (i == 4) {
3905  vc1_mc_4mv_chroma4(v, 0, 0, 0);
3906  }
3907  }
3908  } else if (twomv) {
3909  mvbp = v->twomvbp;
3910  dmv_x = dmv_y = 0;
3911  if (mvbp & 2) {
3912  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3913  }
3914  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3915  vc1_mc_4mv_luma(v, 0, 0, 0);
3916  vc1_mc_4mv_luma(v, 1, 0, 0);
3917  dmv_x = dmv_y = 0;
3918  if (mvbp & 1) {
3919  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3920  }
3921  vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], 0);
3922  vc1_mc_4mv_luma(v, 2, 0, 0);
3923  vc1_mc_4mv_luma(v, 3, 0, 0);
3924  vc1_mc_4mv_chroma4(v, 0, 0, 0);
3925  } else {
3926  mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3927  dmv_x = dmv_y = 0;
3928  if (mvbp) {
3929  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3930  }
3931  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3932  vc1_mc_1mv(v, 0);
3933  }
3934  if (cbp)
3935  GET_MQUANT(); // p. 227
3936  s->current_picture.qscale_table[mb_pos] = mquant;
3937  if (!v->ttmbf && cbp)
3938  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3939  for (i = 0; i < 6; i++) {
3940  s->dc_val[0][s->block_index[i]] = 0;
3941  dst_idx += i >> 2;
3942  val = ((cbp >> (5 - i)) & 1);
3943  if (!fieldtx)
3944  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3945  else
3946  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3947  if (val) {
3948  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3949  first_block, s->dest[dst_idx] + off,
3950  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3951  (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3952  block_cbp |= pat << (i << 2);
3953  if (!v->ttmbf && ttmb < 8)
3954  ttmb = -1;
3955  first_block = 0;
3956  }
3957  }
3958  }
3959  } else { // skipped
3960  s->mb_intra = v->is_intra[s->mb_x] = 0;
3961  for (i = 0; i < 6; i++) {
3962  v->mb_type[0][s->block_index[i]] = 0;
3963  s->dc_val[0][s->block_index[i]] = 0;
3964  }
3965  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3966  s->current_picture.qscale_table[mb_pos] = 0;
3967  v->blk_mv_type[s->block_index[0]] = 0;
3968  v->blk_mv_type[s->block_index[1]] = 0;
3969  v->blk_mv_type[s->block_index[2]] = 0;
3970  v->blk_mv_type[s->block_index[3]] = 0;
3971  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
3972  vc1_mc_1mv(v, 0);
3973  }
3974  if (s->mb_x == s->mb_width - 1)
3975  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3976  return 0;
3977 }
3978 
3979 static int vc1_decode_p_mb_intfi(VC1Context *v)
3980 {
3981  MpegEncContext *s = &v->s;
3982  GetBitContext *gb = &s->gb;
3983  int i;
3984  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3985  int cbp = 0; /* cbp decoding stuff */
3986  int mqdiff, mquant; /* MB quantization */
3987  int ttmb = v->ttfrm; /* MB Transform type */
3988 
3989  int mb_has_coeffs = 1; /* last_flag */
3990  int dmv_x, dmv_y; /* Differential MV components */
3991  int val; /* temp values */
3992  int first_block = 1;
3993  int dst_idx, off;
3994  int pred_flag = 0;
3995  int block_cbp = 0, pat, block_tt = 0;
3996  int idx_mbmode = 0;
3997 
3998  mquant = v->pq; /* Lossy initialization */
3999 
4000  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4001  if (idx_mbmode <= 1) { // intra MB
4002  s->mb_intra = v->is_intra[s->mb_x] = 1;
4003  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4004  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4005  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4006  GET_MQUANT();
4007  s->current_picture.qscale_table[mb_pos] = mquant;
4008  /* Set DC scale - y and c use the same (not sure if necessary here) */
4009  s->y_dc_scale = s->y_dc_scale_table[mquant];
4010  s->c_dc_scale = s->c_dc_scale_table[mquant];
4011  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4012  mb_has_coeffs = idx_mbmode & 1;
4013  if (mb_has_coeffs)
4014  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4015  dst_idx = 0;
4016  for (i = 0; i < 6; i++) {
4017  s->dc_val[0][s->block_index[i]] = 0;
4018  v->mb_type[0][s->block_index[i]] = 1;
4019  dst_idx += i >> 2;
4020  val = ((cbp >> (5 - i)) & 1);
4021  v->a_avail = v->c_avail = 0;
4022  if (i == 2 || i == 3 || !s->first_slice_line)
4023  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4024  if (i == 1 || i == 3 || s->mb_x)
4025  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4026 
4027  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4028  (i & 4) ? v->codingset2 : v->codingset);
4029  if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4030  continue;
4031  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4032  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4033  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4034  // TODO: loop filter
4035  }
4036  } else {
4037  s->mb_intra = v->is_intra[s->mb_x] = 0;
4038  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4039  for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4040  if (idx_mbmode <= 5) { // 1-MV
4041  dmv_x = dmv_y = pred_flag = 0;
4042  if (idx_mbmode & 1) {
4043  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4044  }
4045  vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4046  vc1_mc_1mv(v, 0);
4047  mb_has_coeffs = !(idx_mbmode & 2);
4048  } else { // 4-MV
4049  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4050  for (i = 0; i < 6; i++) {
4051  if (i < 4) {
4052  dmv_x = dmv_y = pred_flag = 0;
4053  val = ((v->fourmvbp >> (3 - i)) & 1);
4054  if (val) {
4055  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
4056  }
4057  vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
4058  vc1_mc_4mv_luma(v, i, 0, 0);
4059  } else if (i == 4)
4060  vc1_mc_4mv_chroma(v, 0);
4061  }
4062  mb_has_coeffs = idx_mbmode & 1;
4063  }
4064  if (mb_has_coeffs)
4065  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4066  if (cbp) {
4067  GET_MQUANT();
4068  }
4069  s->current_picture.qscale_table[mb_pos] = mquant;
4070  if (!v->ttmbf && cbp) {
4071  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4072  }
4073  dst_idx = 0;
4074  for (i = 0; i < 6; i++) {
4075  s->dc_val[0][s->block_index[i]] = 0;
4076  dst_idx += i >> 2;
4077  val = ((cbp >> (5 - i)) & 1);
4078  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4079  if (val) {
4080  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4081  first_block, s->dest[dst_idx] + off,
4082  (i & 4) ? s->uvlinesize : s->linesize,
4083  (i & 4) && (s->flags & CODEC_FLAG_GRAY),
4084  &block_tt);
4085  block_cbp |= pat << (i << 2);
4086  if (!v->ttmbf && ttmb < 8) ttmb = -1;
4087  first_block = 0;
4088  }
4089  }
4090  }
4091  if (s->mb_x == s->mb_width - 1)
4092  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4093  return 0;
4094 }
4095 
4096 /** Decode one B-frame MB (in Main profile)
4097  */
4098 static void vc1_decode_b_mb(VC1Context *v)
4099 {
4100  MpegEncContext *s = &v->s;
4101  GetBitContext *gb = &s->gb;
4102  int i, j;
4103  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4104  int cbp = 0; /* cbp decoding stuff */
4105  int mqdiff, mquant; /* MB quantization */
4106  int ttmb = v->ttfrm; /* MB Transform type */
4107  int mb_has_coeffs = 0; /* last_flag */
4108  int index, index1; /* LUT indexes */
4109  int val, sign; /* temp values */
4110  int first_block = 1;
4111  int dst_idx, off;
4112  int skipped, direct;
4113  int dmv_x[2], dmv_y[2];
4114  int bmvtype = BMV_TYPE_BACKWARD;
4115 
4116  mquant = v->pq; /* lossy initialization */
4117  s->mb_intra = 0;
4118 
4119  if (v->dmb_is_raw)
4120  direct = get_bits1(gb);
4121  else
4122  direct = v->direct_mb_plane[mb_pos];
4123  if (v->skip_is_raw)
4124  skipped = get_bits1(gb);
4125  else
4126  skipped = v->s.mbskip_table[mb_pos];
4127 
4128  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4129  for (i = 0; i < 6; i++) {
4130  v->mb_type[0][s->block_index[i]] = 0;
4131  s->dc_val[0][s->block_index[i]] = 0;
4132  }
4133  s->current_picture.qscale_table[mb_pos] = 0;
4134 
4135  if (!direct) {
4136  if (!skipped) {
4137  GET_MVDATA(dmv_x[0], dmv_y[0]);
4138  dmv_x[1] = dmv_x[0];
4139  dmv_y[1] = dmv_y[0];
4140  }
4141  if (skipped || !s->mb_intra) {
4142  bmvtype = decode012(gb);
4143  switch (bmvtype) {
4144  case 0:
4145  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4146  break;
4147  case 1:
4148  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4149  break;
4150  case 2:
4151  bmvtype = BMV_TYPE_INTERPOLATED;
4152  dmv_x[0] = dmv_y[0] = 0;
4153  }
4154  }
4155  }
4156  for (i = 0; i < 6; i++)
4157  v->mb_type[0][s->block_index[i]] = s->mb_intra;
4158 
4159  if (skipped) {
4160  if (direct)
4161  bmvtype = BMV_TYPE_INTERPOLATED;
4162  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4163  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4164  return;
4165  }
4166  if (direct) {
4167  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4168  GET_MQUANT();
4169  s->mb_intra = 0;
4170  s->current_picture.qscale_table[mb_pos] = mquant;
4171  if (!v->ttmbf)
4172  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4173  dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4174  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4175  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4176  } else {
4177  if (!mb_has_coeffs && !s->mb_intra) {
4178  /* no coded blocks - effectively skipped */
4179  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4180  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4181  return;
4182  }
4183  if (s->mb_intra && !mb_has_coeffs) {
4184  GET_MQUANT();
4185  s->current_picture.qscale_table[mb_pos] = mquant;
4186  s->ac_pred = get_bits1(gb);
4187  cbp = 0;
4188  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4189  } else {
4190  if (bmvtype == BMV_TYPE_INTERPOLATED) {
4191  GET_MVDATA(dmv_x[0], dmv_y[0]);
4192  if (!mb_has_coeffs) {
4193  /* interpolated skipped block */
4194  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4195  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4196  return;
4197  }
4198  }
4199  vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4200  if (!s->mb_intra) {
4201  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4202  }
4203  if (s->mb_intra)
4204  s->ac_pred = get_bits1(gb);
4205  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4206  GET_MQUANT();
4207  s->current_picture.qscale_table[mb_pos] = mquant;
4208  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4209  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4210  }
4211  }
4212  dst_idx = 0;
4213  for (i = 0; i < 6; i++) {
4214  s->dc_val[0][s->block_index[i]] = 0;
4215  dst_idx += i >> 2;
4216  val = ((cbp >> (5 - i)) & 1);
4217  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4218  v->mb_type[0][s->block_index[i]] = s->mb_intra;
4219  if (s->mb_intra) {
4220  /* check if prediction blocks A and C are available */
4221  v->a_avail = v->c_avail = 0;
4222  if (i == 2 || i == 3 || !s->first_slice_line)
4223  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4224  if (i == 1 || i == 3 || s->mb_x)
4225  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4226 
4227  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4228  (i & 4) ? v->codingset2 : v->codingset);
4229  if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4230  continue;
4231  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4232  if (v->rangeredfrm)
4233  for (j = 0; j < 64; j++)
4234  s->block[i][j] <<= 1;
4235  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4236  } else if (val) {
4237  vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4238  first_block, s->dest[dst_idx] + off,
4239  (i & 4) ? s->uvlinesize : s->linesize,
4240  (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4241  if (!v->ttmbf && ttmb < 8)
4242  ttmb = -1;
4243  first_block = 0;
4244  }
4245  }
4246 }
4247 
4248 /** Decode one B-frame MB (in interlaced field B picture)
4249  */
4250 static void vc1_decode_b_mb_intfi(VC1Context *v)
4251 {
4252  MpegEncContext *s = &v->s;
4253  GetBitContext *gb = &s->gb;
4254  int i, j;
4255  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4256  int cbp = 0; /* cbp decoding stuff */
4257  int mqdiff, mquant; /* MB quantization */
4258  int ttmb = v->ttfrm; /* MB Transform type */
4259  int mb_has_coeffs = 0; /* last_flag */
4260  int val; /* temp value */
4261  int first_block = 1;
4262  int dst_idx, off;
4263  int fwd;
4264  int dmv_x[2], dmv_y[2], pred_flag[2];
4265  int bmvtype = BMV_TYPE_BACKWARD;
4266  int idx_mbmode;
4267 
4268  mquant = v->pq; /* Lossy initialization */
4269  s->mb_intra = 0;
4270 
4271  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4272  if (idx_mbmode <= 1) { // intra MB
4273  s->mb_intra = v->is_intra[s->mb_x] = 1;
4274  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4275  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4276  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4277  GET_MQUANT();
4278  s->current_picture.qscale_table[mb_pos] = mquant;
4279  /* Set DC scale - y and c use the same (not sure if necessary here) */
4280  s->y_dc_scale = s->y_dc_scale_table[mquant];
4281  s->c_dc_scale = s->c_dc_scale_table[mquant];
4282  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4283  mb_has_coeffs = idx_mbmode & 1;
4284  if (mb_has_coeffs)
4285  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4286  dst_idx = 0;
4287  for (i = 0; i < 6; i++) {
4288  s->dc_val[0][s->block_index[i]] = 0;
4289  dst_idx += i >> 2;
4290  val = ((cbp >> (5 - i)) & 1);
4291  v->mb_type[0][s->block_index[i]] = s->mb_intra;
4292  v->a_avail = v->c_avail = 0;
4293  if (i == 2 || i == 3 || !s->first_slice_line)
4294  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4295  if (i == 1 || i == 3 || s->mb_x)
4296  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4297 
4298  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4299  (i & 4) ? v->codingset2 : v->codingset);
4300  if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4301  continue;
4302  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4303  if (v->rangeredfrm)
4304  for (j = 0; j < 64; j++)
4305  s->block[i][j] <<= 1;
4306  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4307  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4308  // TODO: yet to perform loop filter
4309  }
4310  } else {
4311  s->mb_intra = v->is_intra[s->mb_x] = 0;
4312  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4313  for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4314  if (v->fmb_is_raw)
4315  fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4316  else
4317  fwd = v->forward_mb_plane[mb_pos];
4318  if (idx_mbmode <= 5) { // 1-MV
4319  int interpmvp = 0;
4320  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4321  pred_flag[0] = pred_flag[1] = 0;
4322  if (fwd)
4323  bmvtype = BMV_TYPE_FORWARD;
4324  else {
4325  bmvtype = decode012(gb);
4326  switch (bmvtype) {
4327  case 0:
4328  bmvtype = BMV_TYPE_BACKWARD;
4329  break;
4330  case 1:
4331  bmvtype = BMV_TYPE_DIRECT;
4332  break;
4333  case 2:
4334  bmvtype = BMV_TYPE_INTERPOLATED;
4335  interpmvp = get_bits1(gb);
4336  }
4337  }
4338  v->bmvtype = bmvtype;
4339  if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4340  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4341  }
4342  if (interpmvp) {
4343  get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4344  }
4345  if (bmvtype == BMV_TYPE_DIRECT) {
4346  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4347  dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4348  if (!s->next_picture_ptr->field_picture) {
4349  av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");
4350  return;
4351  }
4352  }
4353  vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4354  vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4355  mb_has_coeffs = !(idx_mbmode & 2);
4356  } else { // 4-MV
4357  if (fwd)
4358  bmvtype = BMV_TYPE_FORWARD;
4359  v->bmvtype = bmvtype;
4360  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4361  for (i = 0; i < 6; i++) {
4362  if (i < 4) {
4363  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4364  dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4365  val = ((v->fourmvbp >> (3 - i)) & 1);
4366  if (val) {
4367  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4368  &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4369  &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4370  }
4371  vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4372  vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
4373  } else if (i == 4)
4374  vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4375  }
4376  mb_has_coeffs = idx_mbmode & 1;
4377  }
4378  if (mb_has_coeffs)
4379  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4380  if (cbp) {
4381  GET_MQUANT();
4382  }
4383  s->current_picture.qscale_table[mb_pos] = mquant;
4384  if (!v->ttmbf && cbp) {
4385  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4386  }
4387  dst_idx = 0;
4388  for (i = 0; i < 6; i++) {
4389  s->dc_val[0][s->block_index[i]] = 0;
4390  dst_idx += i >> 2;
4391  val = ((cbp >> (5 - i)) & 1);
4392  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4393  if (val) {
4394  vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4395  first_block, s->dest[dst_idx] + off,
4396  (i & 4) ? s->uvlinesize : s->linesize,
4397  (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4398  if (!v->ttmbf && ttmb < 8)
4399  ttmb = -1;
4400  first_block = 0;
4401  }
4402  }
4403  }
4404 }
4405 
4406 /** Decode one B-frame MB (in interlaced frame B picture)
4407  */
4408 static int vc1_decode_b_mb_intfr(VC1Context *v)
4409 {
4410  MpegEncContext *s = &v->s;
4411  GetBitContext *gb = &s->gb;
4412  int i, j;
4413  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4414  int cbp = 0; /* cbp decoding stuff */
4415  int mqdiff, mquant; /* MB quantization */
4416  int ttmb = v->ttfrm; /* MB Transform type */
4417  int mvsw = 0; /* motion vector switch */
4418  int mb_has_coeffs = 1; /* last_flag */
4419  int dmv_x, dmv_y; /* Differential MV components */
4420  int val; /* temp value */
4421  int first_block = 1;
4422  int dst_idx, off;
4423  int skipped, direct, twomv = 0;
4424  int block_cbp = 0, pat, block_tt = 0;
4425  int idx_mbmode = 0, mvbp;
4426  int stride_y, fieldtx;
4427  int bmvtype = BMV_TYPE_BACKWARD;
4428  int dir, dir2;
4429 
4430  mquant = v->pq; /* Lossy initialization */
4431  s->mb_intra = 0;
4432  if (v->skip_is_raw)
4433  skipped = get_bits1(gb);
4434  else
4435  skipped = v->s.mbskip_table[mb_pos];
4436 
4437  if (!skipped) {
4438  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
4439  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
4440  twomv = 1;
4441  v->blk_mv_type[s->block_index[0]] = 1;
4442  v->blk_mv_type[s->block_index[1]] = 1;
4443  v->blk_mv_type[s->block_index[2]] = 1;
4444  v->blk_mv_type[s->block_index[3]] = 1;
4445  } else {
4446  v->blk_mv_type[s->block_index[0]] = 0;
4447  v->blk_mv_type[s->block_index[1]] = 0;
4448  v->blk_mv_type[s->block_index[2]] = 0;
4449  v->blk_mv_type[s->block_index[3]] = 0;
4450  }
4451  }
4452 
4453  if (v->dmb_is_raw)
4454  direct = get_bits1(gb);
4455  else
4456  direct = v->direct_mb_plane[mb_pos];
4457 
4458  if (direct) {
4459  if (s->next_picture_ptr->field_picture)
4460  av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
4461  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);
4462  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);
4463  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);
4464  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);
4465 
4466  if (twomv) {
4467  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);
4468  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);
4469  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);
4470  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);
4471 
4472  for (i = 1; i < 4; i += 2) {
4473  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
4474  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
4475  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
4476  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
4477  }
4478  } else {
4479  for (i = 1; i < 4; i++) {
4480  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
4481  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
4482  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
4483  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
4484  }
4485  }
4486  }
4487 
4488  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
4489  for (i = 0; i < 4; i++) {
4490  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
4491  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
4492  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
4493  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
4494  }
4495  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4496  s->mb_intra = v->is_intra[s->mb_x] = 1;
4497  for (i = 0; i < 6; i++)
4498  v->mb_type[0][s->block_index[i]] = 1;
4499  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
4500  mb_has_coeffs = get_bits1(gb);
4501  if (mb_has_coeffs)
4502  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4503  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
4504  GET_MQUANT();
4505  s->current_picture.qscale_table[mb_pos] = mquant;
4506  /* Set DC scale - y and c use the same (not sure if necessary here) */
4507  s->y_dc_scale = s->y_dc_scale_table[mquant];
4508  s->c_dc_scale = s->c_dc_scale_table[mquant];
4509  dst_idx = 0;
4510  for (i = 0; i < 6; i++) {
4511  s->dc_val[0][s->block_index[i]] = 0;
4512  dst_idx += i >> 2;
4513  val = ((cbp >> (5 - i)) & 1);
4514  v->mb_type[0][s->block_index[i]] = s->mb_intra;
4515  v->a_avail = v->c_avail = 0;
4516  if (i == 2 || i == 3 || !s->first_slice_line)
4517  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4518  if (i == 1 || i == 3 || s->mb_x)
4519  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4520 
4521  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4522  (i & 4) ? v->codingset2 : v->codingset);
4523  if (i > 3 && (s->flags & CODEC_FLAG_GRAY))
4524  continue;
4525  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4526  if (i < 4) {
4527  stride_y = s->linesize << fieldtx;
4528  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
4529  } else {
4530  stride_y = s->uvlinesize;
4531  off = 0;
4532  }
4533  s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
4534  }
4535  } else {
4536  s->mb_intra = v->is_intra[s->mb_x] = 0;
4537  if (!direct) {
4538  if (skipped || !s->mb_intra) {
4539  bmvtype = decode012(gb);
4540  switch (bmvtype) {
4541  case 0:
4542  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4543  break;
4544  case 1:
4545  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4546  break;
4547  case 2:
4548  bmvtype = BMV_TYPE_INTERPOLATED;
4549  }
4550  }
4551 
4552  if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
4553  mvsw = get_bits1(gb);
4554  }
4555 
4556  if (!skipped) { // inter MB
4557  mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
4558  if (mb_has_coeffs)
4559  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4560  if (!direct) {
4561  if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
4562  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4563  } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
4564  v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
4565  }
4566  }
4567 
4568  for (i = 0; i < 6; i++)
4569  v->mb_type[0][s->block_index[i]] = 0;
4570  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
4571  /* for all motion vector read MVDATA and motion compensate each block */
4572  dst_idx = 0;
4573  if (direct) {
4574  if (twomv) {
4575  for (i = 0; i < 4; i++) {
4576  vc1_mc_4mv_luma(v, i, 0, 0);
4577  vc1_mc_4mv_luma(v, i, 1, 1);
4578  }
4579  vc1_mc_4mv_chroma4(v, 0, 0, 0);
4580  vc1_mc_4mv_chroma4(v, 1, 1, 1);
4581  } else {
4582  vc1_mc_1mv(v, 0);
4583  vc1_interp_mc(v);
4584  }
4585  } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
4586  mvbp = v->fourmvbp;
4587  for (i = 0; i < 4; i++) {
4588  dir = i==1 || i==3;
4589  dmv_x = dmv_y = 0;
4590  val = ((mvbp >> (3 - i)) & 1);
4591  if (val)
4592  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4593  j = i > 1 ? 2 : 0;
4594  vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4595  vc1_mc_4mv_luma(v, j, dir, dir);
4596  vc1_mc_4mv_luma(v, j+1, dir, dir);
4597  }
4598 
4599  vc1_mc_4mv_chroma4(v, 0, 0, 0);
4600  vc1_mc_4mv_chroma4(v, 1, 1, 1);
4601  } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
4602  mvbp = v->twomvbp;
4603  dmv_x = dmv_y = 0;
4604  if (mvbp & 2)
4605  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4606 
4607  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4608  vc1_mc_1mv(v, 0);
4609 
4610  dmv_x = dmv_y = 0;
4611  if (mvbp & 1)
4612  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4613 
4614  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4615  vc1_interp_mc(v);
4616  } else if (twomv) {
4617  dir = bmvtype == BMV_TYPE_BACKWARD;
4618  dir2 = dir;
4619  if (mvsw)
4620  dir2 = !dir;
4621  mvbp = v->twomvbp;
4622  dmv_x = dmv_y = 0;
4623  if (mvbp & 2)
4624  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4625  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir);
4626 
4627  dmv_x = dmv_y = 0;
4628  if (mvbp & 1)
4629  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4630  vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0], dir2);
4631 
4632  if (mvsw) {
4633  for (i = 0; i < 2; i++) {
4634  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];
4635  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];
4636  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];
4637  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];
4638  }
4639  } else {
4640  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4641  vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, v->mb_type[0], !dir);
4642  }
4643 
4644  vc1_mc_4mv_luma(v, 0, dir, 0);
4645  vc1_mc_4mv_luma(v, 1, dir, 0);
4646  vc1_mc_4mv_luma(v, 2, dir2, 0);
4647  vc1_mc_4mv_luma(v, 3, dir2, 0);
4648  vc1_mc_4mv_chroma4(v, dir, dir2, 0);
4649  } else {
4650  dir = bmvtype == BMV_TYPE_BACKWARD;
4651 
4652  mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
4653  dmv_x = dmv_y = 0;
4654  if (mvbp)
4655  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
4656 
4657  vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4658  v->blk_mv_type[s->block_index[0]] = 1;
4659  v->blk_mv_type[s->block_index[1]] = 1;
4660  v->blk_mv_type[s->block_index[2]] = 1;
4661  v->blk_mv_type[s->block_index[3]] = 1;
4662  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4663  for (i = 0; i < 2; i++) {
4664  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];
4665  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];
4666  }
4667  vc1_mc_1mv(v, dir);
4668  }
4669 
4670  if (cbp)
4671  GET_MQUANT(); // p. 227
4672  s->current_picture.qscale_table[mb_pos] = mquant;
4673  if (!v->ttmbf && cbp)
4674  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4675  for (i = 0; i < 6; i++) {
4676  s->dc_val[0][s->block_index[i]] = 0;
4677  dst_idx += i >> 2;
4678  val = ((cbp >> (5 - i)) & 1);
4679  if (!fieldtx)
4680  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4681  else
4682  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
4683  if (val) {
4684  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4685  first_block, s->dest[dst_idx] + off,
4686  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
4687  (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
4688  block_cbp |= pat << (i << 2);
4689  if (!v->ttmbf && ttmb < 8)
4690  ttmb = -1;
4691  first_block = 0;
4692  }
4693  }
4694 
4695  } else { // skipped
4696  dir = 0;
4697  for (i = 0; i < 6; i++) {
4698  v->mb_type[0][s->block_index[i]] = 0;
4699  s->dc_val[0][s->block_index[i]] = 0;
4700  }
4701  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
4702  s->current_picture.qscale_table[mb_pos] = 0;
4703  v->blk_mv_type[s->block_index[0]] = 0;
4704  v->blk_mv_type[s->block_index[1]] = 0;
4705  v->blk_mv_type[s->block_index[2]] = 0;
4706  v->blk_mv_type[s->block_index[3]] = 0;
4707 
4708  if (!direct) {
4709  if (bmvtype == BMV_TYPE_INTERPOLATED) {
4710  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0);
4711  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 1);
4712  } else {
4713  dir = bmvtype == BMV_TYPE_BACKWARD;
4714  vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], dir);
4715  if (mvsw) {
4716  int dir2 = dir;
4717  if (mvsw)
4718  dir2 = !dir;
4719  for (i = 0; i < 2; i++) {
4720  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];
4721  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];
4722  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];
4723  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];
4724  }
4725  } else {
4726  v->blk_mv_type[s->block_index[0]] = 1;
4727  v->blk_mv_type[s->block_index[1]] = 1;
4728  v->blk_mv_type[s->block_index[2]] = 1;
4729  v->blk_mv_type[s->block_index[3]] = 1;
4730  vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, 0, !dir);
4731  for (i = 0; i < 2; i++) {
4732  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];
4733  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];
4734  }
4735  }
4736  }
4737  }
4738 
4739  vc1_mc_1mv(v, dir);
4740  if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
4741  vc1_interp_mc(v);
4742  }
4743  }
4744  }
4745  if (s->mb_x == s->mb_width - 1)
4746  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4747  v->cbp[s->mb_x] = block_cbp;
4748  v->ttblk[s->mb_x] = block_tt;
4749  return 0;
4750 }
4751 
4752 /** Decode blocks of I-frame
4753  */
4754 static void vc1_decode_i_blocks(VC1Context *v)
4755 {
4756  int k, j;
4757  MpegEncContext *s = &v->s;
4758  int cbp, val;
4759  uint8_t *coded_val;
4760  int mb_pos;
4761 
4762  /* select codingmode used for VLC tables selection */
4763  switch (v->y_ac_table_index) {
4764  case 0:
4765  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4766  break;
4767  case 1:
4768  v->codingset = CS_HIGH_MOT_INTRA;
4769  break;
4770  case 2:
4771  v->codingset = CS_MID_RATE_INTRA;
4772  break;
4773  }
4774 
4775  switch (v->c_ac_table_index) {
4776  case 0:
4777  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4778  break;
4779  case 1:
4780  v->codingset2 = CS_HIGH_MOT_INTER;
4781  break;
4782  case 2:
4783  v->codingset2 = CS_MID_RATE_INTER;
4784  break;
4785  }
4786 
4787  /* Set DC scale - y and c use the same */
4788  s->y_dc_scale = s->y_dc_scale_table[v->pq];
4789  s->c_dc_scale = s->c_dc_scale_table[v->pq];
4790 
4791  //do frame decode
4792  s->mb_x = s->mb_y = 0;
4793  s->mb_intra = 1;
4794  s->first_slice_line = 1;
4795  for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4796  s->mb_x = 0;
4797  init_block_index(v);
4798  for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4799  uint8_t *dst[6];
4800  ff_update_block_index(s);
4801  dst[0] = s->dest[0];
4802  dst[1] = dst[0] + 8;
4803  dst[2] = s->dest[0] + s->linesize * 8;
4804  dst[3] = dst[2] + 8;
4805  dst[4] = s->dest[1];
4806  dst[5] = s->dest[2];
4807  s->dsp.clear_blocks(s->block[0]);
4808  mb_pos = s->mb_x + s->mb_y * s->mb_width;
4809  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
4810  s->current_picture.qscale_table[mb_pos] = v->pq;
4811  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
4812  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
4813 
4814  // do actual MB decoding and displaying
4815  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4816  v->s.ac_pred = get_bits1(&v->s.gb);
4817 
4818  for (k = 0; k < 6; k++) {
4819  val = ((cbp >> (5 - k)) & 1);
4820 
4821  if (k < 4) {
4822  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4823  val = val ^ pred;
4824  *coded_val = val;
4825  }
4826  cbp |= val << (5 - k);
4827 
4828  vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4829 
4830  if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4831  continue;
4832  v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4833  if (v->pq >= 9 && v->overlap) {
4834  if (v->rangeredfrm)
4835  for (j = 0; j < 64; j++)
4836  s->block[k][j] <<= 1;
4837  s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4838  } else {
4839  if (v->rangeredfrm)
4840  for (j = 0; j < 64; j++)
4841  s->block[k][j] = (s->block[k][j] - 64) << 1;
4842  s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4843  }
4844  }
4845 
4846  if (v->pq >= 9 && v->overlap) {
4847  if (s->mb_x) {
4848  v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4849  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4850  if (!(s->flags & CODEC_FLAG_GRAY)) {
4851  v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4852  v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4853  }
4854  }
4855  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4856  v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4857  if (!s->first_slice_line) {
4858  v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4859  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4860  if (!(s->flags & CODEC_FLAG_GRAY)) {
4861  v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4862  v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4863  }
4864  }
4865  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4866  v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4867  }
4868  if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4869 
4870  if (get_bits_count(&s->gb) > v->bits) {
4871  ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4872  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4873  get_bits_count(&s->gb), v->bits);
4874  return;
4875  }
4876  }
4877  if (!v->s.loop_filter)
4878  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
4879  else if (s->mb_y)
4880  ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4881 
4882  s->first_slice_line = 0;
4883  }
4884  if (v->s.loop_filter)
4885  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4886 
4887  /* This is intentionally mb_height and not end_mb_y - unlike in advanced
4888  * profile, these only differ are when decoding MSS2 rectangles. */
4889  ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4890 }
4891 
4892 /** Decode blocks of I-frame for advanced profile
4893  */
4894 static void vc1_decode_i_blocks_adv(VC1Context *v)
4895 {
4896  int k;
4897  MpegEncContext *s = &v->s;
4898  int cbp, val;
4899  uint8_t *coded_val;
4900  int mb_pos;
4901  int mquant = v->pq;
4902  int mqdiff;
4903  GetBitContext *gb = &s->gb;
4904 
4905  /* select codingmode used for VLC tables selection */
4906  switch (v->y_ac_table_index) {
4907  case 0:
4908  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4909  break;
4910  case 1:
4911  v->codingset = CS_HIGH_MOT_INTRA;
4912  break;
4913  case 2:
4914  v->codingset = CS_MID_RATE_INTRA;
4915  break;
4916  }
4917 
4918  switch (v->c_ac_table_index) {
4919  case 0:
4920  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4921  break;
4922  case 1:
4923  v->codingset2 = CS_HIGH_MOT_INTER;
4924  break;
4925  case 2:
4926  v->codingset2 = CS_MID_RATE_INTER;
4927  break;
4928  }
4929 
4930  // do frame decode
4931  s->mb_x = s->mb_y = 0;
4932  s->mb_intra = 1;
4933  s->first_slice_line = 1;
4934  s->mb_y = s->start_mb_y;
4935  if (s->start_mb_y) {
4936  s->mb_x = 0;
4937  init_block_index(v);
4938  memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4939  (1 + s->b8_stride) * sizeof(*s->coded_block));
4940  }
4941  for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4942  s->mb_x = 0;
4943  init_block_index(v);
4944  for (;s->mb_x < s->mb_width; s->mb_x++) {
4945  int16_t (*block)[64] = v->block[v->cur_blk_idx];
4946  ff_update_block_index(s);
4947  s->dsp.clear_blocks(block[0]);
4948  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4949  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
4950  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4951  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4952 
4953  // do actual MB decoding and displaying
4954  if (v->fieldtx_is_raw)
4955  v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4956  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4957  if ( v->acpred_is_raw)
4958  v->s.ac_pred = get_bits1(&v->s.gb);
4959  else
4960  v->s.ac_pred = v->acpred_plane[mb_pos];
4961 
4962  if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4963  v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4964 
4965  GET_MQUANT();
4966 
4967  s->current_picture.qscale_table[mb_pos] = mquant;
4968  /* Set DC scale - y and c use the same */
4969  s->y_dc_scale = s->y_dc_scale_table[mquant];
4970  s->c_dc_scale = s->c_dc_scale_table[mquant];
4971 
4972  for (k = 0; k < 6; k++) {
4973  val = ((cbp >> (5 - k)) & 1);
4974 
4975  if (k < 4) {
4976  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
4977  val = val ^ pred;
4978  *coded_val = val;
4979  }
4980  cbp |= val << (5 - k);
4981 
4982  v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4983  v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4984 
4985  vc1_decode_i_block_adv(v, block[k], k, val,
4986  (k < 4) ? v->codingset : v->codingset2, mquant);
4987 
4988  if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4989  continue;
4990  v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4991  }
4992 
4993  vc1_smooth_overlap_filter_iblk(v);
4994  vc1_put_signed_blocks_clamped(v);
4995  if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4996 
4997  if (get_bits_count(&s->gb) > v->bits) {
4998  // TODO: may need modification to handle slice coding
4999  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5000  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
5001  get_bits_count(&s->gb), v->bits);
5002  return;
5003  }
5004  }
5005  if (!v->s.loop_filter)
5006  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5007  else if (s->mb_y)
5008  ff_mpeg_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
5009  s->first_slice_line = 0;
5010  }
5011 
5012  /* raw bottom MB row */
5013  s->mb_x = 0;
5014  init_block_index(v);
5015 
5016  for (;s->mb_x < s->mb_width; s->mb_x++) {
5017  ff_update_block_index(s);
5018  vc1_put_signed_blocks_clamped(v);
5019  if (v->s.loop_filter)
5020  vc1_loop_filter_iblk_delayed(v, v->pq);
5021  }
5022  if (v->s.loop_filter)
5023  ff_mpeg_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
5024  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5025  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5026 }
5027 
5028 static void vc1_decode_p_blocks(VC1Context *v)
5029 {
5030  MpegEncContext *s = &v->s;
5031  int apply_loop_filter;
5032 
5033  /* select codingmode used for VLC tables selection */
5034  switch (v->c_ac_table_index) {
5035  case 0:
5036  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5037  break;
5038  case 1:
5039  v->codingset = CS_HIGH_MOT_INTRA;
5040  break;
5041  case 2:
5042  v->codingset = CS_MID_RATE_INTRA;
5043  break;
5044  }
5045 
5046  switch (v->c_ac_table_index) {
5047  case 0:
5048  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5049  break;
5050  case 1:
5051  v->codingset2 = CS_HIGH_MOT_INTER;
5052  break;
5053  case 2:
5054  v->codingset2 = CS_MID_RATE_INTER;
5055  break;
5056  }
5057 
5058  apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY) &&
5059  v->fcm == PROGRESSIVE;
5060  s->first_slice_line = 1;
5061  memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
5062  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5063  s->mb_x = 0;
5064  init_block_index(v);
5065  for (; s->mb_x < s->mb_width; s->mb_x++) {
5066  ff_update_block_index(s);
5067 
5068  if (v->fcm == ILACE_FIELD)
5069  vc1_decode_p_mb_intfi(v);
5070  else if (v->fcm == ILACE_FRAME)
5071  vc1_decode_p_mb_intfr(v);
5072  else vc1_decode_p_mb(v);
5073  if (s->mb_y != s->start_mb_y && apply_loop_filter)
5074  vc1_apply_p_loop_filter(v);
5075  if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5076  // TODO: may need modification to handle slice coding
5077  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5078  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5079  get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5080  return;
5081  }
5082  }
5083  memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0]) * s->mb_stride);
5084  memmove(v->ttblk_base, v->ttblk, sizeof(v->ttblk_base[0]) * s->mb_stride);
5085  memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
5086  memmove(v->luma_mv_base, v->luma_mv, sizeof(v->luma_mv_base[0]) * s->mb_stride);
5087  if (s->mb_y != s->start_mb_y) ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5088  s->first_slice_line = 0;
5089  }
5090  if (apply_loop_filter) {
5091  s->mb_x = 0;
5092  init_block_index(v);
5093  for (; s->mb_x < s->mb_width; s->mb_x++) {
5094  ff_update_block_index(s);
5095  vc1_apply_p_loop_filter(v);
5096  }
5097  }
5098  if (s->end_mb_y >= s->start_mb_y)
5099  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5100  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5101  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5102 }
5103 
5104 static void vc1_decode_b_blocks(VC1Context *v)
5105 {
5106  MpegEncContext *s = &v->s;
5107 
5108  /* select codingmode used for VLC tables selection */
5109  switch (v->c_ac_table_index) {
5110  case 0:
5111  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
5112  break;
5113  case 1:
5114  v->codingset = CS_HIGH_MOT_INTRA;
5115  break;
5116  case 2:
5117  v->codingset = CS_MID_RATE_INTRA;
5118  break;
5119  }
5120 
5121  switch (v->c_ac_table_index) {
5122  case 0:
5123  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
5124  break;
5125  case 1:
5126  v->codingset2 = CS_HIGH_MOT_INTER;
5127  break;
5128  case 2:
5129  v->codingset2 = CS_MID_RATE_INTER;
5130  break;
5131  }
5132 
5133  s->first_slice_line = 1;
5134  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5135  s->mb_x = 0;
5136  init_block_index(v);
5137  for (; s->mb_x < s->mb_width; s->mb_x++) {
5138  ff_update_block_index(s);
5139 
5140  if (v->fcm == ILACE_FIELD)
5141  vc1_decode_b_mb_intfi(v);
5142  else if (v->fcm == ILACE_FRAME)
5143  vc1_decode_b_mb_intfr(v);
5144  else
5145  vc1_decode_b_mb(v);
5146  if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
5147  // TODO: may need modification to handle slice coding
5148  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
5149  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
5150  get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
5151  return;
5152  }
5153  if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
5154  }
5155  if (!v->s.loop_filter)
5156  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5157  else if (s->mb_y)
5158  ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
5159  s->first_slice_line = 0;
5160  }
5161  if (v->s.loop_filter)
5162  ff_mpeg_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
5163  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
5164  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
5165 }
5166 
5167 static void vc1_decode_skip_blocks(VC1Context *v)
5168 {
5169  MpegEncContext *s = &v->s;
5170 
5171  if (!v->s.last_picture.f.data[0])
5172  return;
5173 
5174  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
5175  s->first_slice_line = 1;
5176  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
5177  s->mb_x = 0;
5178  init_block_index(v);
5179  ff_update_block_index(s);
5180  memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
5181  memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5182  memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
5183  ff_mpeg_draw_horiz_band(s, s->mb_y * 16, 16);
5184  s->first_slice_line = 0;
5185  }
5186  s->pict_type = AV_PICTURE_TYPE_P;
5187 }
5188 
5189 void ff_vc1_decode_blocks(VC1Context *v)
5190 {
5191 
5192  v->s.esc3_level_length = 0;
5193  if (v->x8_type) {
5194  ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
5195  } else {
5196  v->cur_blk_idx = 0;
5197  v->left_blk_idx = -1;
5198  v->topleft_blk_idx = 1;
5199  v->top_blk_idx = 2;
5200  switch (v->s.pict_type) {
5201  case AV_PICTURE_TYPE_I:
5202  if (v->profile == PROFILE_ADVANCED)
5203  vc1_decode_i_blocks_adv(v);
5204  else
5205  vc1_decode_i_blocks(v);
5206  break;
5207  case AV_PICTURE_TYPE_P:
5208  if (v->p_frame_skipped)
5209  vc1_decode_skip_blocks(v);
5210  else
5211  vc1_decode_p_blocks(v);
5212  break;
5213  case AV_PICTURE_TYPE_B:
5214  if (v->bi_type) {
5215  if (v->profile == PROFILE_ADVANCED)
5216  vc1_decode_i_blocks_adv(v);
5217  else
5218  vc1_decode_i_blocks(v);
5219  } else
5220  vc1_decode_b_blocks(v);
5221  break;
5222  }
5223  }
5224 }
5225 
5226 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5227 
5228 typedef struct {
5229  /**
5230  * Transform coefficients for both sprites in 16.16 fixed point format,
5231  * in the order they appear in the bitstream:
5232  * x scale
5233  * rotation 1 (unused)
5234  * x offset
5235  * rotation 2 (unused)
5236  * y scale
5237  * y offset
5238  * alpha
5239  */
5240  int coefs[2][7];
5241 
5242  int effect_type, effect_flag;
5243  int effect_pcount1, effect_pcount2; ///< amount of effect parameters stored in effect_params
5244  int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
5245 } SpriteData;
5246 
5247 static inline int get_fp_val(GetBitContext* gb)
5248 {
5249  return (get_bits_long(gb, 30) - (1 << 29)) << 1;
5250 }
5251 
5252 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
5253 {
5254  c[1] = c[3] = 0;
5255 
5256  switch (get_bits(gb, 2)) {
5257  case 0:
5258  c[0] = 1 << 16;
5259  c[2] = get_fp_val(gb);
5260  c[4] = 1 << 16;
5261  break;
5262  case 1:
5263  c[0] = c[4] = get_fp_val(gb);
5264  c[2] = get_fp_val(gb);
5265  break;
5266  case 2:
5267  c[0] = get_fp_val(gb);
5268  c[2] = get_fp_val(gb);
5269  c[4] = get_fp_val(gb);
5270  break;
5271  case 3:
5272  c[0] = get_fp_val(gb);
5273  c[1] = get_fp_val(gb);
5274  c[2] = get_fp_val(gb);
5275  c[3] = get_fp_val(gb);
5276  c[4] = get_fp_val(gb);
5277  break;
5278  }
5279  c[5] = get_fp_val(gb);
5280  if (get_bits1(gb))
5281  c[6] = get_fp_val(gb);
5282  else
5283  c[6] = 1 << 16;
5284 }
5285 
5286 static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
5287 {
5288  AVCodecContext *avctx = v->s.avctx;
5289  int sprite, i;
5290 
5291  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5292  vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
5293  if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
5294  avpriv_request_sample(avctx, "Non-zero rotation coefficients");
5295  av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
5296  for (i = 0; i < 7; i++)
5297  av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
5298  sd->coefs[sprite][i] / (1<<16),
5299  (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
5300  av_log(avctx, AV_LOG_DEBUG, "\n");
5301  }
5302 
5303  skip_bits(gb, 2);
5304  if (sd->effect_type = get_bits_long(gb, 30)) {
5305  switch (sd->effect_pcount1 = get_bits(gb, 4)) {
5306  case 7:
5307  vc1_sprite_parse_transform(gb, sd->effect_params1);
5308  break;
5309  case 14:
5310  vc1_sprite_parse_transform(gb, sd->effect_params1);
5311  vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
5312  break;
5313  default:
5314  for (i = 0; i < sd->effect_pcount1; i++)
5315  sd->effect_params1[i] = get_fp_val(gb);
5316  }
5317  if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
5318  // effect 13 is simple alpha blending and matches the opacity above
5319  av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
5320  for (i = 0; i < sd->effect_pcount1; i++)
5321  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5322  sd->effect_params1[i] / (1 << 16),
5323  (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
5324  av_log(avctx, AV_LOG_DEBUG, "\n");
5325  }
5326 
5327  sd->effect_pcount2 = get_bits(gb, 16);
5328  if (sd->effect_pcount2 > 10) {
5329  av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
5330  return AVERROR_INVALIDDATA;
5331  } else if (sd->effect_pcount2) {
5332  i = -1;
5333  av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
5334  while (++i < sd->effect_pcount2) {
5335  sd->effect_params2[i] = get_fp_val(gb);
5336  av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
5337  sd->effect_params2[i] / (1 << 16),
5338  (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
5339  }
5340  av_log(avctx, AV_LOG_DEBUG, "\n");
5341  }
5342  }
5343  if (sd->effect_flag = get_bits1(gb))
5344  av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
5345 
5346  if (get_bits_count(gb) >= gb->size_in_bits +
5347  (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
5348  av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
5349  return AVERROR_INVALIDDATA;
5350  }
5351  if (get_bits_count(gb) < gb->size_in_bits - 8)
5352  av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5353 
5354  return 0;
5355 }
5356 
5357 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5358 {
5359  int i, plane, row, sprite;
5360  int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5361  uint8_t* src_h[2][2];
5362  int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5363  int ysub[2];
5364  MpegEncContext *s = &v->s;
5365 
5366  for (i = 0; i <= v->two_sprites; i++) {
5367  xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5368  xadv[i] = sd->coefs[i][0];
5369  if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5370  xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5371 
5372  yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5373  yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5374  }
5375  alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5376 
5377  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5378  int width = v->output_width>>!!plane;
5379 
5380  for (row = 0; row < v->output_height>>!!plane; row++) {
5381  uint8_t *dst = v->sprite_output_frame->data[plane] +
5382  v->sprite_output_frame->linesize[plane] * row;
5383 
5384  for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5385  uint8_t *iplane = s->current_picture.f.data[plane];
5386  int iline = s->current_picture.f.linesize[plane];
5387  int ycoord = yoff[sprite] + yadv[sprite] * row;
5388  int yline = ycoord >> 16;
5389  int next_line;
5390  ysub[sprite] = ycoord & 0xFFFF;
5391  if (sprite) {
5392  iplane = s->last_picture.f.data[plane];
5393  iline = s->last_picture.f.linesize[plane];
5394  }
5395  next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5396  if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5397  src_h[sprite][0] = iplane + (xoff[sprite] >> 16) + yline * iline;
5398  if (ysub[sprite])
5399  src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5400  } else {
5401  if (sr_cache[sprite][0] != yline) {
5402  if (sr_cache[sprite][1] == yline) {
5403  FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5404  FFSWAP(int, sr_cache[sprite][0], sr_cache[sprite][1]);
5405  } else {
5406  v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5407  sr_cache[sprite][0] = yline;
5408  }
5409  }
5410  if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5411  v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5412  iplane + next_line, xoff[sprite],
5413  xadv[sprite], width);
5414  sr_cache[sprite][1] = yline + 1;
5415  }
5416  src_h[sprite][0] = v->sr_rows[sprite][0];
5417  src_h[sprite][1] = v->sr_rows[sprite][1];
5418  }
5419  }
5420 
5421  if (!v->two_sprites) {
5422  if (ysub[0]) {
5423  v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5424  } else {
5425  memcpy(dst, src_h[0][0], width);
5426  }
5427  } else {
5428  if (ysub[0] && ysub[1]) {
5429  v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5430  src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5431  } else if (ysub[0]) {
5432  v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5433  src_h[1][0], alpha, width);
5434  } else if (ysub[1]) {
5435  v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5436  src_h[0][0], (1<<16)-1-alpha, width);
5437  } else {
5438  v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5439  }
5440  }
5441  }
5442 
5443  if (!plane) {
5444  for (i = 0; i <= v->two_sprites; i++) {
5445  xoff[i] >>= 1;
5446  yoff[i] >>= 1;
5447  }
5448  }
5449 
5450  }
5451 }
5452 
5453 
5454 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5455 {
5456  int ret;
5457  MpegEncContext *s = &v->s;
5458  AVCodecContext *avctx = s->avctx;
5459  SpriteData sd;
5460 
5461  memset(&sd, 0, sizeof(sd));
5462 
5463  ret = vc1_parse_sprites(v, gb, &sd);
5464  if (ret < 0)
5465  return ret;
5466 
5467  if (!s->current_picture.f.data[0]) {
5468  av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5469  return -1;
5470  }
5471 
5472  if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5473  av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5474  v->two_sprites = 0;
5475  }
5476 
5477  av_frame_unref(v->sprite_output_frame);
5478  if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
5479  return ret;
5480 
5481  vc1_draw_sprites(v, &sd);
5482 
5483  return 0;
5484 }
5485 
5486 static void vc1_sprite_flush(AVCodecContext *avctx)
5487 {
5488  VC1Context *v = avctx->priv_data;
5489  MpegEncContext *s = &v->s;
5490  AVFrame *f = &s->current_picture.f;
5491  int plane, i;
5492 
5493  /* Windows Media Image codecs have a convergence interval of two keyframes.
5494  Since we can't enforce it, clear to black the missing sprite. This is
5495  wrong but it looks better than doing nothing. */
5496 
5497  if (f->data[0])
5498  for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5499  for (i = 0; i < v->sprite_height>>!!plane; i++)
5500  memset(f->data[plane] + i * f->linesize[plane],
5501  plane ? 128 : 0, f->linesize[plane]);
5502 }
5503 
5504 #endif
5505 
5506 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5507 {
5508  MpegEncContext *s = &v->s;
5509  int i;
5510  int mb_height = FFALIGN(s->mb_height, 2);
5511 
5512  /* Allocate mb bitplanes */
5513  v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
5514  v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
5515  v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
5516  v->fieldtx_plane = av_mallocz(s->mb_stride * mb_height);
5517  v->acpred_plane = av_malloc (s->mb_stride * mb_height);
5518  v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
5519 
5520  v->n_allocated_blks = s->mb_width + 2;
5521  v->block = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5522  v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5523  v->cbp = v->cbp_base + s->mb_stride;
5524  v->ttblk_base = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5525  v->ttblk = v->ttblk_base + s->mb_stride;
5526  v->is_intra_base = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5527  v->is_intra = v->is_intra_base + s->mb_stride;
5528  v->luma_mv_base = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5529  v->luma_mv = v->luma_mv_base + s->mb_stride;
5530 
5531  /* allocate block type info in that way so it could be used with s->block_index[] */
5532  v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5533  v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
5534  v->mb_type[1] = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
5535  v->mb_type[2] = v->mb_type[1] + s->mb_stride * (mb_height + 1);
5536 
5537  /* allocate memory to store block level MV info */
5538  v->blk_mv_type_base = av_mallocz( s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5539  v->blk_mv_type = v->blk_mv_type_base + s->b8_stride + 1;
5540  v->mv_f_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5541  v->mv_f[0] = v->mv_f_base + s->b8_stride + 1;
5542  v->mv_f[1] = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5543  v->mv_f_next_base = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5544  v->mv_f_next[0] = v->mv_f_next_base + s->b8_stride + 1;
5545  v->mv_f_next[1] = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5546 
5547  /* Init coded blocks info */
5548  if (v->profile == PROFILE_ADVANCED) {
5549 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5550 // return -1;
5551 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5552 // return -1;
5553  }
5554 
5555  ff_intrax8_common_init(&v->x8,s);
5556 
5557  if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5558  for (i = 0; i < 4; i++)
5559  if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5560  return AVERROR(ENOMEM);
5561  }
5562 
5563  if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5564  !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5565  !v->mb_type_base) {
5566  av_freep(&v->mv_type_mb_plane);
5567  av_freep(&v->direct_mb_plane);
5568  av_freep(&v->acpred_plane);
5569  av_freep(&v->over_flags_plane);
5570  av_freep(&v->block);
5571  av_freep(&v->cbp_base);
5572  av_freep(&v->ttblk_base);
5573  av_freep(&v->is_intra_base);
5574  av_freep(&v->luma_mv_base);
5575  av_freep(&v->mb_type_base);
5576  return AVERROR(ENOMEM);
5577  }
5578 
5579  return 0;
5580 }
5581 
5582 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5583 {
5584  int i;
5585  for (i = 0; i < 64; i++) {
5586 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5587  v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5588  v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5589  v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5590  v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5591  v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5592  }
5593  v->left_blk_sh = 0;
5594  v->top_blk_sh = 3;
5595 }
5596 
5597 /** Initialize a VC1/WMV3 decoder
5598  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5599  * @todo TODO: Decypher remaining bits in extra_data
5600  */
5601 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5602 {
5603  VC1Context *v = avctx->priv_data;
5604  MpegEncContext *s = &v->s;
5605  GetBitContext gb;
5606  int ret;
5607 
5608  /* save the container output size for WMImage */
5609  v->output_width = avctx->width;
5610  v->output_height = avctx->height;
5611 
5612  if (!avctx->extradata_size || !avctx->extradata)
5613  return -1;
5614  if (!(avctx->flags & CODEC_FLAG_GRAY))
5615  avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5616  else
5617  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5618  avctx->hwaccel = ff_find_hwaccel(avctx);
5619  v->s.avctx = avctx;
5620 
5621  if ((ret = ff_vc1_init_common(v)) < 0)
5622  return ret;
5623  // ensure static VLC tables are initialized
5624  if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5625  return ret;
5626  if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5627  return ret;
5628  // Hack to ensure the above functions will be called
5629  // again once we know all necessary settings.
5630  // That this is necessary might indicate a bug.
5631  ff_vc1_decode_end(avctx);
5632 
5633  ff_h264chroma_init(&v->h264chroma, 8);
5634  ff_vc1dsp_init(&v->vc1dsp);
5635 
5636  if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5637  int count = 0;
5638 
5639  // looks like WMV3 has a sequence header stored in the extradata
5640  // advanced sequence header may be before the first frame
5641  // the last byte of the extradata is a version number, 1 for the
5642  // samples we can decode
5643 
5644  init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5645 
5646  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5647  return ret;
5648 
5649  count = avctx->extradata_size*8 - get_bits_count(&gb);
5650  if (count > 0) {
5651  av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5652  count, get_bits(&gb, count));
5653  } else if (count < 0) {
5654  av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5655  }
5656  } else { // VC1/WVC1/WVP2
5657  const uint8_t *start = avctx->extradata;
5658  uint8_t *end = avctx->extradata + avctx->extradata_size;
5659  const uint8_t *next;
5660  int size, buf2_size;
5661  uint8_t *buf2 = NULL;
5662  int seq_initialized = 0, ep_initialized = 0;
5663 
5664  if (avctx->extradata_size < 16) {
5665  av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5666  return -1;
5667  }
5668 
5669  buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5670  start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5671  next = start;
5672  for (; next < end; start = next) {
5673  next = find_next_marker(start + 4, end);
5674  size = next - start - 4;
5675  if (size <= 0)
5676  continue;
5677  buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5678  init_get_bits(&gb, buf2, buf2_size * 8);
5679  switch (AV_RB32(start)) {
5680  case VC1_CODE_SEQHDR:
5681  if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5682  av_free(buf2);
5683  return ret;
5684  }
5685  seq_initialized = 1;
5686  break;
5687  case VC1_CODE_ENTRYPOINT:
5688  if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5689  av_free(buf2);
5690  return ret;
5691  }
5692  ep_initialized = 1;
5693  break;
5694  }
5695  }
5696  av_free(buf2);
5697  if (!seq_initialized || !ep_initialized) {
5698  av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5699  return -1;
5700  }
5701  v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5702  }
5703 
5704  v->sprite_output_frame = av_frame_alloc();
5705  if (!v->sprite_output_frame)
5706  return AVERROR(ENOMEM);
5707 
5708  avctx->profile = v->profile;
5709  if (v->profile == PROFILE_ADVANCED)
5710  avctx->level = v->level;
5711 
5712  avctx->has_b_frames = !!avctx->max_b_frames;
5713 
5714  s->mb_width = (avctx->coded_width + 15) >> 4;
5715  s->mb_height = (avctx->coded_height + 15) >> 4;
5716 
5717  if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5718  ff_vc1_init_transposed_scantables(v);
5719  } else {
5720  memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5721  v->left_blk_sh = 3;
5722  v->top_blk_sh = 0;
5723  }
5724 
5725  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5726  v->sprite_width = avctx->coded_width;
5727  v->sprite_height = avctx->coded_height;
5728 
5729  avctx->coded_width = avctx->width = v->output_width;
5730  avctx->coded_height = avctx->height = v->output_height;
5731 
5732  // prevent 16.16 overflows
5733  if (v->sprite_width > 1 << 14 ||
5734  v->sprite_height > 1 << 14 ||
5735  v->output_width > 1 << 14 ||
5736  v->output_height > 1 << 14) return -1;
5737 
5738  if ((v->sprite_width&1) || (v->sprite_height&1)) {
5739  avpriv_request_sample(avctx, "odd sprites support");
5740  return AVERROR_PATCHWELCOME;
5741  }
5742  }
5743  return 0;
5744 }
5745 
5746 /** Close a VC1/WMV3 decoder
5747  * @warning Initial try at using MpegEncContext stuff
5748  */
5749 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5750 {
5751  VC1Context *v = avctx->priv_data;
5752  int i;
5753 
5754  av_frame_free(&v->sprite_output_frame);
5755 
5756  for (i = 0; i < 4; i++)
5757  av_freep(&v->sr_rows[i >> 1][i & 1]);
5758  av_freep(&v->hrd_rate);
5759  av_freep(&v->hrd_buffer);
5760  ff_MPV_common_end(&v->s);
5761  av_freep(&v->mv_type_mb_plane);
5762  av_freep(&v->direct_mb_plane);
5763  av_freep(&v->forward_mb_plane);
5764  av_freep(&v->fieldtx_plane);
5765  av_freep(&v->acpred_plane);
5766  av_freep(&v->over_flags_plane);
5767  av_freep(&v->mb_type_base);
5768  av_freep(&v->blk_mv_type_base);
5769  av_freep(&v->mv_f_base);
5770  av_freep(&v->mv_f_next_base);
5771  av_freep(&v->block);
5772  av_freep(&v->cbp_base);
5773  av_freep(&v->ttblk_base);
5774  av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5775  av_freep(&v->luma_mv_base);
5776  ff_intrax8_common_end(&v->x8);
5777  return 0;
5778 }
5779 
5780 
5781 /** Decode a VC1/WMV3 frame
5782  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5783  */
5784 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5785  int *got_frame, AVPacket *avpkt)
5786 {
5787  const uint8_t *buf = avpkt->data;
5788  int buf_size = avpkt->size, n_slices = 0, i, ret;
5789  VC1Context *v = avctx->priv_data;
5790  MpegEncContext *s = &v->s;
5791  AVFrame *pict = data;
5792  uint8_t *buf2 = NULL;
5793  const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5794  int mb_height, n_slices1=-1;
5795  struct {
5796  uint8_t *buf;
5797  GetBitContext gb;
5798  int mby_start;
5799  } *slices = NULL, *tmp;
5800 
5801  v->second_field = 0;
5802 
5803  if(s->flags & CODEC_FLAG_LOW_DELAY)
5804  s->low_delay = 1;
5805 
5806  /* no supplementary picture */
5807  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5808  /* special case for last picture */
5809  if (s->low_delay == 0 && s->next_picture_ptr) {
5810  if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5811  return ret;
5812  s->next_picture_ptr = NULL;
5813 
5814  *got_frame = 1;
5815  }
5816 
5817  return buf_size;
5818  }
5819 
5820  if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5821  if (v->profile < PROFILE_ADVANCED)
5822  avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5823  else
5824  avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5825  }
5826 
5827  //for advanced profile we may need to parse and unescape data
5828  if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5829  int buf_size2 = 0;
5830  buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5831  if (!buf2)
5832  return AVERROR(ENOMEM);
5833 
5834  if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5835  const uint8_t *start, *end, *next;
5836  int size;
5837 
5838  next = buf;
5839  for (start = buf, end = buf + buf_size; next < end; start = next) {
5840  next = find_next_marker(start + 4, end);
5841  size = next - start - 4;
5842  if (size <= 0) continue;
5843  switch (AV_RB32(start)) {
5844  case VC1_CODE_FRAME:
5845  if (avctx->hwaccel ||
5846  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5847  buf_start = start;
5848  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5849  break;
5850  case VC1_CODE_FIELD: {
5851  int buf_size3;
5852  if (avctx->hwaccel ||
5853  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5854  buf_start_second_field = start;
5855  tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5856  if (!tmp)
5857  goto err;
5858  slices = tmp;
5859  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5860  if (!slices[n_slices].buf)
5861  goto err;
5862  buf_size3 = vc1_unescape_buffer(start + 4, size,
5863  slices[n_slices].buf);
5864  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5865  buf_size3 << 3);
5866  /* assuming that the field marker is at the exact middle,
5867  hope it's correct */
5868  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5869  n_slices1 = n_slices - 1; // index of the last slice of the first field
5870  n_slices++;
5871  break;
5872  }
5873  case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5874  buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5875  init_get_bits(&s->gb, buf2, buf_size2 * 8);
5876  ff_vc1_decode_entry_point(avctx, v, &s->gb);
5877  break;
5878  case VC1_CODE_SLICE: {
5879  int buf_size3;
5880  tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5881  if (!tmp)
5882  goto err;
5883  slices = tmp;
5884  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5885  if (!slices[n_slices].buf)
5886  goto err;
5887  buf_size3 = vc1_unescape_buffer(start + 4, size,
5888  slices[n_slices].buf);
5889  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5890  buf_size3 << 3);
5891  slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5892  n_slices++;
5893  break;
5894  }
5895  }
5896  }
5897  } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5898  const uint8_t *divider;
5899  int buf_size3;
5900 
5901  divider = find_next_marker(buf, buf + buf_size);
5902  if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5903  av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5904  goto err;
5905  } else { // found field marker, unescape second field
5906  if (avctx->hwaccel ||
5907  s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5908  buf_start_second_field = divider;
5909  tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5910  if (!tmp)
5911  goto err;
5912  slices = tmp;
5913  slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5914  if (!slices[n_slices].buf)
5915  goto err;
5916  buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5917  init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5918  buf_size3 << 3);
5919  slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5920  n_slices1 = n_slices - 1;
5921  n_slices++;
5922  }
5923  buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5924  } else {
5925  buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5926  }
5927  init_get_bits(&s->gb, buf2, buf_size2*8);
5928  } else
5929  init_get_bits(&s->gb, buf, buf_size*8);
5930 
5931  if (v->res_sprite) {
5932  v->new_sprite = !get_bits1(&s->gb);
5933  v->two_sprites = get_bits1(&s->gb);
5934  /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5935  we're using the sprite compositor. These are intentionally kept separate
5936  so you can get the raw sprites by using the wmv3 decoder for WMVP or
5937  the vc1 one for WVP2 */
5938  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5939  if (v->new_sprite) {
5940  // switch AVCodecContext parameters to those of the sprites
5941  avctx->width = avctx->coded_width = v->sprite_width;
5942  avctx->height = avctx->coded_height = v->sprite_height;
5943  } else {
5944  goto image;
5945  }
5946  }
5947  }
5948 
5949  if (s->context_initialized &&
5950  (s->width != avctx->coded_width ||
5951  s->height != avctx->coded_height)) {
5952  ff_vc1_decode_end(avctx);
5953  }
5954 
5955  if (!s->context_initialized) {
5956  if (ff_msmpeg4_decode_init(avctx) < 0)
5957  goto err;
5958  if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5959  ff_MPV_common_end(s);
5960  goto err;
5961  }
5962 
5963  s->low_delay = !avctx->has_b_frames || v->res_sprite;
5964 
5965  if (v->profile == PROFILE_ADVANCED) {
5966  if(avctx->coded_width<=1 || avctx->coded_height<=1)
5967  goto err;
5968  s->h_edge_pos = avctx->coded_width;
5969  s->v_edge_pos = avctx->coded_height;
5970  }
5971  }
5972 
5973  // do parse frame header
5974  v->pic_header_flag = 0;
5975  v->first_pic_header_flag = 1;
5976  if (v->profile < PROFILE_ADVANCED) {
5977  if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5978  goto err;
5979  }
5980  } else {
5981  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5982  goto err;
5983  }
5984  }
5985  v->first_pic_header_flag = 0;
5986 
5987  if (avctx->debug & FF_DEBUG_PICT_INFO)
5988  av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5989 
5990  if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5991  && s->pict_type != AV_PICTURE_TYPE_I) {
5992  av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5993  goto err;
5994  }
5995 
5996  if ((s->mb_height >> v->field_mode) == 0) {
5997  av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5998  goto err;
5999  }
6000 
6001  // for skipping the frame
6002  s->current_picture.f.pict_type = s->pict_type;
6003  s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
6004 
6005  /* skip B-frames if we don't have reference frames */
6006  if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6007  goto err;
6008  }
6009  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6010  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6011  avctx->skip_frame >= AVDISCARD_ALL) {
6012  goto end;
6013  }
6014 
6015  if (s->next_p_frame_damaged) {
6016  if (s->pict_type == AV_PICTURE_TYPE_B)
6017  goto end;
6018  else
6019  s->next_p_frame_damaged = 0;
6020  }
6021 
6022  if (ff_MPV_frame_start(s, avctx) < 0) {
6023  goto err;
6024  }
6025 
6026  v->s.current_picture_ptr->field_picture = v->field_mode;
6027  v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6028  v->s.current_picture_ptr->f.top_field_first = v->tff;
6029 
6030  // process pulldown flags
6031  s->current_picture_ptr->f.repeat_pict = 0;
6032  // Pulldown flags are only valid when 'broadcast' has been set.
6033  // So ticks_per_frame will be 2
6034  if (v->rff) {
6035  // repeat field
6036  s->current_picture_ptr->f.repeat_pict = 1;
6037  } else if (v->rptfrm) {
6038  // repeat frames
6039  s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
6040  }
6041 
6042  s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6043  s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6044 
6045  if ((CONFIG_VC1_VDPAU_DECODER)
6046  &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6047  if (v->field_mode && buf_start_second_field) {
6048  ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6049  ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6050  } else {
6051  ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6052  }
6053  } else if (avctx->hwaccel) {
6054  if (v->field_mode && buf_start_second_field) {
6055  // decode first field
6056  s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6057  if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6058  goto err;
6059  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6060  goto err;
6061  if (avctx->hwaccel->end_frame(avctx) < 0)
6062  goto err;
6063 
6064  // decode second field
6065  s->gb = slices[n_slices1 + 1].gb;
6066  s->picture_structure = PICT_TOP_FIELD + v->tff;
6067  v->second_field = 1;
6068  v->pic_header_flag = 0;
6069  if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6070  av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6071  goto err;
6072  }
6073  v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6074 
6075  if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6076  goto err;
6077  if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6078  goto err;
6079  if (avctx->hwaccel->end_frame(avctx) < 0)
6080  goto err;
6081  } else {
6082  s->picture_structure = PICT_FRAME;
6083  if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6084  goto err;
6085  if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6086  goto err;
6087  if (avctx->hwaccel->end_frame(avctx) < 0)
6088  goto err;
6089  }
6090  } else {
6091  int header_ret = 0;
6092 
6093  ff_mpeg_er_frame_start(s);
6094 
6095  v->bits = buf_size * 8;
6096  v->end_mb_x = s->mb_width;
6097  if (v->field_mode) {
6098  s->current_picture.f.linesize[0] <<= 1;
6099  s->current_picture.f.linesize[1] <<= 1;
6100  s->current_picture.f.linesize[2] <<= 1;
6101  s->linesize <<= 1;
6102  s->uvlinesize <<= 1;
6103  }
6104  mb_height = s->mb_height >> v->field_mode;
6105 
6106  av_assert0 (mb_height > 0);
6107 
6108  for (i = 0; i <= n_slices; i++) {
6109  if (i > 0 && slices[i - 1].mby_start >= mb_height) {
6110  if (v->field_mode <= 0) {
6111  av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6112  "picture boundary (%d >= %d)\n", i,
6113  slices[i - 1].mby_start, mb_height);
6114  continue;
6115  }
6116  v->second_field = 1;
6117  av_assert0((s->mb_height & 1) == 0);
6118  v->blocks_off = s->b8_stride * (s->mb_height&~1);
6119  v->mb_off = s->mb_stride * s->mb_height >> 1;
6120  } else {
6121  v->second_field = 0;
6122  v->blocks_off = 0;
6123  v->mb_off = 0;
6124  }
6125  if (i) {
6126  v->pic_header_flag = 0;
6127  if (v->field_mode && i == n_slices1 + 2) {
6128  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6129  av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6130  if (avctx->err_recognition & AV_EF_EXPLODE)
6131  goto err;
6132  continue;
6133  }
6134  } else if (get_bits1(&s->gb)) {
6135  v->pic_header_flag = 1;
6136  if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6137  av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6138  if (avctx->err_recognition & AV_EF_EXPLODE)
6139  goto err;
6140  continue;
6141  }
6142  }
6143  }
6144  if (header_ret < 0)
6145  continue;
6146  s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6147  if (!v->field_mode || v->second_field)
6148  s->end_mb_y = (i == n_slices ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6149  else {
6150  if (i >= n_slices) {
6151  av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6152  continue;
6153  }
6154  s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6155  }
6156  if (s->end_mb_y <= s->start_mb_y) {
6157  av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6158  continue;
6159  }
6160  if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6161  av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6162  continue;
6163  }
6164  ff_vc1_decode_blocks(v);
6165  if (i != n_slices)
6166  s->gb = slices[i].gb;
6167  }
6168  if (v->field_mode) {
6169  v->second_field = 0;
6170  s->current_picture.f.linesize[0] >>= 1;
6171  s->current_picture.f.linesize[1] >>= 1;
6172  s->current_picture.f.linesize[2] >>= 1;
6173  s->linesize >>= 1;
6174  s->uvlinesize >>= 1;
6175  if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6176  FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6177  FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6178  }
6179  }
6180  av_dlog(s->avctx, "Consumed %i/%i bits\n",
6181  get_bits_count(&s->gb), s->gb.size_in_bits);
6182 // if (get_bits_count(&s->gb) > buf_size * 8)
6183 // return -1;
6184  if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6185  goto err;
6186  if (!v->field_mode)
6187  ff_er_frame_end(&s->er);
6188  }
6189 
6190  ff_MPV_frame_end(s);
6191 
6192  if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6193 image:
6194  avctx->width = avctx->coded_width = v->output_width;
6195  avctx->height = avctx->coded_height = v->output_height;
6196  if (avctx->skip_frame >= AVDISCARD_NONREF)
6197  goto end;
6198 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6199  if (vc1_decode_sprites(v, &s->gb))
6200  goto err;
6201 #endif
6202  if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
6203  goto err;
6204  *got_frame = 1;
6205  } else {
6206  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6207  if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6208  goto err;
6209  ff_print_debug_info(s, s->current_picture_ptr, pict);
6210  *got_frame = 1;
6211  } else if (s->last_picture_ptr != NULL) {
6212  if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6213  goto err;
6214  ff_print_debug_info(s, s->last_picture_ptr, pict);
6215  *got_frame = 1;
6216  }
6217  }
6218 
6219 end:
6220  av_free(buf2);
6221  for (i = 0; i < n_slices; i++)
6222  av_free(slices[i].buf);
6223  av_free(slices);
6224  return buf_size;
6225 
6226 err:
6227  av_free(buf2);
6228  for (i = 0; i < n_slices; i++)
6229  av_free(slices[i].buf);
6230  av_free(slices);
6231  return -1;
6232 }
6233 
6234 
6235 static const AVProfile profiles[] = {
6236  { FF_PROFILE_VC1_SIMPLE, "Simple" },
6237  { FF_PROFILE_VC1_MAIN, "Main" },
6238  { FF_PROFILE_VC1_COMPLEX, "Complex" },
6239  { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6240  { FF_PROFILE_UNKNOWN },
6241 };
6242 
6243 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6244 #if CONFIG_DXVA2
6245  AV_PIX_FMT_DXVA2_VLD,
6246 #endif
6247 #if CONFIG_VAAPI
6248  AV_PIX_FMT_VAAPI_VLD,
6249 #endif
6250 #if CONFIG_VDPAU
6251  AV_PIX_FMT_VDPAU,
6252 #endif
6253  AV_PIX_FMT_YUV420P,
6254  AV_PIX_FMT_NONE
6255 };
6256 
6257 AVCodec ff_vc1_decoder = {
6258  .name = "vc1",
6259  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6260  .type = AVMEDIA_TYPE_VIDEO,
6261  .id = AV_CODEC_ID_VC1,
6262  .priv_data_size = sizeof(VC1Context),
6263  .init = vc1_decode_init,
6264  .close = ff_vc1_decode_end,
6265  .decode = vc1_decode_frame,
6266  .flush = ff_mpeg_flush,
6267  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6268  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6269  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6270 };
6271 
6272 #if CONFIG_WMV3_DECODER
6273 AVCodec ff_wmv3_decoder = {
6274  .name = "wmv3",
6275  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6276  .type = AVMEDIA_TYPE_VIDEO,
6277  .id = AV_CODEC_ID_WMV3,
6278  .priv_data_size = sizeof(VC1Context),
6279  .init = vc1_decode_init,
6280  .close = ff_vc1_decode_end,
6281  .decode = vc1_decode_frame,
6282  .flush = ff_mpeg_flush,
6283  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6284  .pix_fmts = vc1_hwaccel_pixfmt_list_420,
6285  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6286 };
6287 #endif
6288 
6289 #if CONFIG_WMV3_VDPAU_DECODER
6290 AVCodec ff_wmv3_vdpau_decoder = {
6291  .name = "wmv3_vdpau",
6292  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6293  .type = AVMEDIA_TYPE_VIDEO,
6294  .id = AV_CODEC_ID_WMV3,
6295  .priv_data_size = sizeof(VC1Context),
6296  .init = vc1_decode_init,
6297  .close = ff_vc1_decode_end,
6298  .decode = vc1_decode_frame,
6299  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6300  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6301  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6302 };
6303 #endif
6304 
6305 #if CONFIG_VC1_VDPAU_DECODER
6306 AVCodec ff_vc1_vdpau_decoder = {
6307  .name = "vc1_vdpau",
6308  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6309  .type = AVMEDIA_TYPE_VIDEO,
6310  .id = AV_CODEC_ID_VC1,
6311  .priv_data_size = sizeof(VC1Context),
6312  .init = vc1_decode_init,
6313  .close = ff_vc1_decode_end,
6314  .decode = vc1_decode_frame,
6315  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6316  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6317  .profiles = NULL_IF_CONFIG_SMALL(profiles)
6318 };
6319 #endif
6320 
6321 #if CONFIG_WMV3IMAGE_DECODER
6322 AVCodec ff_wmv3image_decoder = {
6323  .name = "wmv3image",
6324  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6325  .type = AVMEDIA_TYPE_VIDEO,
6326  .id = AV_CODEC_ID_WMV3IMAGE,
6327  .priv_data_size = sizeof(VC1Context),
6328  .init = vc1_decode_init,
6329  .close = ff_vc1_decode_end,
6330  .decode = vc1_decode_frame,
6331  .capabilities = CODEC_CAP_DR1,
6332  .flush = vc1_sprite_flush,
6333  .pix_fmts = ff_pixfmt_list_420
6334 };
6335 #endif
6336 
6337 #if CONFIG_VC1IMAGE_DECODER
6338 AVCodec ff_vc1image_decoder = {
6339  .name = "vc1image",
6340  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6341  .type = AVMEDIA_TYPE_VIDEO,
6342  .id = AV_CODEC_ID_VC1IMAGE,
6343  .priv_data_size = sizeof(VC1Context),
6344  .init = vc1_decode_init,
6345  .close = ff_vc1_decode_end,
6346  .decode = vc1_decode_frame,
6347  .capabilities = CODEC_CAP_DR1,
6348  .flush = vc1_sprite_flush,
6349  .pix_fmts = ff_pixfmt_list_420
6350 };
6351 #endif
Generated on Sun Mar 23 2014 23:50:04 for FFmpeg by   doxygen 1.8.2