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