FFmpeg
vc1_block.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 block decoding routines
27  */
28 
29 #include "avcodec.h"
30 #include "mpegutils.h"
31 #include "mpegvideo.h"
32 #include "mpegvideodec.h"
33 #include "msmpeg4_vc1_data.h"
34 #include "unary.h"
35 #include "vc1.h"
36 #include "vc1_pred.h"
37 #include "vc1acdata.h"
38 #include "vc1data.h"
39 
40 // offset tables for interlaced picture MVDATA decoding
41 static const uint8_t offset_table[2][9] = {
42  { 0, 1, 2, 4, 8, 16, 32, 64, 128 },
43  { 0, 1, 3, 7, 15, 31, 63, 127, 255 },
44 };
45 
46 // mapping table for internal block representation
47 static const int block_map[6] = {0, 2, 1, 3, 4, 5};
48 
49 /***********************************************************************/
50 /**
51  * @name VC-1 Bitplane decoding
52  * @see 8.7, p56
53  * @{
54  */
55 
56 
57 static inline void init_block_index(VC1Context *v)
58 {
59  MpegEncContext *s = &v->s;
61  if (v->field_mode && !(v->second_field ^ v->tff)) {
62  s->dest[0] += s->current_picture_ptr->f->linesize[0];
63  s->dest[1] += s->current_picture_ptr->f->linesize[1];
64  s->dest[2] += s->current_picture_ptr->f->linesize[2];
65  }
66 }
67 
68 static inline void update_block_index(MpegEncContext *s)
69 {
70  /* VC1 is always 420 except when using AV_CODEC_FLAG_GRAY
71  * (or a HWAccel). Shall we inline this value? */
72  ff_update_block_index(s, 8, 0, s->chroma_x_shift);
73 }
74 
75 /** @} */ //Bitplane group
76 
77 static void vc1_put_blocks_clamped(VC1Context *v, int put_signed)
78 {
79  MpegEncContext *s = &v->s;
80  uint8_t *dest;
81  int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
82  int fieldtx = 0;
83  int i;
84 
85  /* The put pixels loop is one MB row and one MB column behind the decoding
86  * loop because we can only put pixels when overlap filtering is done. For
87  * interlaced frame pictures, however, the put pixels loop is only one
88  * column behind the decoding loop as interlaced frame pictures only need
89  * horizontal overlap filtering. */
90  if (!s->first_slice_line && v->fcm != ILACE_FRAME) {
91  if (s->mb_x) {
92  for (i = 0; i < block_count; i++) {
93  if (i > 3 ? v->mb_type[0][s->block_index[i] - s->block_wrap[i] - 1] :
94  v->mb_type[0][s->block_index[i] - 2 * s->block_wrap[i] - 2]) {
95  dest = s->dest[0] + ((i & 2) - 4) * 4 * s->linesize + ((i & 1) - 2) * 8;
96  if (put_signed)
97  s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][block_map[i]],
98  i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
99  i > 3 ? s->uvlinesize : s->linesize);
100  else
101  s->idsp.put_pixels_clamped(v->block[v->topleft_blk_idx][block_map[i]],
102  i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
103  i > 3 ? s->uvlinesize : s->linesize);
104  }
105  }
106  }
107  if (s->mb_x == v->end_mb_x - 1) {
108  for (i = 0; i < block_count; i++) {
109  if (i > 3 ? v->mb_type[0][s->block_index[i] - s->block_wrap[i]] :
110  v->mb_type[0][s->block_index[i] - 2 * s->block_wrap[i]]) {
111  dest = s->dest[0] + ((i & 2) - 4) * 4 * s->linesize + (i & 1) * 8;
112  if (put_signed)
113  s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][block_map[i]],
114  i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
115  i > 3 ? s->uvlinesize : s->linesize);
116  else
117  s->idsp.put_pixels_clamped(v->block[v->top_blk_idx][block_map[i]],
118  i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
119  i > 3 ? s->uvlinesize : s->linesize);
120  }
121  }
122  }
123  }
124  if (s->mb_y == s->end_mb_y - 1 || v->fcm == ILACE_FRAME) {
125  if (s->mb_x) {
126  if (v->fcm == ILACE_FRAME)
127  fieldtx = v->fieldtx_plane[s->mb_y * s->mb_stride + s->mb_x - 1];
128  for (i = 0; i < block_count; i++) {
129  if (i > 3 ? v->mb_type[0][s->block_index[i] - 1] :
130  v->mb_type[0][s->block_index[i] - 2]) {
131  if (fieldtx)
132  dest = s->dest[0] + ((i & 2) >> 1) * s->linesize + ((i & 1) - 2) * 8;
133  else
134  dest = s->dest[0] + (i & 2) * 4 * s->linesize + ((i & 1) - 2) * 8;
135  if (put_signed)
136  s->idsp.put_signed_pixels_clamped(v->block[v->left_blk_idx][block_map[i]],
137  i > 3 ? s->dest[i - 3] - 8 : dest,
138  i > 3 ? s->uvlinesize : s->linesize << fieldtx);
139  else
140  s->idsp.put_pixels_clamped(v->block[v->left_blk_idx][block_map[i]],
141  i > 3 ? s->dest[i - 3] - 8 : dest,
142  i > 3 ? s->uvlinesize : s->linesize << fieldtx);
143  }
144  }
145  }
146  if (s->mb_x == v->end_mb_x - 1) {
147  if (v->fcm == ILACE_FRAME)
148  fieldtx = v->fieldtx_plane[s->mb_y * s->mb_stride + s->mb_x];
149  for (i = 0; i < block_count; i++) {
150  if (v->mb_type[0][s->block_index[i]]) {
151  if (fieldtx)
152  dest = s->dest[0] + ((i & 2) >> 1) * s->linesize + (i & 1) * 8;
153  else
154  dest = s->dest[0] + (i & 2) * 4 * s->linesize + (i & 1) * 8;
155  if (put_signed)
156  s->idsp.put_signed_pixels_clamped(v->block[v->cur_blk_idx][block_map[i]],
157  i > 3 ? s->dest[i - 3] : dest,
158  i > 3 ? s->uvlinesize : s->linesize << fieldtx);
159  else
160  s->idsp.put_pixels_clamped(v->block[v->cur_blk_idx][block_map[i]],
161  i > 3 ? s->dest[i - 3] : dest,
162  i > 3 ? s->uvlinesize : s->linesize << fieldtx);
163  }
164  }
165  }
166  }
167 }
168 
169 #define inc_blk_idx(idx) do { \
170  idx++; \
171  if (idx >= v->n_allocated_blks) \
172  idx = 0; \
173  } while (0)
174 
175 /***********************************************************************/
176 /**
177  * @name VC-1 Block-level functions
178  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
179  * @{
180  */
181 
182 /**
183  * @def GET_MQUANT
184  * @brief Get macroblock-level quantizer scale
185  */
186 #define GET_MQUANT() \
187  if (v->dquantfrm) { \
188  int edges = 0; \
189  if (v->dqprofile == DQPROFILE_ALL_MBS) { \
190  if (v->dqbilevel) { \
191  mquant = (get_bits1(gb)) ? -v->altpq : v->pq; \
192  } else { \
193  mqdiff = get_bits(gb, 3); \
194  if (mqdiff != 7) \
195  mquant = -v->pq - mqdiff; \
196  else \
197  mquant = -get_bits(gb, 5); \
198  } \
199  } \
200  if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \
201  edges = 1 << v->dqsbedge; \
202  else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
203  edges = (3 << v->dqsbedge) % 15; \
204  else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \
205  edges = 15; \
206  if ((edges&1) && !s->mb_x) \
207  mquant = -v->altpq; \
208  if ((edges&2) && !s->mb_y) \
209  mquant = -v->altpq; \
210  if ((edges&4) && s->mb_x == (s->mb_width - 1)) \
211  mquant = -v->altpq; \
212  if ((edges&8) && \
213  s->mb_y == ((s->mb_height >> v->field_mode) - 1)) \
214  mquant = -v->altpq; \
215  if (!mquant || mquant > 31 || mquant < -31) { \
216  av_log(v->s.avctx, AV_LOG_ERROR, \
217  "Overriding invalid mquant %d\n", mquant); \
218  mquant = 1; \
219  } \
220  }
221 
222 /**
223  * @def GET_MVDATA(_dmv_x, _dmv_y)
224  * @brief Get MV differentials
225  * @see MVDATA decoding from 8.3.5.2, p(1)20
226  * @param _dmv_x Horizontal differential for decoded MV
227  * @param _dmv_y Vertical differential for decoded MV
228  */
229 #define GET_MVDATA(_dmv_x, _dmv_y) \
230  index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index], \
231  VC1_MV_DIFF_VLC_BITS, 2); \
232  if (index > 36) { \
233  mb_has_coeffs = 1; \
234  index -= 37; \
235  } else \
236  mb_has_coeffs = 0; \
237  s->mb_intra = 0; \
238  if (!index) { \
239  _dmv_x = _dmv_y = 0; \
240  } else if (index == 35) { \
241  _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
242  _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
243  } else if (index == 36) { \
244  _dmv_x = 0; \
245  _dmv_y = 0; \
246  s->mb_intra = 1; \
247  } else { \
248  index1 = index % 6; \
249  _dmv_x = offset_table[1][index1]; \
250  val = size_table[index1] - (!s->quarter_sample && index1 == 5); \
251  if (val > 0) { \
252  val = get_bits(gb, val); \
253  sign = 0 - (val & 1); \
254  _dmv_x = (sign ^ ((val >> 1) + _dmv_x)) - sign; \
255  } \
256  \
257  index1 = index / 6; \
258  _dmv_y = offset_table[1][index1]; \
259  val = size_table[index1] - (!s->quarter_sample && index1 == 5); \
260  if (val > 0) { \
261  val = get_bits(gb, val); \
262  sign = 0 - (val & 1); \
263  _dmv_y = (sign ^ ((val >> 1) + _dmv_y)) - sign; \
264  } \
265  }
266 
268  int *dmv_y, int *pred_flag)
269 {
270  int index, index1;
271  int extend_x, extend_y;
272  GetBitContext *gb = &v->s.gb;
273  int bits, esc;
274  int val, sign;
275 
276  if (v->numref) {
278  esc = 125;
279  } else {
281  esc = 71;
282  }
283  extend_x = v->dmvrange & 1;
284  extend_y = (v->dmvrange >> 1) & 1;
285  index = get_vlc2(gb, v->imv_vlc, bits, 3);
286  if (index == esc) {
287  *dmv_x = get_bits(gb, v->k_x);
288  *dmv_y = get_bits(gb, v->k_y);
289  if (v->numref) {
290  if (pred_flag)
291  *pred_flag = *dmv_y & 1;
292  *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1;
293  }
294  }
295  else {
296  av_assert0(index < esc);
297  index1 = (index + 1) % 9;
298  if (index1 != 0) {
299  val = get_bits(gb, index1 + extend_x);
300  sign = 0 - (val & 1);
301  *dmv_x = (sign ^ ((val >> 1) + offset_table[extend_x][index1])) - sign;
302  } else
303  *dmv_x = 0;
304  index1 = (index + 1) / 9;
305  if (index1 > v->numref) {
306  val = get_bits(gb, (index1 >> v->numref) + extend_y);
307  sign = 0 - (val & 1);
308  *dmv_y = (sign ^ ((val >> 1) + offset_table[extend_y][index1 >> v->numref])) - sign;
309  } else
310  *dmv_y = 0;
311  if (v->numref && pred_flag)
312  *pred_flag = index1 & 1;
313  }
314 }
315 
316 /** Reconstruct motion vector for B-frame and do motion compensation
317  */
318 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
319  int direct, int mode)
320 {
321  if (direct) {
322  ff_vc1_mc_1mv(v, 0);
323  ff_vc1_interp_mc(v);
324  return;
325  }
326  if (mode == BMV_TYPE_INTERPOLATED) {
327  ff_vc1_mc_1mv(v, 0);
328  ff_vc1_interp_mc(v);
329  return;
330  }
331 
333 }
334 
335 /** Get predicted DC value for I-frames only
336  * prediction dir: left=0, top=1
337  * @param s MpegEncContext
338  * @param overlap flag indicating that overlap filtering is used
339  * @param pq integer part of picture quantizer
340  * @param[in] n block index in the current MB
341  * @param dc_val_ptr Pointer to DC predictor
342  * @param dir_ptr Prediction direction for use in AC prediction
343  */
344 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
345  int16_t **dc_val_ptr, int *dir_ptr)
346 {
347  int a, b, c, wrap, pred, scale;
348  int16_t *dc_val;
349  static const uint16_t dcpred[32] = {
350  -1, 1024, 512, 341, 256, 205, 171, 146, 128,
351  114, 102, 93, 85, 79, 73, 68, 64,
352  60, 57, 54, 51, 49, 47, 45, 43,
353  41, 39, 38, 37, 35, 34, 33
354  };
355 
356  /* find prediction - wmv3_dc_scale always used here in fact */
357  if (n < 4) scale = s->y_dc_scale;
358  else scale = s->c_dc_scale;
359 
360  wrap = s->block_wrap[n];
361  dc_val = s->dc_val[0] + s->block_index[n];
362 
363  /* B A
364  * C X
365  */
366  c = dc_val[ - 1];
367  b = dc_val[ - 1 - wrap];
368  a = dc_val[ - wrap];
369 
370  if (pq < 9 || !overlap) {
371  /* Set outer values */
372  if (s->first_slice_line && (n != 2 && n != 3))
373  b = a = dcpred[scale];
374  if (s->mb_x == 0 && (n != 1 && n != 3))
375  b = c = dcpred[scale];
376  } else {
377  /* Set outer values */
378  if (s->first_slice_line && (n != 2 && n != 3))
379  b = a = 0;
380  if (s->mb_x == 0 && (n != 1 && n != 3))
381  b = c = 0;
382  }
383 
384  if (abs(a - b) <= abs(b - c)) {
385  pred = c;
386  *dir_ptr = 1; // left
387  } else {
388  pred = a;
389  *dir_ptr = 0; // top
390  }
391 
392  /* update predictor */
393  *dc_val_ptr = &dc_val[0];
394  return pred;
395 }
396 
397 
398 /** Get predicted DC value
399  * prediction dir: left=0, top=1
400  * @param s MpegEncContext
401  * @param overlap flag indicating that overlap filtering is used
402  * @param pq integer part of picture quantizer
403  * @param[in] n block index in the current MB
404  * @param a_avail flag indicating top block availability
405  * @param c_avail flag indicating left block availability
406  * @param dc_val_ptr Pointer to DC predictor
407  * @param dir_ptr Prediction direction for use in AC prediction
408  */
409 static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
410  int a_avail, int c_avail,
411  int16_t **dc_val_ptr, int *dir_ptr)
412 {
413  int a, b, c, wrap, pred;
414  int16_t *dc_val;
415  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
416  int q1, q2 = 0;
417  int dqscale_index;
418 
419  /* scale predictors if needed */
420  q1 = FFABS(s->current_picture.qscale_table[mb_pos]);
421  dqscale_index = s->y_dc_scale_table[q1] - 1;
422  if (dqscale_index < 0)
423  return 0;
424 
425  wrap = s->block_wrap[n];
426  dc_val = s->dc_val[0] + s->block_index[n];
427 
428  /* B A
429  * C X
430  */
431  c = dc_val[ - 1];
432  b = dc_val[ - 1 - wrap];
433  a = dc_val[ - wrap];
434 
435  if (c_avail && (n != 1 && n != 3)) {
436  q2 = FFABS(s->current_picture.qscale_table[mb_pos - 1]);
437  if (q2 && q2 != q1)
438  c = (int)((unsigned)c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
439  }
440  if (a_avail && (n != 2 && n != 3)) {
441  q2 = FFABS(s->current_picture.qscale_table[mb_pos - s->mb_stride]);
442  if (q2 && q2 != q1)
443  a = (int)((unsigned)a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
444  }
445  if (a_avail && c_avail && (n != 3)) {
446  int off = mb_pos;
447  if (n != 1)
448  off--;
449  if (n != 2)
450  off -= s->mb_stride;
451  q2 = FFABS(s->current_picture.qscale_table[off]);
452  if (q2 && q2 != q1)
453  b = (int)((unsigned)b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
454  }
455 
456  if (c_avail && (!a_avail || abs(a - b) <= abs(b - c))) {
457  pred = c;
458  *dir_ptr = 1; // left
459  } else if (a_avail) {
460  pred = a;
461  *dir_ptr = 0; // top
462  } else {
463  pred = 0;
464  *dir_ptr = 1; // left
465  }
466 
467  /* update predictor */
468  *dc_val_ptr = &dc_val[0];
469  return pred;
470 }
471 
472 /** @} */ // Block group
473 
474 /**
475  * @name VC1 Macroblock-level functions in Simple/Main Profiles
476  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
477  * @{
478  */
479 
480 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
481  uint8_t **coded_block_ptr)
482 {
483  int xy, wrap, pred, a, b, c;
484 
485  xy = s->block_index[n];
486  wrap = s->b8_stride;
487 
488  /* B C
489  * A X
490  */
491  a = s->coded_block[xy - 1 ];
492  b = s->coded_block[xy - 1 - wrap];
493  c = s->coded_block[xy - wrap];
494 
495  if (b == c) {
496  pred = a;
497  } else {
498  pred = c;
499  }
500 
501  /* store value */
502  *coded_block_ptr = &s->coded_block[xy];
503 
504  return pred;
505 }
506 
507 /**
508  * Decode one AC coefficient
509  * @param v The VC1 context
510  * @param last Last coefficient
511  * @param skip How much zero coefficients to skip
512  * @param value Decoded AC coefficient value
513  * @param codingset set of VLC to decode data
514  * @see 8.1.3.4
515  */
516 static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
517  int *value, int codingset)
518 {
519  GetBitContext *gb = &v->s.gb;
520  int index, run, level, lst, sign;
521 
522  index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3);
523  if (index < 0)
524  return index;
525  if (index != ff_vc1_ac_sizes[codingset] - 1) {
526  run = vc1_index_decode_table[codingset][index][0];
527  level = vc1_index_decode_table[codingset][index][1];
528  lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
529  sign = get_bits1(gb);
530  } else {
531  int escape = decode210(gb);
532  if (escape != 2) {
533  index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3);
534  if (index >= ff_vc1_ac_sizes[codingset] - 1U)
535  return AVERROR_INVALIDDATA;
536  run = vc1_index_decode_table[codingset][index][0];
537  level = vc1_index_decode_table[codingset][index][1];
538  lst = index >= vc1_last_decode_table[codingset];
539  if (escape == 0) {
540  if (lst)
541  level += vc1_last_delta_level_table[codingset][run];
542  else
543  level += vc1_delta_level_table[codingset][run];
544  } else {
545  if (lst)
546  run += vc1_last_delta_run_table[codingset][level] + 1;
547  else
548  run += vc1_delta_run_table[codingset][level] + 1;
549  }
550  sign = get_bits1(gb);
551  } else {
552  lst = get_bits1(gb);
553  if (v->s.esc3_level_length == 0) {
554  if (v->pq < 8 || v->dquantfrm) { // table 59
555  v->s.esc3_level_length = get_bits(gb, 3);
556  if (!v->s.esc3_level_length)
557  v->s.esc3_level_length = get_bits(gb, 2) + 8;
558  } else { // table 60
559  v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
560  }
561  v->s.esc3_run_length = 3 + get_bits(gb, 2);
562  }
563  run = get_bits(gb, v->s.esc3_run_length);
564  sign = get_bits1(gb);
565  level = get_bits(gb, v->s.esc3_level_length);
566  }
567  }
568 
569  *last = lst;
570  *skip = run;
571  *value = (level ^ -sign) + sign;
572 
573  return 0;
574 }
575 
576 /** Decode intra block in intra frames - should be faster than decode_intra_block
577  * @param v VC1Context
578  * @param block block to decode
579  * @param[in] n subblock index
580  * @param coded are AC coeffs present or not
581  * @param codingset set of VLC to decode data
582  */
583 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
584  int coded, int codingset)
585 {
586  GetBitContext *gb = &v->s.gb;
587  MpegEncContext *s = &v->s;
588  int dc_pred_dir = 0; /* Direction of the DC prediction used */
589  int i;
590  int16_t *dc_val;
591  int16_t *ac_val, *ac_val2;
592  int dcdiff, scale;
593 
594  /* Get DC differential */
595  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[s->dc_table_index][n >= 4],
596  MSMP4_DC_VLC_BITS, 3);
597  if (dcdiff) {
598  const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0;
599  if (dcdiff == 119 /* ESC index value */) {
600  dcdiff = get_bits(gb, 8 + m);
601  } else {
602  if (m)
603  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
604  }
605  if (get_bits1(gb))
606  dcdiff = -dcdiff;
607  }
608 
609  /* Prediction */
610  dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
611  *dc_val = dcdiff;
612 
613  /* Store the quantized DC coeff, used for prediction */
614  if (n < 4)
615  scale = s->y_dc_scale;
616  else
617  scale = s->c_dc_scale;
618  block[0] = dcdiff * scale;
619 
620  ac_val = s->ac_val[0][s->block_index[n]];
621  ac_val2 = ac_val;
622  if (dc_pred_dir) // left
623  ac_val -= 16;
624  else // top
625  ac_val -= 16 * s->block_wrap[n];
626 
627  scale = v->pq * 2 + v->halfpq;
628 
629  //AC Decoding
630  i = !!coded;
631 
632  if (coded) {
633  int last = 0, skip, value;
634  const uint8_t *zz_table;
635  int k;
636 
637  if (v->s.ac_pred) {
638  if (!dc_pred_dir)
639  zz_table = v->zz_8x8[2];
640  else
641  zz_table = v->zz_8x8[3];
642  } else
643  zz_table = v->zz_8x8[1];
644 
645  while (!last) {
646  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
647  if (ret < 0)
648  return ret;
649  i += skip;
650  if (i > 63)
651  break;
652  block[zz_table[i++]] = value;
653  }
654 
655  /* apply AC prediction if needed */
656  if (s->ac_pred) {
657  int sh;
658  if (dc_pred_dir) { // left
659  sh = v->left_blk_sh;
660  } else { // top
661  sh = v->top_blk_sh;
662  ac_val += 8;
663  }
664  for (k = 1; k < 8; k++)
665  block[k << sh] += ac_val[k];
666  }
667  /* save AC coeffs for further prediction */
668  for (k = 1; k < 8; k++) {
669  ac_val2[k] = block[k << v->left_blk_sh];
670  ac_val2[k + 8] = block[k << v->top_blk_sh];
671  }
672 
673  /* scale AC coeffs */
674  for (k = 1; k < 64; k++)
675  if (block[k]) {
676  block[k] *= scale;
677  if (!v->pquantizer)
678  block[k] += (block[k] < 0) ? -v->pq : v->pq;
679  }
680 
681  } else {
682  int k;
683 
684  memset(ac_val2, 0, 16 * 2);
685 
686  /* apply AC prediction if needed */
687  if (s->ac_pred) {
688  int sh;
689  if (dc_pred_dir) { //left
690  sh = v->left_blk_sh;
691  } else { // top
692  sh = v->top_blk_sh;
693  ac_val += 8;
694  ac_val2 += 8;
695  }
696  memcpy(ac_val2, ac_val, 8 * 2);
697  for (k = 1; k < 8; k++) {
698  block[k << sh] = ac_val[k] * scale;
699  if (!v->pquantizer && block[k << sh])
700  block[k << sh] += (block[k << sh] < 0) ? -v->pq : v->pq;
701  }
702  }
703  }
704  if (s->ac_pred) i = 63;
705  s->block_last_index[n] = i;
706 
707  return 0;
708 }
709 
710 /** Decode intra block in intra frames - should be faster than decode_intra_block
711  * @param v VC1Context
712  * @param block block to decode
713  * @param[in] n subblock number
714  * @param coded are AC coeffs present or not
715  * @param codingset set of VLC to decode data
716  * @param mquant quantizer value for this macroblock
717  */
718 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
719  int coded, int codingset, int mquant)
720 {
721  GetBitContext *gb = &v->s.gb;
722  MpegEncContext *s = &v->s;
723  int dc_pred_dir = 0; /* Direction of the DC prediction used */
724  int i;
725  int16_t *dc_val = NULL;
726  int16_t *ac_val, *ac_val2;
727  int dcdiff;
728  int a_avail = v->a_avail, c_avail = v->c_avail;
729  int use_pred = s->ac_pred;
730  int scale;
731  int q1, q2 = 0;
732  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
733  int quant = FFABS(mquant);
734 
735  /* Get DC differential */
736  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[s->dc_table_index][n >= 4],
737  MSMP4_DC_VLC_BITS, 3);
738  if (dcdiff) {
739  const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
740  if (dcdiff == 119 /* ESC index value */) {
741  dcdiff = get_bits(gb, 8 + m);
742  } else {
743  if (m)
744  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
745  }
746  if (get_bits1(gb))
747  dcdiff = -dcdiff;
748  }
749 
750  /* Prediction */
751  dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
752  *dc_val = dcdiff;
753 
754  /* Store the quantized DC coeff, used for prediction */
755  if (n < 4)
756  scale = s->y_dc_scale;
757  else
758  scale = s->c_dc_scale;
759  block[0] = dcdiff * scale;
760 
761  /* check if AC is needed at all */
762  if (!a_avail && !c_avail)
763  use_pred = 0;
764 
765  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
766 
767  ac_val = s->ac_val[0][s->block_index[n]];
768  ac_val2 = ac_val;
769  if (dc_pred_dir) // left
770  ac_val -= 16;
771  else // top
772  ac_val -= 16 * s->block_wrap[n];
773 
774  q1 = s->current_picture.qscale_table[mb_pos];
775  if (n == 3)
776  q2 = q1;
777  else if (dc_pred_dir) {
778  if (n == 1)
779  q2 = q1;
780  else if (c_avail && mb_pos)
781  q2 = s->current_picture.qscale_table[mb_pos - 1];
782  } else {
783  if (n == 2)
784  q2 = q1;
785  else if (a_avail && mb_pos >= s->mb_stride)
786  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
787  }
788 
789  //AC Decoding
790  i = 1;
791 
792  if (coded) {
793  int last = 0, skip, value;
794  const uint8_t *zz_table;
795  int k;
796 
797  if (v->s.ac_pred) {
798  if (!use_pred && v->fcm == ILACE_FRAME) {
799  zz_table = v->zzi_8x8;
800  } else {
801  if (!dc_pred_dir) // top
802  zz_table = v->zz_8x8[2];
803  else // left
804  zz_table = v->zz_8x8[3];
805  }
806  } else {
807  if (v->fcm != ILACE_FRAME)
808  zz_table = v->zz_8x8[1];
809  else
810  zz_table = v->zzi_8x8;
811  }
812 
813  while (!last) {
814  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
815  if (ret < 0)
816  return ret;
817  i += skip;
818  if (i > 63)
819  break;
820  block[zz_table[i++]] = value;
821  }
822 
823  /* apply AC prediction if needed */
824  if (use_pred) {
825  int sh;
826  if (dc_pred_dir) { // left
827  sh = v->left_blk_sh;
828  } else { // top
829  sh = v->top_blk_sh;
830  ac_val += 8;
831  }
832  /* scale predictors if needed*/
833  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
834  if (q1 < 1)
835  return AVERROR_INVALIDDATA;
836  if (q2)
837  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
838  if (q2 && q1 != q2) {
839  for (k = 1; k < 8; k++)
840  block[k << sh] += (int)(ac_val[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
841  } else {
842  for (k = 1; k < 8; k++)
843  block[k << sh] += ac_val[k];
844  }
845  }
846  /* save AC coeffs for further prediction */
847  for (k = 1; k < 8; k++) {
848  ac_val2[k ] = block[k << v->left_blk_sh];
849  ac_val2[k + 8] = block[k << v->top_blk_sh];
850  }
851 
852  /* scale AC coeffs */
853  for (k = 1; k < 64; k++)
854  if (block[k]) {
855  block[k] *= scale;
856  if (!v->pquantizer)
857  block[k] += (block[k] < 0) ? -quant : quant;
858  }
859 
860  } else { // no AC coeffs
861  int k;
862 
863  memset(ac_val2, 0, 16 * 2);
864 
865  /* apply AC prediction if needed */
866  if (use_pred) {
867  int sh;
868  if (dc_pred_dir) { // left
869  sh = v->left_blk_sh;
870  } else { // top
871  sh = v->top_blk_sh;
872  ac_val += 8;
873  ac_val2 += 8;
874  }
875  memcpy(ac_val2, ac_val, 8 * 2);
876  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
877  if (q1 < 1)
878  return AVERROR_INVALIDDATA;
879  if (q2)
880  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
881  if (q2 && q1 != q2) {
882  for (k = 1; k < 8; k++)
883  ac_val2[k] = (int)(ac_val2[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
884  }
885  for (k = 1; k < 8; k++) {
886  block[k << sh] = ac_val2[k] * scale;
887  if (!v->pquantizer && block[k << sh])
888  block[k << sh] += (block[k << sh] < 0) ? -quant : quant;
889  }
890  }
891  }
892  if (use_pred) i = 63;
893  s->block_last_index[n] = i;
894 
895  return 0;
896 }
897 
898 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
899  * @param v VC1Context
900  * @param block block to decode
901  * @param[in] n subblock index
902  * @param coded are AC coeffs present or not
903  * @param mquant block quantizer
904  * @param codingset set of VLC to decode data
905  */
906 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
907  int coded, int mquant, int codingset)
908 {
909  GetBitContext *gb = &v->s.gb;
910  MpegEncContext *s = &v->s;
911  int dc_pred_dir = 0; /* Direction of the DC prediction used */
912  int i;
913  int16_t *dc_val = NULL;
914  int16_t *ac_val, *ac_val2;
915  int dcdiff;
916  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
917  int a_avail = v->a_avail, c_avail = v->c_avail;
918  int use_pred = s->ac_pred;
919  int scale;
920  int q1, q2 = 0;
921  int quant = FFABS(mquant);
922 
923  s->bdsp.clear_block(block);
924 
925  /* XXX: Guard against dumb values of mquant */
926  quant = av_clip_uintp2(quant, 5);
927 
928  /* Set DC scale - y and c use the same */
929  s->y_dc_scale = s->y_dc_scale_table[quant];
930  s->c_dc_scale = s->c_dc_scale_table[quant];
931 
932  /* Get DC differential */
933  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_vlc[s->dc_table_index][n >= 4],
934  MSMP4_DC_VLC_BITS, 3);
935  if (dcdiff) {
936  const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
937  if (dcdiff == 119 /* ESC index value */) {
938  dcdiff = get_bits(gb, 8 + m);
939  } else {
940  if (m)
941  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
942  }
943  if (get_bits1(gb))
944  dcdiff = -dcdiff;
945  }
946 
947  /* Prediction */
948  dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
949  *dc_val = dcdiff;
950 
951  /* Store the quantized DC coeff, used for prediction */
952 
953  if (n < 4) {
954  block[0] = dcdiff * s->y_dc_scale;
955  } else {
956  block[0] = dcdiff * s->c_dc_scale;
957  }
958 
959  //AC Decoding
960  i = 1;
961 
962  /* check if AC is needed at all and adjust direction if needed */
963  if (!a_avail) dc_pred_dir = 1;
964  if (!c_avail) dc_pred_dir = 0;
965  if (!a_avail && !c_avail) use_pred = 0;
966  ac_val = s->ac_val[0][s->block_index[n]];
967  ac_val2 = ac_val;
968 
969  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
970 
971  if (dc_pred_dir) //left
972  ac_val -= 16;
973  else //top
974  ac_val -= 16 * s->block_wrap[n];
975 
976  q1 = s->current_picture.qscale_table[mb_pos];
977  if (dc_pred_dir && c_avail && mb_pos)
978  q2 = s->current_picture.qscale_table[mb_pos - 1];
979  if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
980  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
981  if (dc_pred_dir && n == 1)
982  q2 = q1;
983  if (!dc_pred_dir && n == 2)
984  q2 = q1;
985  if (n == 3) q2 = q1;
986 
987  if (coded) {
988  int last = 0, skip, value;
989  int k;
990 
991  while (!last) {
992  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
993  if (ret < 0)
994  return ret;
995  i += skip;
996  if (i > 63)
997  break;
998  if (v->fcm == PROGRESSIVE)
999  block[v->zz_8x8[0][i++]] = value;
1000  else {
1001  if (use_pred && (v->fcm == ILACE_FRAME)) {
1002  if (!dc_pred_dir) // top
1003  block[v->zz_8x8[2][i++]] = value;
1004  else // left
1005  block[v->zz_8x8[3][i++]] = value;
1006  } else {
1007  block[v->zzi_8x8[i++]] = value;
1008  }
1009  }
1010  }
1011 
1012  /* apply AC prediction if needed */
1013  if (use_pred) {
1014  /* scale predictors if needed*/
1015  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1016  if (q1 < 1)
1017  return AVERROR_INVALIDDATA;
1018  if (q2)
1019  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1020  if (q2 && q1 != q2) {
1021  if (dc_pred_dir) { // left
1022  for (k = 1; k < 8; k++)
1023  block[k << v->left_blk_sh] += (int)(ac_val[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1024  } else { //top
1025  for (k = 1; k < 8; k++)
1026  block[k << v->top_blk_sh] += (int)(ac_val[k + 8] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1027  }
1028  } else {
1029  if (dc_pred_dir) { // left
1030  for (k = 1; k < 8; k++)
1031  block[k << v->left_blk_sh] += ac_val[k];
1032  } else { // top
1033  for (k = 1; k < 8; k++)
1034  block[k << v->top_blk_sh] += ac_val[k + 8];
1035  }
1036  }
1037  }
1038  /* save AC coeffs for further prediction */
1039  for (k = 1; k < 8; k++) {
1040  ac_val2[k ] = block[k << v->left_blk_sh];
1041  ac_val2[k + 8] = block[k << v->top_blk_sh];
1042  }
1043 
1044  /* scale AC coeffs */
1045  for (k = 1; k < 64; k++)
1046  if (block[k]) {
1047  block[k] *= scale;
1048  if (!v->pquantizer)
1049  block[k] += (block[k] < 0) ? -quant : quant;
1050  }
1051 
1052  if (use_pred) i = 63;
1053  } else { // no AC coeffs
1054  int k;
1055 
1056  memset(ac_val2, 0, 16 * 2);
1057  if (dc_pred_dir) { // left
1058  if (use_pred) {
1059  memcpy(ac_val2, ac_val, 8 * 2);
1060  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1061  if (q1 < 1)
1062  return AVERROR_INVALIDDATA;
1063  if (q2)
1064  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1065  if (q2 && q1 != q2) {
1066  for (k = 1; k < 8; k++)
1067  ac_val2[k] = (int)(ac_val2[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1068  }
1069  }
1070  } else { // top
1071  if (use_pred) {
1072  memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1073  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1074  if (q1 < 1)
1075  return AVERROR_INVALIDDATA;
1076  if (q2)
1077  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1078  if (q2 && q1 != q2) {
1079  for (k = 1; k < 8; k++)
1080  ac_val2[k + 8] = (int)(ac_val2[k + 8] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1081  }
1082  }
1083  }
1084 
1085  /* apply AC prediction if needed */
1086  if (use_pred) {
1087  if (dc_pred_dir) { // left
1088  for (k = 1; k < 8; k++) {
1089  block[k << v->left_blk_sh] = ac_val2[k] * scale;
1090  if (!v->pquantizer && block[k << v->left_blk_sh])
1091  block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -quant : quant;
1092  }
1093  } else { // top
1094  for (k = 1; k < 8; k++) {
1095  block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
1096  if (!v->pquantizer && block[k << v->top_blk_sh])
1097  block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -quant : quant;
1098  }
1099  }
1100  i = 63;
1101  }
1102  }
1103  s->block_last_index[n] = i;
1104 
1105  return 0;
1106 }
1107 
1108 /** Decode P block
1109  */
1110 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
1111  int mquant, int ttmb, int first_block,
1112  uint8_t *dst, int linesize, int skip_block,
1113  int *ttmb_out)
1114 {
1115  MpegEncContext *s = &v->s;
1116  GetBitContext *gb = &s->gb;
1117  int i, j;
1118  int subblkpat = 0;
1119  int scale, off, idx, last, skip, value;
1120  int ttblk = ttmb & 7;
1121  int pat = 0;
1122  int quant = FFABS(mquant);
1123 
1124  s->bdsp.clear_block(block);
1125 
1126  if (ttmb == -1) {
1128  }
1129  if (ttblk == TT_4X4) {
1130  subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index], VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
1131  }
1132  if ((ttblk != TT_8X8 && ttblk != TT_4X4)
1133  && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
1134  || (!v->res_rtm_flag && !first_block))) {
1135  subblkpat = decode012(gb);
1136  if (subblkpat)
1137  subblkpat ^= 3; // swap decoded pattern bits
1138  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
1139  ttblk = TT_8X4;
1140  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
1141  ttblk = TT_4X8;
1142  }
1143  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
1144 
1145  // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
1146  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
1147  subblkpat = 2 - (ttblk == TT_8X4_TOP);
1148  ttblk = TT_8X4;
1149  }
1150  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
1151  subblkpat = 2 - (ttblk == TT_4X8_LEFT);
1152  ttblk = TT_4X8;
1153  }
1154  switch (ttblk) {
1155  case TT_8X8:
1156  pat = 0xF;
1157  i = 0;
1158  last = 0;
1159  while (!last) {
1160  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1161  if (ret < 0)
1162  return ret;
1163  i += skip;
1164  if (i > 63)
1165  break;
1166  if (!v->fcm)
1167  idx = v->zz_8x8[0][i++];
1168  else
1169  idx = v->zzi_8x8[i++];
1170  block[idx] = value * scale;
1171  if (!v->pquantizer)
1172  block[idx] += (block[idx] < 0) ? -quant : quant;
1173  }
1174  if (!skip_block) {
1175  if (i == 1)
1176  v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
1177  else {
1179  s->idsp.add_pixels_clamped(block, dst, linesize);
1180  }
1181  }
1182  break;
1183  case TT_4X4:
1184  pat = ~subblkpat & 0xF;
1185  for (j = 0; j < 4; j++) {
1186  last = subblkpat & (1 << (3 - j));
1187  i = 0;
1188  off = (j & 1) * 4 + (j & 2) * 16;
1189  while (!last) {
1190  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1191  if (ret < 0)
1192  return ret;
1193  i += skip;
1194  if (i > 15)
1195  break;
1196  if (!v->fcm)
1198  else
1200  block[idx + off] = value * scale;
1201  if (!v->pquantizer)
1202  block[idx + off] += (block[idx + off] < 0) ? -quant : quant;
1203  }
1204  if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
1205  if (i == 1)
1206  v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
1207  else
1208  v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
1209  }
1210  }
1211  break;
1212  case TT_8X4:
1213  pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
1214  for (j = 0; j < 2; j++) {
1215  last = subblkpat & (1 << (1 - j));
1216  i = 0;
1217  off = j * 32;
1218  while (!last) {
1219  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1220  if (ret < 0)
1221  return ret;
1222  i += skip;
1223  if (i > 31)
1224  break;
1225  if (!v->fcm)
1226  idx = v->zz_8x4[i++] + off;
1227  else
1228  idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
1229  block[idx] = value * scale;
1230  if (!v->pquantizer)
1231  block[idx] += (block[idx] < 0) ? -quant : quant;
1232  }
1233  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
1234  if (i == 1)
1235  v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
1236  else
1237  v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
1238  }
1239  }
1240  break;
1241  case TT_4X8:
1242  pat = ~(subblkpat * 5) & 0xF;
1243  for (j = 0; j < 2; j++) {
1244  last = subblkpat & (1 << (1 - j));
1245  i = 0;
1246  off = j * 4;
1247  while (!last) {
1248  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1249  if (ret < 0)
1250  return ret;
1251  i += skip;
1252  if (i > 31)
1253  break;
1254  if (!v->fcm)
1255  idx = v->zz_4x8[i++] + off;
1256  else
1257  idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
1258  block[idx] = value * scale;
1259  if (!v->pquantizer)
1260  block[idx] += (block[idx] < 0) ? -quant : quant;
1261  }
1262  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
1263  if (i == 1)
1264  v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
1265  else
1266  v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
1267  }
1268  }
1269  break;
1270  }
1271  if (ttmb_out)
1272  *ttmb_out |= ttblk << (n * 4);
1273  return pat;
1274 }
1275 
1276 /** @} */ // Macroblock group
1277 
1278 static const uint8_t size_table[6] = { 0, 2, 3, 4, 5, 8 };
1279 
1280 /** Decode one P-frame MB
1281  */
1283 {
1284  MpegEncContext *s = &v->s;
1285  GetBitContext *gb = &s->gb;
1286  int i, j;
1287  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1288  int cbp; /* cbp decoding stuff */
1289  int mqdiff, mquant; /* MB quantization */
1290  int ttmb = v->ttfrm; /* MB Transform type */
1291 
1292  int mb_has_coeffs = 1; /* last_flag */
1293  int dmv_x, dmv_y; /* Differential MV components */
1294  int index, index1; /* LUT indexes */
1295  int val, sign; /* temp values */
1296  int first_block = 1;
1297  int dst_idx, off;
1298  int skipped, fourmv;
1299  int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
1300 
1301  mquant = v->pq; /* lossy initialization */
1302 
1303  if (v->mv_type_is_raw)
1304  fourmv = get_bits1(gb);
1305  else
1306  fourmv = v->mv_type_mb_plane[mb_pos];
1307  if (v->skip_is_raw)
1308  skipped = get_bits1(gb);
1309  else
1310  skipped = v->s.mbskip_table[mb_pos];
1311 
1312  if (!fourmv) { /* 1MV mode */
1313  if (!skipped) {
1314  GET_MVDATA(dmv_x, dmv_y);
1315 
1316  if (s->mb_intra) {
1317  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
1318  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
1319  }
1320  s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
1321  ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1322 
1323  /* FIXME Set DC val for inter block ? */
1324  if (s->mb_intra && !mb_has_coeffs) {
1325  GET_MQUANT();
1326  s->ac_pred = get_bits1(gb);
1327  cbp = 0;
1328  } else if (mb_has_coeffs) {
1329  if (s->mb_intra)
1330  s->ac_pred = get_bits1(gb);
1331  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1332  GET_MQUANT();
1333  } else {
1334  mquant = v->pq;
1335  cbp = 0;
1336  }
1337  s->current_picture.qscale_table[mb_pos] = mquant;
1338 
1339  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1340  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index],
1341  VC1_TTMB_VLC_BITS, 2);
1342  if (!s->mb_intra) ff_vc1_mc_1mv(v, 0);
1343  dst_idx = 0;
1344  for (i = 0; i < 6; i++) {
1345  s->dc_val[0][s->block_index[i]] = 0;
1346  dst_idx += i >> 2;
1347  val = ((cbp >> (5 - i)) & 1);
1348  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1349  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1350  if (s->mb_intra) {
1351  /* check if prediction blocks A and C are available */
1352  v->a_avail = v->c_avail = 0;
1353  if (i == 2 || i == 3 || !s->first_slice_line)
1354  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1355  if (i == 1 || i == 3 || s->mb_x)
1356  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1357 
1358  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1359  (i & 4) ? v->codingset2 : v->codingset);
1360  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1361  continue;
1363  if (v->rangeredfrm)
1364  for (j = 0; j < 64; j++)
1365  v->block[v->cur_blk_idx][block_map[i]][j] *= 2;
1366  block_cbp |= 0xF << (i << 2);
1367  block_intra |= 1 << i;
1368  } else if (val) {
1369  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, first_block,
1370  s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
1371  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
1372  if (pat < 0)
1373  return pat;
1374  block_cbp |= pat << (i << 2);
1375  if (!v->ttmbf && ttmb < 8)
1376  ttmb = -1;
1377  first_block = 0;
1378  }
1379  }
1380  } else { // skipped
1381  s->mb_intra = 0;
1382  for (i = 0; i < 6; i++) {
1383  v->mb_type[0][s->block_index[i]] = 0;
1384  s->dc_val[0][s->block_index[i]] = 0;
1385  }
1386  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
1387  s->current_picture.qscale_table[mb_pos] = 0;
1388  ff_vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1389  ff_vc1_mc_1mv(v, 0);
1390  }
1391  } else { // 4MV mode
1392  if (!skipped /* unskipped MB */) {
1393  int intra_count = 0, coded_inter = 0;
1394  int is_intra[6], is_coded[6];
1395  /* Get CBPCY */
1396  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1397  for (i = 0; i < 6; i++) {
1398  val = ((cbp >> (5 - i)) & 1);
1399  s->dc_val[0][s->block_index[i]] = 0;
1400  s->mb_intra = 0;
1401  if (i < 4) {
1402  dmv_x = dmv_y = 0;
1403  s->mb_intra = 0;
1404  mb_has_coeffs = 0;
1405  if (val) {
1406  GET_MVDATA(dmv_x, dmv_y);
1407  }
1408  ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1409  if (!s->mb_intra)
1410  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1411  intra_count += s->mb_intra;
1412  is_intra[i] = s->mb_intra;
1413  is_coded[i] = mb_has_coeffs;
1414  }
1415  if (i & 4) {
1416  is_intra[i] = (intra_count >= 3);
1417  is_coded[i] = val;
1418  }
1419  if (i == 4)
1420  ff_vc1_mc_4mv_chroma(v, 0);
1421  v->mb_type[0][s->block_index[i]] = is_intra[i];
1422  if (!coded_inter)
1423  coded_inter = !is_intra[i] & is_coded[i];
1424  }
1425  // if there are no coded blocks then don't do anything more
1426  dst_idx = 0;
1427  if (!intra_count && !coded_inter)
1428  goto end;
1429  GET_MQUANT();
1430  s->current_picture.qscale_table[mb_pos] = mquant;
1431  /* test if block is intra and has pred */
1432  {
1433  int intrapred = 0;
1434  for (i = 0; i < 6; i++)
1435  if (is_intra[i]) {
1436  if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
1437  || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
1438  intrapred = 1;
1439  break;
1440  }
1441  }
1442  if (intrapred)
1443  s->ac_pred = get_bits1(gb);
1444  else
1445  s->ac_pred = 0;
1446  }
1447  if (!v->ttmbf && coded_inter)
1448  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1449  for (i = 0; i < 6; i++) {
1450  dst_idx += i >> 2;
1451  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1452  s->mb_intra = is_intra[i];
1453  if (is_intra[i]) {
1454  /* check if prediction blocks A and C are available */
1455  v->a_avail = v->c_avail = 0;
1456  if (i == 2 || i == 3 || !s->first_slice_line)
1457  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1458  if (i == 1 || i == 3 || s->mb_x)
1459  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1460 
1461  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, is_coded[i], mquant,
1462  (i & 4) ? v->codingset2 : v->codingset);
1463  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1464  continue;
1466  if (v->rangeredfrm)
1467  for (j = 0; j < 64; j++)
1468  v->block[v->cur_blk_idx][block_map[i]][j] *= 2;
1469  block_cbp |= 0xF << (i << 2);
1470  block_intra |= 1 << i;
1471  } else if (is_coded[i]) {
1472  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1473  first_block, s->dest[dst_idx] + off,
1474  (i & 4) ? s->uvlinesize : s->linesize,
1475  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY),
1476  &block_tt);
1477  if (pat < 0)
1478  return pat;
1479  block_cbp |= pat << (i << 2);
1480  if (!v->ttmbf && ttmb < 8)
1481  ttmb = -1;
1482  first_block = 0;
1483  }
1484  }
1485  } else { // skipped MB
1486  s->mb_intra = 0;
1487  s->current_picture.qscale_table[mb_pos] = 0;
1488  for (i = 0; i < 6; i++) {
1489  v->mb_type[0][s->block_index[i]] = 0;
1490  s->dc_val[0][s->block_index[i]] = 0;
1491  }
1492  for (i = 0; i < 4; i++) {
1493  ff_vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1494  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1495  }
1496  ff_vc1_mc_4mv_chroma(v, 0);
1497  s->current_picture.qscale_table[mb_pos] = 0;
1498  }
1499  }
1500 end:
1501  if (v->overlap && v->pq >= 9)
1503  vc1_put_blocks_clamped(v, 1);
1504 
1505  v->cbp[s->mb_x] = block_cbp;
1506  v->ttblk[s->mb_x] = block_tt;
1507  v->is_intra[s->mb_x] = block_intra;
1508 
1509  return 0;
1510 }
1511 
1512 /* Decode one macroblock in an interlaced frame p picture */
1513 
1515 {
1516  MpegEncContext *s = &v->s;
1517  GetBitContext *gb = &s->gb;
1518  int i;
1519  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1520  int cbp = 0; /* cbp decoding stuff */
1521  int mqdiff, mquant; /* MB quantization */
1522  int ttmb = v->ttfrm; /* MB Transform type */
1523 
1524  int mb_has_coeffs = 1; /* last_flag */
1525  int dmv_x, dmv_y; /* Differential MV components */
1526  int val; /* temp value */
1527  int first_block = 1;
1528  int dst_idx, off;
1529  int skipped, fourmv = 0, twomv = 0;
1530  int block_cbp = 0, pat, block_tt = 0;
1531  int idx_mbmode = 0, mvbp;
1532  int fieldtx;
1533 
1534  mquant = v->pq; /* Lossy initialization */
1535 
1536  if (v->skip_is_raw)
1537  skipped = get_bits1(gb);
1538  else
1539  skipped = v->s.mbskip_table[mb_pos];
1540  if (!skipped) {
1541  if (v->fourmvswitch)
1542  idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
1543  else
1544  idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
1545  switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
1546  /* store the motion vector type in a flag (useful later) */
1547  case MV_PMODE_INTFR_4MV:
1548  fourmv = 1;
1549  v->blk_mv_type[s->block_index[0]] = 0;
1550  v->blk_mv_type[s->block_index[1]] = 0;
1551  v->blk_mv_type[s->block_index[2]] = 0;
1552  v->blk_mv_type[s->block_index[3]] = 0;
1553  break;
1555  fourmv = 1;
1556  v->blk_mv_type[s->block_index[0]] = 1;
1557  v->blk_mv_type[s->block_index[1]] = 1;
1558  v->blk_mv_type[s->block_index[2]] = 1;
1559  v->blk_mv_type[s->block_index[3]] = 1;
1560  break;
1562  twomv = 1;
1563  v->blk_mv_type[s->block_index[0]] = 1;
1564  v->blk_mv_type[s->block_index[1]] = 1;
1565  v->blk_mv_type[s->block_index[2]] = 1;
1566  v->blk_mv_type[s->block_index[3]] = 1;
1567  break;
1568  case MV_PMODE_INTFR_1MV:
1569  v->blk_mv_type[s->block_index[0]] = 0;
1570  v->blk_mv_type[s->block_index[1]] = 0;
1571  v->blk_mv_type[s->block_index[2]] = 0;
1572  v->blk_mv_type[s->block_index[3]] = 0;
1573  break;
1574  }
1575  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
1576  for (i = 0; i < 4; i++) {
1577  s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
1578  s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
1579  }
1580  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1581  s->mb_intra = 1;
1582  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
1583  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
1584  mb_has_coeffs = get_bits1(gb);
1585  if (mb_has_coeffs)
1586  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1587  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1588  GET_MQUANT();
1589  s->current_picture.qscale_table[mb_pos] = mquant;
1590  /* Set DC scale - y and c use the same (not sure if necessary here) */
1591  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1592  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
1593  dst_idx = 0;
1594  for (i = 0; i < 6; i++) {
1595  v->a_avail = v->c_avail = 0;
1596  v->mb_type[0][s->block_index[i]] = 1;
1597  s->dc_val[0][s->block_index[i]] = 0;
1598  dst_idx += i >> 2;
1599  val = ((cbp >> (5 - i)) & 1);
1600  if (i == 2 || i == 3 || !s->first_slice_line)
1601  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1602  if (i == 1 || i == 3 || s->mb_x)
1603  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1604 
1605  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1606  (i & 4) ? v->codingset2 : v->codingset);
1607  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1608  continue;
1610  if (i < 4)
1611  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
1612  else
1613  off = 0;
1614  block_cbp |= 0xf << (i << 2);
1615  }
1616 
1617  } else { // inter MB
1618  mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
1619  if (mb_has_coeffs)
1620  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1621  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
1623  } else {
1624  if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
1625  || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
1627  }
1628  }
1629  s->mb_intra = v->is_intra[s->mb_x] = 0;
1630  for (i = 0; i < 6; i++)
1631  v->mb_type[0][s->block_index[i]] = 0;
1632  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
1633  /* for all motion vector read MVDATA and motion compensate each block */
1634  dst_idx = 0;
1635  if (fourmv) {
1636  mvbp = v->fourmvbp;
1637  for (i = 0; i < 4; i++) {
1638  dmv_x = dmv_y = 0;
1639  if (mvbp & (8 >> i))
1640  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1641  ff_vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, 0);
1642  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1643  }
1644  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
1645  } else if (twomv) {
1646  mvbp = v->twomvbp;
1647  dmv_x = dmv_y = 0;
1648  if (mvbp & 2) {
1649  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1650  }
1651  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0);
1652  ff_vc1_mc_4mv_luma(v, 0, 0, 0);
1653  ff_vc1_mc_4mv_luma(v, 1, 0, 0);
1654  dmv_x = dmv_y = 0;
1655  if (mvbp & 1) {
1656  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1657  }
1658  ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0);
1659  ff_vc1_mc_4mv_luma(v, 2, 0, 0);
1660  ff_vc1_mc_4mv_luma(v, 3, 0, 0);
1661  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
1662  } else {
1663  mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
1664  dmv_x = dmv_y = 0;
1665  if (mvbp) {
1666  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1667  }
1668  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0);
1669  ff_vc1_mc_1mv(v, 0);
1670  }
1671  if (cbp)
1672  GET_MQUANT(); // p. 227
1673  s->current_picture.qscale_table[mb_pos] = mquant;
1674  if (!v->ttmbf && cbp)
1675  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1676  for (i = 0; i < 6; i++) {
1677  s->dc_val[0][s->block_index[i]] = 0;
1678  dst_idx += i >> 2;
1679  val = ((cbp >> (5 - i)) & 1);
1680  if (!fieldtx)
1681  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1682  else
1683  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
1684  if (val) {
1685  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1686  first_block, s->dest[dst_idx] + off,
1687  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
1688  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
1689  if (pat < 0)
1690  return pat;
1691  block_cbp |= pat << (i << 2);
1692  if (!v->ttmbf && ttmb < 8)
1693  ttmb = -1;
1694  first_block = 0;
1695  }
1696  }
1697  }
1698  } else { // skipped
1699  s->mb_intra = v->is_intra[s->mb_x] = 0;
1700  for (i = 0; i < 6; i++) {
1701  v->mb_type[0][s->block_index[i]] = 0;
1702  s->dc_val[0][s->block_index[i]] = 0;
1703  }
1704  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
1705  s->current_picture.qscale_table[mb_pos] = 0;
1706  v->blk_mv_type[s->block_index[0]] = 0;
1707  v->blk_mv_type[s->block_index[1]] = 0;
1708  v->blk_mv_type[s->block_index[2]] = 0;
1709  v->blk_mv_type[s->block_index[3]] = 0;
1710  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0);
1711  ff_vc1_mc_1mv(v, 0);
1712  v->fieldtx_plane[mb_pos] = 0;
1713  }
1714  if (v->overlap && v->pq >= 9)
1716  vc1_put_blocks_clamped(v, 1);
1717 
1718  v->cbp[s->mb_x] = block_cbp;
1719  v->ttblk[s->mb_x] = block_tt;
1720 
1721  return 0;
1722 }
1723 
1725 {
1726  MpegEncContext *s = &v->s;
1727  GetBitContext *gb = &s->gb;
1728  int i;
1729  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1730  int cbp = 0; /* cbp decoding stuff */
1731  int mqdiff, mquant; /* MB quantization */
1732  int ttmb = v->ttfrm; /* MB Transform type */
1733 
1734  int mb_has_coeffs = 1; /* last_flag */
1735  int dmv_x, dmv_y; /* Differential MV components */
1736  int val; /* temp values */
1737  int first_block = 1;
1738  int dst_idx, off;
1739  int pred_flag = 0;
1740  int block_cbp = 0, pat, block_tt = 0;
1741  int idx_mbmode = 0;
1742 
1743  mquant = v->pq; /* Lossy initialization */
1744 
1745  idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_IF_MBMODE_VLC_BITS, 2);
1746  if (idx_mbmode <= 1) { // intra MB
1747  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1748  s->mb_intra = 1;
1749  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
1750  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
1751  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
1752  GET_MQUANT();
1753  s->current_picture.qscale_table[mb_pos] = mquant;
1754  /* Set DC scale - y and c use the same (not sure if necessary here) */
1755  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1756  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
1757  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1758  mb_has_coeffs = idx_mbmode & 1;
1759  if (mb_has_coeffs)
1760  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
1761  dst_idx = 0;
1762  for (i = 0; i < 6; i++) {
1763  v->a_avail = v->c_avail = 0;
1764  v->mb_type[0][s->block_index[i]] = 1;
1765  s->dc_val[0][s->block_index[i]] = 0;
1766  dst_idx += i >> 2;
1767  val = ((cbp >> (5 - i)) & 1);
1768  if (i == 2 || i == 3 || !s->first_slice_line)
1769  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1770  if (i == 1 || i == 3 || s->mb_x)
1771  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1772 
1773  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1774  (i & 4) ? v->codingset2 : v->codingset);
1775  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1776  continue;
1778  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1779  block_cbp |= 0xf << (i << 2);
1780  }
1781  } else {
1782  s->mb_intra = v->is_intra[s->mb_x] = 0;
1783  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
1784  for (i = 0; i < 6; i++)
1785  v->mb_type[0][s->block_index[i]] = 0;
1786  if (idx_mbmode <= 5) { // 1-MV
1787  dmv_x = dmv_y = pred_flag = 0;
1788  if (idx_mbmode & 1) {
1789  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
1790  }
1791  ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
1792  ff_vc1_mc_1mv(v, 0);
1793  mb_has_coeffs = !(idx_mbmode & 2);
1794  } else { // 4-MV
1796  for (i = 0; i < 4; i++) {
1797  dmv_x = dmv_y = pred_flag = 0;
1798  if (v->fourmvbp & (8 >> i))
1799  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
1800  ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
1801  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1802  }
1803  ff_vc1_mc_4mv_chroma(v, 0);
1804  mb_has_coeffs = idx_mbmode & 1;
1805  }
1806  if (mb_has_coeffs)
1807  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1808  if (cbp) {
1809  GET_MQUANT();
1810  }
1811  s->current_picture.qscale_table[mb_pos] = mquant;
1812  if (!v->ttmbf && cbp) {
1813  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1814  }
1815  dst_idx = 0;
1816  for (i = 0; i < 6; i++) {
1817  s->dc_val[0][s->block_index[i]] = 0;
1818  dst_idx += i >> 2;
1819  val = ((cbp >> (5 - i)) & 1);
1820  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
1821  if (val) {
1822  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1823  first_block, s->dest[dst_idx] + off,
1824  (i & 4) ? s->uvlinesize : s->linesize,
1825  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY),
1826  &block_tt);
1827  if (pat < 0)
1828  return pat;
1829  block_cbp |= pat << (i << 2);
1830  if (!v->ttmbf && ttmb < 8)
1831  ttmb = -1;
1832  first_block = 0;
1833  }
1834  }
1835  }
1836  if (v->overlap && v->pq >= 9)
1838  vc1_put_blocks_clamped(v, 1);
1839 
1840  v->cbp[s->mb_x] = block_cbp;
1841  v->ttblk[s->mb_x] = block_tt;
1842 
1843  return 0;
1844 }
1845 
1846 /** Decode one B-frame MB (in Main profile)
1847  */
1849 {
1850  MpegEncContext *s = &v->s;
1851  GetBitContext *gb = &s->gb;
1852  int i, j;
1853  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1854  int cbp = 0; /* cbp decoding stuff */
1855  int mqdiff, mquant; /* MB quantization */
1856  int ttmb = v->ttfrm; /* MB Transform type */
1857  int mb_has_coeffs = 0; /* last_flag */
1858  int index, index1; /* LUT indexes */
1859  int val, sign; /* temp values */
1860  int first_block = 1;
1861  int dst_idx, off;
1862  int skipped, direct;
1863  int dmv_x[2], dmv_y[2];
1864  int bmvtype = BMV_TYPE_BACKWARD;
1865 
1866  mquant = v->pq; /* lossy initialization */
1867  s->mb_intra = 0;
1868 
1869  if (v->dmb_is_raw)
1870  direct = get_bits1(gb);
1871  else
1872  direct = v->direct_mb_plane[mb_pos];
1873  if (v->skip_is_raw)
1874  skipped = get_bits1(gb);
1875  else
1876  skipped = v->s.mbskip_table[mb_pos];
1877 
1878  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
1879  for (i = 0; i < 6; i++) {
1880  v->mb_type[0][s->block_index[i]] = 0;
1881  s->dc_val[0][s->block_index[i]] = 0;
1882  }
1883  s->current_picture.qscale_table[mb_pos] = 0;
1884 
1885  if (!direct) {
1886  if (!skipped) {
1887  GET_MVDATA(dmv_x[0], dmv_y[0]);
1888  dmv_x[1] = dmv_x[0];
1889  dmv_y[1] = dmv_y[0];
1890  }
1891  if (skipped || !s->mb_intra) {
1892  bmvtype = decode012(gb);
1893  switch (bmvtype) {
1894  case 0:
1895  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
1896  break;
1897  case 1:
1898  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
1899  break;
1900  case 2:
1901  bmvtype = BMV_TYPE_INTERPOLATED;
1902  dmv_x[0] = dmv_y[0] = 0;
1903  }
1904  }
1905  }
1906  for (i = 0; i < 6; i++)
1907  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1908 
1909  if (skipped) {
1910  if (direct)
1911  bmvtype = BMV_TYPE_INTERPOLATED;
1912  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1913  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1914  return 0;
1915  }
1916  if (direct) {
1917  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1918  GET_MQUANT();
1919  s->mb_intra = 0;
1920  s->current_picture.qscale_table[mb_pos] = mquant;
1921  if (!v->ttmbf)
1922  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1923  dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
1924  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1925  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1926  } else {
1927  if (!mb_has_coeffs && !s->mb_intra) {
1928  /* no coded blocks - effectively skipped */
1929  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1930  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1931  return 0;
1932  }
1933  if (s->mb_intra && !mb_has_coeffs) {
1934  GET_MQUANT();
1935  s->current_picture.qscale_table[mb_pos] = mquant;
1936  s->ac_pred = get_bits1(gb);
1937  cbp = 0;
1938  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1939  } else {
1940  if (bmvtype == BMV_TYPE_INTERPOLATED) {
1941  GET_MVDATA(dmv_x[0], dmv_y[0]);
1942  if (!mb_has_coeffs) {
1943  /* interpolated skipped block */
1944  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1945  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1946  return 0;
1947  }
1948  }
1949  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1950  if (!s->mb_intra) {
1951  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1952  }
1953  if (s->mb_intra)
1954  s->ac_pred = get_bits1(gb);
1955  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
1956  GET_MQUANT();
1957  s->current_picture.qscale_table[mb_pos] = mquant;
1958  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1959  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
1960  }
1961  }
1962  dst_idx = 0;
1963  for (i = 0; i < 6; i++) {
1964  s->dc_val[0][s->block_index[i]] = 0;
1965  dst_idx += i >> 2;
1966  val = ((cbp >> (5 - i)) & 1);
1967  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1968  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1969  if (s->mb_intra) {
1970  /* check if prediction blocks A and C are available */
1971  v->a_avail = v->c_avail = 0;
1972  if (i == 2 || i == 3 || !s->first_slice_line)
1973  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1974  if (i == 1 || i == 3 || s->mb_x)
1975  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1976 
1977  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
1978  (i & 4) ? v->codingset2 : v->codingset);
1979  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1980  continue;
1981  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
1982  if (v->rangeredfrm)
1983  for (j = 0; j < 64; j++)
1984  s->block[i][j] *= 2;
1985  s->idsp.put_signed_pixels_clamped(s->block[i],
1986  s->dest[dst_idx] + off,
1987  i & 4 ? s->uvlinesize
1988  : s->linesize);
1989  } else if (val) {
1990  int pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
1991  first_block, s->dest[dst_idx] + off,
1992  (i & 4) ? s->uvlinesize : s->linesize,
1993  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), NULL);
1994  if (pat < 0)
1995  return pat;
1996  if (!v->ttmbf && ttmb < 8)
1997  ttmb = -1;
1998  first_block = 0;
1999  }
2000  }
2001  return 0;
2002 }
2003 
2004 /** Decode one B-frame MB (in interlaced field B picture)
2005  */
2007 {
2008  MpegEncContext *s = &v->s;
2009  GetBitContext *gb = &s->gb;
2010  int i, j;
2011  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2012  int cbp = 0; /* cbp decoding stuff */
2013  int mqdiff, mquant; /* MB quantization */
2014  int ttmb = v->ttfrm; /* MB Transform type */
2015  int mb_has_coeffs = 0; /* last_flag */
2016  int val; /* temp value */
2017  int first_block = 1;
2018  int dst_idx, off;
2019  int fwd;
2020  int dmv_x[2], dmv_y[2], pred_flag[2];
2021  int bmvtype = BMV_TYPE_BACKWARD;
2022  int block_cbp = 0, pat, block_tt = 0;
2023  int idx_mbmode;
2024 
2025  mquant = v->pq; /* Lossy initialization */
2026  s->mb_intra = 0;
2027 
2028  idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_IF_MBMODE_VLC_BITS, 2);
2029  if (idx_mbmode <= 1) { // intra MB
2030  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2031  s->mb_intra = 1;
2032  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
2033  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
2034  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2035  GET_MQUANT();
2036  s->current_picture.qscale_table[mb_pos] = mquant;
2037  /* Set DC scale - y and c use the same (not sure if necessary here) */
2038  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2039  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2040  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2041  mb_has_coeffs = idx_mbmode & 1;
2042  if (mb_has_coeffs)
2043  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2);
2044  dst_idx = 0;
2045  for (i = 0; i < 6; i++) {
2046  v->a_avail = v->c_avail = 0;
2047  v->mb_type[0][s->block_index[i]] = 1;
2048  s->dc_val[0][s->block_index[i]] = 0;
2049  dst_idx += i >> 2;
2050  val = ((cbp >> (5 - i)) & 1);
2051  if (i == 2 || i == 3 || !s->first_slice_line)
2052  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2053  if (i == 1 || i == 3 || s->mb_x)
2054  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2055 
2056  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
2057  (i & 4) ? v->codingset2 : v->codingset);
2058  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2059  continue;
2060  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2061  if (v->rangeredfrm)
2062  for (j = 0; j < 64; j++)
2063  s->block[i][j] <<= 1;
2064  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2065  s->idsp.put_signed_pixels_clamped(s->block[i],
2066  s->dest[dst_idx] + off,
2067  (i & 4) ? s->uvlinesize
2068  : s->linesize);
2069  }
2070  } else {
2071  s->mb_intra = v->is_intra[s->mb_x] = 0;
2072  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
2073  for (i = 0; i < 6; i++)
2074  v->mb_type[0][s->block_index[i]] = 0;
2075  if (v->fmb_is_raw)
2076  fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
2077  else
2078  fwd = v->forward_mb_plane[mb_pos];
2079  if (idx_mbmode <= 5) { // 1-MV
2080  int interpmvp = 0;
2081  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
2082  pred_flag[0] = pred_flag[1] = 0;
2083  if (fwd)
2084  bmvtype = BMV_TYPE_FORWARD;
2085  else {
2086  bmvtype = decode012(gb);
2087  switch (bmvtype) {
2088  case 0:
2089  bmvtype = BMV_TYPE_BACKWARD;
2090  break;
2091  case 1:
2092  bmvtype = BMV_TYPE_DIRECT;
2093  break;
2094  case 2:
2095  bmvtype = BMV_TYPE_INTERPOLATED;
2096  interpmvp = get_bits1(gb);
2097  }
2098  }
2099  v->bmvtype = bmvtype;
2100  if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
2101  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
2102  }
2103  if (interpmvp) {
2104  get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
2105  }
2106  if (bmvtype == BMV_TYPE_DIRECT) {
2107  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
2108  dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
2109  if (!s->next_picture_ptr->field_picture) {
2110  av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");
2111  return AVERROR_INVALIDDATA;
2112  }
2113  }
2114  ff_vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
2115  vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
2116  mb_has_coeffs = !(idx_mbmode & 2);
2117  } else { // 4-MV
2118  if (fwd)
2119  bmvtype = BMV_TYPE_FORWARD;
2120  v->bmvtype = bmvtype;
2122  for (i = 0; i < 4; i++) {
2123  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
2124  dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
2125  if (v->fourmvbp & (8 >> i)) {
2126  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
2127  &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
2128  &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
2129  }
2130  ff_vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
2131  ff_vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
2132  }
2133  ff_vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
2134  mb_has_coeffs = idx_mbmode & 1;
2135  }
2136  if (mb_has_coeffs)
2137  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2138  if (cbp) {
2139  GET_MQUANT();
2140  }
2141  s->current_picture.qscale_table[mb_pos] = mquant;
2142  if (!v->ttmbf && cbp) {
2143  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
2144  }
2145  dst_idx = 0;
2146  for (i = 0; i < 6; i++) {
2147  s->dc_val[0][s->block_index[i]] = 0;
2148  dst_idx += i >> 2;
2149  val = ((cbp >> (5 - i)) & 1);
2150  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
2151  if (val) {
2152  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
2153  first_block, s->dest[dst_idx] + off,
2154  (i & 4) ? s->uvlinesize : s->linesize,
2155  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
2156  if (pat < 0)
2157  return pat;
2158  block_cbp |= pat << (i << 2);
2159  if (!v->ttmbf && ttmb < 8)
2160  ttmb = -1;
2161  first_block = 0;
2162  }
2163  }
2164  }
2165  v->cbp[s->mb_x] = block_cbp;
2166  v->ttblk[s->mb_x] = block_tt;
2167 
2168  return 0;
2169 }
2170 
2171 /** Decode one B-frame MB (in interlaced frame B picture)
2172  */
2174 {
2175  MpegEncContext *s = &v->s;
2176  GetBitContext *gb = &s->gb;
2177  int i, j;
2178  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2179  int cbp = 0; /* cbp decoding stuff */
2180  int mqdiff, mquant; /* MB quantization */
2181  int ttmb = v->ttfrm; /* MB Transform type */
2182  int mvsw = 0; /* motion vector switch */
2183  int mb_has_coeffs = 1; /* last_flag */
2184  int dmv_x, dmv_y; /* Differential MV components */
2185  int val; /* temp value */
2186  int first_block = 1;
2187  int dst_idx, off;
2188  int skipped, direct, twomv = 0;
2189  int block_cbp = 0, pat, block_tt = 0;
2190  int idx_mbmode = 0, mvbp;
2191  int stride_y, fieldtx;
2192  int bmvtype = BMV_TYPE_BACKWARD;
2193  int dir, dir2;
2194 
2195  mquant = v->pq; /* Lossy initialization */
2196  s->mb_intra = 0;
2197  if (v->skip_is_raw)
2198  skipped = get_bits1(gb);
2199  else
2200  skipped = v->s.mbskip_table[mb_pos];
2201 
2202  if (!skipped) {
2203  idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
2204  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
2205  twomv = 1;
2206  v->blk_mv_type[s->block_index[0]] = 1;
2207  v->blk_mv_type[s->block_index[1]] = 1;
2208  v->blk_mv_type[s->block_index[2]] = 1;
2209  v->blk_mv_type[s->block_index[3]] = 1;
2210  } else {
2211  v->blk_mv_type[s->block_index[0]] = 0;
2212  v->blk_mv_type[s->block_index[1]] = 0;
2213  v->blk_mv_type[s->block_index[2]] = 0;
2214  v->blk_mv_type[s->block_index[3]] = 0;
2215  }
2216  }
2217 
2218  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
2219  for (i = 0; i < 4; i++) {
2220  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
2221  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
2222  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
2223  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
2224  }
2225  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2226  s->mb_intra = 1;
2227  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2228  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
2229  mb_has_coeffs = get_bits1(gb);
2230  if (mb_has_coeffs)
2231  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2232  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2233  GET_MQUANT();
2234  s->current_picture.qscale_table[mb_pos] = mquant;
2235  /* Set DC scale - y and c use the same (not sure if necessary here) */
2236  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2237  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2238  dst_idx = 0;
2239  for (i = 0; i < 6; i++) {
2240  v->a_avail = v->c_avail = 0;
2241  v->mb_type[0][s->block_index[i]] = 1;
2242  s->dc_val[0][s->block_index[i]] = 0;
2243  dst_idx += i >> 2;
2244  val = ((cbp >> (5 - i)) & 1);
2245  if (i == 2 || i == 3 || !s->first_slice_line)
2246  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2247  if (i == 1 || i == 3 || s->mb_x)
2248  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2249 
2250  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
2251  (i & 4) ? v->codingset2 : v->codingset);
2252  if (CONFIG_GRAY && i > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2253  continue;
2254  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2255  if (i < 4) {
2256  stride_y = s->linesize << fieldtx;
2257  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
2258  } else {
2259  stride_y = s->uvlinesize;
2260  off = 0;
2261  }
2262  s->idsp.put_signed_pixels_clamped(s->block[i],
2263  s->dest[dst_idx] + off,
2264  stride_y);
2265  }
2266  } else {
2267  s->mb_intra = v->is_intra[s->mb_x] = 0;
2268 
2269  if (v->dmb_is_raw)
2270  direct = get_bits1(gb);
2271  else
2272  direct = v->direct_mb_plane[mb_pos];
2273 
2274  if (direct) {
2275  if (s->next_picture_ptr->field_picture)
2276  av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
2277  s->mv[0][0][0] = s->current_picture.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample);
2278  s->mv[0][0][1] = s->current_picture.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample);
2279  s->mv[1][0][0] = s->current_picture.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample);
2280  s->mv[1][0][1] = s->current_picture.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample);
2281 
2282  if (twomv) {
2283  s->mv[0][2][0] = s->current_picture.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample);
2284  s->mv[0][2][1] = s->current_picture.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample);
2285  s->mv[1][2][0] = s->current_picture.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample);
2286  s->mv[1][2][1] = s->current_picture.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample);
2287 
2288  for (i = 1; i < 4; i += 2) {
2289  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
2290  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
2291  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
2292  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
2293  }
2294  } else {
2295  for (i = 1; i < 4; i++) {
2296  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
2297  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
2298  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
2299  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
2300  }
2301  }
2302  }
2303 
2304  if (!direct) {
2305  if (skipped || !s->mb_intra) {
2306  bmvtype = decode012(gb);
2307  switch (bmvtype) {
2308  case 0:
2309  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
2310  break;
2311  case 1:
2312  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
2313  break;
2314  case 2:
2315  bmvtype = BMV_TYPE_INTERPOLATED;
2316  }
2317  }
2318 
2319  if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
2320  mvsw = get_bits1(gb);
2321  }
2322 
2323  if (!skipped) { // inter MB
2324  mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
2325  if (mb_has_coeffs)
2326  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2);
2327  if (!direct) {
2328  if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
2330  } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
2332  }
2333  }
2334 
2335  for (i = 0; i < 6; i++)
2336  v->mb_type[0][s->block_index[i]] = 0;
2337  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
2338  /* for all motion vector read MVDATA and motion compensate each block */
2339  dst_idx = 0;
2340  if (direct) {
2341  if (twomv) {
2342  for (i = 0; i < 4; i++) {
2343  ff_vc1_mc_4mv_luma(v, i, 0, 0);
2344  ff_vc1_mc_4mv_luma(v, i, 1, 1);
2345  }
2346  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
2347  ff_vc1_mc_4mv_chroma4(v, 1, 1, 1);
2348  } else {
2349  ff_vc1_mc_1mv(v, 0);
2350  ff_vc1_interp_mc(v);
2351  }
2352  } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
2353  mvbp = v->fourmvbp;
2354  for (i = 0; i < 4; i++) {
2355  dir = i==1 || i==3;
2356  dmv_x = dmv_y = 0;
2357  val = ((mvbp >> (3 - i)) & 1);
2358  if (val)
2359  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2360  j = i > 1 ? 2 : 0;
2361  ff_vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir);
2362  ff_vc1_mc_4mv_luma(v, j, dir, dir);
2363  ff_vc1_mc_4mv_luma(v, j+1, dir, dir);
2364  }
2365 
2366  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
2367  ff_vc1_mc_4mv_chroma4(v, 1, 1, 1);
2368  } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
2369  mvbp = v->twomvbp;
2370  dmv_x = dmv_y = 0;
2371  if (mvbp & 2)
2372  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2373 
2374  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0);
2375  ff_vc1_mc_1mv(v, 0);
2376 
2377  dmv_x = dmv_y = 0;
2378  if (mvbp & 1)
2379  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2380 
2381  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 1);
2382  ff_vc1_interp_mc(v);
2383  } else if (twomv) {
2384  dir = bmvtype == BMV_TYPE_BACKWARD;
2385  dir2 = dir;
2386  if (mvsw)
2387  dir2 = !dir;
2388  mvbp = v->twomvbp;
2389  dmv_x = dmv_y = 0;
2390  if (mvbp & 2)
2391  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2392  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir);
2393 
2394  dmv_x = dmv_y = 0;
2395  if (mvbp & 1)
2396  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2397  ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir2);
2398 
2399  if (mvsw) {
2400  for (i = 0; i < 2; i++) {
2401  s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
2402  s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
2403  s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
2404  s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
2405  }
2406  } else {
2407  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2408  ff_vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, !dir);
2409  }
2410 
2411  ff_vc1_mc_4mv_luma(v, 0, dir, 0);
2412  ff_vc1_mc_4mv_luma(v, 1, dir, 0);
2413  ff_vc1_mc_4mv_luma(v, 2, dir2, 0);
2414  ff_vc1_mc_4mv_luma(v, 3, dir2, 0);
2415  ff_vc1_mc_4mv_chroma4(v, dir, dir2, 0);
2416  } else {
2417  dir = bmvtype == BMV_TYPE_BACKWARD;
2418 
2419  mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
2420  dmv_x = dmv_y = 0;
2421  if (mvbp)
2422  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2423 
2424  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, dir);
2425  v->blk_mv_type[s->block_index[0]] = 1;
2426  v->blk_mv_type[s->block_index[1]] = 1;
2427  v->blk_mv_type[s->block_index[2]] = 1;
2428  v->blk_mv_type[s->block_index[3]] = 1;
2429  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2430  for (i = 0; i < 2; i++) {
2431  s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
2432  s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
2433  }
2434  ff_vc1_mc_1mv(v, dir);
2435  }
2436 
2437  if (cbp)
2438  GET_MQUANT(); // p. 227
2439  s->current_picture.qscale_table[mb_pos] = mquant;
2440  if (!v->ttmbf && cbp)
2441  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2);
2442  for (i = 0; i < 6; i++) {
2443  s->dc_val[0][s->block_index[i]] = 0;
2444  dst_idx += i >> 2;
2445  val = ((cbp >> (5 - i)) & 1);
2446  if (!fieldtx)
2447  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2448  else
2449  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
2450  if (val) {
2451  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
2452  first_block, s->dest[dst_idx] + off,
2453  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
2454  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
2455  if (pat < 0)
2456  return pat;
2457  block_cbp |= pat << (i << 2);
2458  if (!v->ttmbf && ttmb < 8)
2459  ttmb = -1;
2460  first_block = 0;
2461  }
2462  }
2463 
2464  } else { // skipped
2465  dir = 0;
2466  for (i = 0; i < 6; i++) {
2467  v->mb_type[0][s->block_index[i]] = 0;
2468  s->dc_val[0][s->block_index[i]] = 0;
2469  }
2470  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2471  s->current_picture.qscale_table[mb_pos] = 0;
2472  v->blk_mv_type[s->block_index[0]] = 0;
2473  v->blk_mv_type[s->block_index[1]] = 0;
2474  v->blk_mv_type[s->block_index[2]] = 0;
2475  v->blk_mv_type[s->block_index[3]] = 0;
2476 
2477  if (!direct) {
2478  if (bmvtype == BMV_TYPE_INTERPOLATED) {
2479  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0);
2480  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 1);
2481  } else {
2482  dir = bmvtype == BMV_TYPE_BACKWARD;
2483  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, dir);
2484  if (mvsw) {
2485  int dir2 = dir;
2486  if (mvsw)
2487  dir2 = !dir;
2488  for (i = 0; i < 2; i++) {
2489  s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->current_picture.motion_val[dir][s->block_index[i+2]][0] = s->current_picture.motion_val[dir][s->block_index[i]][0];
2490  s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->current_picture.motion_val[dir][s->block_index[i+2]][1] = s->current_picture.motion_val[dir][s->block_index[i]][1];
2491  s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->current_picture.motion_val[dir2][s->block_index[i]][0] = s->current_picture.motion_val[dir2][s->block_index[i+2]][0];
2492  s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->current_picture.motion_val[dir2][s->block_index[i]][1] = s->current_picture.motion_val[dir2][s->block_index[i+2]][1];
2493  }
2494  } else {
2495  v->blk_mv_type[s->block_index[0]] = 1;
2496  v->blk_mv_type[s->block_index[1]] = 1;
2497  v->blk_mv_type[s->block_index[2]] = 1;
2498  v->blk_mv_type[s->block_index[3]] = 1;
2499  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2500  for (i = 0; i < 2; i++) {
2501  s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->current_picture.motion_val[!dir][s->block_index[i+2]][0] = s->current_picture.motion_val[!dir][s->block_index[i]][0];
2502  s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->current_picture.motion_val[!dir][s->block_index[i+2]][1] = s->current_picture.motion_val[!dir][s->block_index[i]][1];
2503  }
2504  }
2505  }
2506  }
2507 
2508  ff_vc1_mc_1mv(v, dir);
2509  if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
2510  ff_vc1_interp_mc(v);
2511  }
2512  v->fieldtx_plane[mb_pos] = 0;
2513  }
2514  }
2515  v->cbp[s->mb_x] = block_cbp;
2516  v->ttblk[s->mb_x] = block_tt;
2517 
2518  return 0;
2519 }
2520 
2521 /** Decode blocks of I-frame
2522  */
2524 {
2525  int k, j;
2526  MpegEncContext *s = &v->s;
2527  int cbp, val;
2528  uint8_t *coded_val;
2529  int mb_pos;
2530 
2531  /* select coding mode used for VLC tables selection */
2532  switch (v->y_ac_table_index) {
2533  case 0:
2535  break;
2536  case 1:
2538  break;
2539  case 2:
2541  break;
2542  }
2543 
2544  switch (v->c_ac_table_index) {
2545  case 0:
2547  break;
2548  case 1:
2550  break;
2551  case 2:
2553  break;
2554  }
2555 
2556  /* Set DC scale - y and c use the same */
2557  s->y_dc_scale = s->y_dc_scale_table[v->pq];
2558  s->c_dc_scale = s->c_dc_scale_table[v->pq];
2559 
2560  //do frame decode
2561  s->mb_x = s->mb_y = 0;
2562  s->mb_intra = 1;
2563  s->first_slice_line = 1;
2564  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2565  s->mb_x = 0;
2566  init_block_index(v);
2567  for (; s->mb_x < v->end_mb_x; s->mb_x++) {
2569  s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2570  mb_pos = s->mb_x + s->mb_y * s->mb_width;
2571  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2572  s->current_picture.qscale_table[mb_pos] = v->pq;
2573  for (int i = 0; i < 4; i++) {
2574  s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
2575  s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
2576  }
2577 
2578  // do actual MB decoding and displaying
2579  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
2581  v->s.ac_pred = get_bits1(&v->s.gb);
2582 
2583  for (k = 0; k < 6; k++) {
2584  v->mb_type[0][s->block_index[k]] = 1;
2585 
2586  val = ((cbp >> (5 - k)) & 1);
2587 
2588  if (k < 4) {
2589  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2590  val = val ^ pred;
2591  *coded_val = val;
2592  }
2593  cbp |= val << (5 - k);
2594 
2595  vc1_decode_i_block(v, v->block[v->cur_blk_idx][block_map[k]], k, val, (k < 4) ? v->codingset : v->codingset2);
2596 
2597  if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2598  continue;
2600  }
2601 
2602  if (v->overlap && v->pq >= 9) {
2604  if (v->rangeredfrm)
2605  for (k = 0; k < 6; k++)
2606  for (j = 0; j < 64; j++)
2607  v->block[v->cur_blk_idx][block_map[k]][j] *= 2;
2608  vc1_put_blocks_clamped(v, 1);
2609  } else {
2610  if (v->rangeredfrm)
2611  for (k = 0; k < 6; k++)
2612  for (j = 0; j < 64; j++)
2613  v->block[v->cur_blk_idx][block_map[k]][j] = (v->block[v->cur_blk_idx][block_map[k]][j] - 64) * 2;
2614  vc1_put_blocks_clamped(v, 0);
2615  }
2616 
2617  if (v->s.loop_filter)
2619 
2620  if (get_bits_left(&s->gb) < 0) {
2621  ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
2622  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2623  get_bits_count(&s->gb), s->gb.size_in_bits);
2624  return;
2625  }
2626 
2627  v->topleft_blk_idx = (v->topleft_blk_idx + 1) % (v->end_mb_x + 2);
2628  v->top_blk_idx = (v->top_blk_idx + 1) % (v->end_mb_x + 2);
2629  v->left_blk_idx = (v->left_blk_idx + 1) % (v->end_mb_x + 2);
2630  v->cur_blk_idx = (v->cur_blk_idx + 1) % (v->end_mb_x + 2);
2631  }
2632 
2633  s->first_slice_line = 0;
2634  }
2635 
2636  /* This is intentionally mb_height and not end_mb_y - unlike in advanced
2637  * profile, these only differ are when decoding MSS2 rectangles. */
2638  ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
2639 }
2640 
2641 /** Decode blocks of I-frame for advanced profile
2642  */
2644 {
2645  int k;
2646  MpegEncContext *s = &v->s;
2647  int cbp, val;
2648  uint8_t *coded_val;
2649  int mb_pos;
2650  int mquant;
2651  int mqdiff;
2652  GetBitContext *gb = &s->gb;
2653 
2654  if (get_bits_left(gb) <= 1)
2655  return AVERROR_INVALIDDATA;
2656 
2657  /* select coding mode used for VLC tables selection */
2658  switch (v->y_ac_table_index) {
2659  case 0:
2661  break;
2662  case 1:
2664  break;
2665  case 2:
2667  break;
2668  }
2669 
2670  switch (v->c_ac_table_index) {
2671  case 0:
2673  break;
2674  case 1:
2676  break;
2677  case 2:
2679  break;
2680  }
2681 
2682  // do frame decode
2683  s->mb_x = s->mb_y = 0;
2684  s->mb_intra = 1;
2685  s->first_slice_line = 1;
2686  s->mb_y = s->start_mb_y;
2687  if (s->start_mb_y) {
2688  s->mb_x = 0;
2689  init_block_index(v);
2690  memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
2691  (1 + s->b8_stride) * sizeof(*s->coded_block));
2692  }
2693  for (; s->mb_y < s->end_mb_y; s->mb_y++) {
2694  s->mb_x = 0;
2695  init_block_index(v);
2696  for (;s->mb_x < s->mb_width; s->mb_x++) {
2697  mquant = v->pq;
2699  s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2700  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2701  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2702  for (int i = 0; i < 4; i++) {
2703  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = 0;
2704  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = 0;
2705  }
2706 
2707  // do actual MB decoding and displaying
2708  if (v->fieldtx_is_raw)
2709  v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
2710  if (get_bits_left(&v->s.gb) <= 1) {
2711  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2712  return 0;
2713  }
2714 
2715  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc,
2717  if (v->acpred_is_raw)
2718  v->s.ac_pred = get_bits1(&v->s.gb);
2719  else
2720  v->s.ac_pred = v->acpred_plane[mb_pos];
2721 
2722  if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
2723  v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
2724 
2725  GET_MQUANT();
2726 
2727  s->current_picture.qscale_table[mb_pos] = mquant;
2728  /* Set DC scale - y and c use the same */
2729  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2730  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2731 
2732  for (k = 0; k < 6; k++) {
2733  v->mb_type[0][s->block_index[k]] = 1;
2734 
2735  val = ((cbp >> (5 - k)) & 1);
2736 
2737  if (k < 4) {
2738  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2739  val = val ^ pred;
2740  *coded_val = val;
2741  }
2742  cbp |= val << (5 - k);
2743 
2744  v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
2745  v->c_avail = !!s->mb_x || (k == 1 || k == 3);
2746 
2748  (k < 4) ? v->codingset : v->codingset2, mquant);
2749 
2750  if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2751  continue;
2753  }
2754 
2755  if (v->overlap && (v->pq >= 9 || v->condover != CONDOVER_NONE))
2757  vc1_put_blocks_clamped(v, 1);
2758  if (v->s.loop_filter)
2760 
2761  if (get_bits_left(&s->gb) < 0) {
2762  // TODO: may need modification to handle slice coding
2763  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2764  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2765  get_bits_count(&s->gb), s->gb.size_in_bits);
2766  return 0;
2767  }
2772  }
2773  s->first_slice_line = 0;
2774  }
2775 
2776  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2777  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2778  return 0;
2779 }
2780 
2782 {
2783  MpegEncContext *s = &v->s;
2784  int apply_loop_filter;
2785 
2786  /* select coding mode used for VLC tables selection */
2787  switch (v->c_ac_table_index) {
2788  case 0:
2790  break;
2791  case 1:
2793  break;
2794  case 2:
2796  break;
2797  }
2798 
2799  switch (v->c_ac_table_index) {
2800  case 0:
2802  break;
2803  case 1:
2805  break;
2806  case 2:
2808  break;
2809  }
2810 
2811  apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
2812  s->first_slice_line = 1;
2813  memset(v->cbp_base, 0, sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
2814  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2815  s->mb_x = 0;
2816  init_block_index(v);
2817  for (; s->mb_x < s->mb_width; s->mb_x++) {
2819 
2820  if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)
2821  if (get_bits_left(&v->s.gb) <= 1) {
2822  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2823  return;
2824  }
2825 
2826  if (v->fcm == ILACE_FIELD) {
2828  if (apply_loop_filter)
2830  } else if (v->fcm == ILACE_FRAME) {
2832  if (apply_loop_filter)
2834  } else {
2835  vc1_decode_p_mb(v);
2836  if (apply_loop_filter)
2838  }
2839  if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
2840  // TODO: may need modification to handle slice coding
2841  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2842  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
2843  get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
2844  return;
2845  }
2850  }
2851  memmove(v->cbp_base,
2852  v->cbp - s->mb_stride,
2853  sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
2854  memmove(v->ttblk_base,
2855  v->ttblk - s->mb_stride,
2856  sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
2857  memmove(v->is_intra_base,
2858  v->is_intra - s->mb_stride,
2859  sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
2860  memmove(v->luma_mv_base,
2861  v->luma_mv - s->mb_stride,
2862  sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
2863  s->first_slice_line = 0;
2864  }
2865  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2866  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2867 }
2868 
2870 {
2871  MpegEncContext *s = &v->s;
2872 
2873  /* select coding mode used for VLC tables selection */
2874  switch (v->c_ac_table_index) {
2875  case 0:
2877  break;
2878  case 1:
2880  break;
2881  case 2:
2883  break;
2884  }
2885 
2886  switch (v->c_ac_table_index) {
2887  case 0:
2889  break;
2890  case 1:
2892  break;
2893  case 2:
2895  break;
2896  }
2897 
2898  s->first_slice_line = 1;
2899  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2900  s->mb_x = 0;
2901  init_block_index(v);
2902  for (; s->mb_x < s->mb_width; s->mb_x++) {
2904 
2905  if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)
2906  if (get_bits_left(&v->s.gb) <= 1) {
2907  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2908  return;
2909  }
2910 
2911  if (v->fcm == ILACE_FIELD) {
2913  if (v->s.loop_filter)
2915  } else if (v->fcm == ILACE_FRAME) {
2917  if (v->s.loop_filter)
2919  } else {
2920  vc1_decode_b_mb(v);
2921  if (v->s.loop_filter)
2923  }
2924  if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
2925  // TODO: may need modification to handle slice coding
2926  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2927  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
2928  get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
2929  return;
2930  }
2931  }
2932  memmove(v->cbp_base,
2933  v->cbp - s->mb_stride,
2934  sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
2935  memmove(v->ttblk_base,
2936  v->ttblk - s->mb_stride,
2937  sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
2938  memmove(v->is_intra_base,
2939  v->is_intra - s->mb_stride,
2940  sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
2941  s->first_slice_line = 0;
2942  }
2943  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2944  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2945 }
2946 
2948 {
2949  MpegEncContext *s = &v->s;
2950 
2951  if (!v->s.last_picture.f->data[0])
2952  return;
2953 
2954  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
2955  s->first_slice_line = 1;
2956  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2957  s->mb_x = 0;
2958  init_block_index(v);
2960  memcpy(s->dest[0], s->last_picture.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
2961  memcpy(s->dest[1], s->last_picture.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2962  memcpy(s->dest[2], s->last_picture.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2963  s->first_slice_line = 0;
2964  }
2965 }
2966 
2968 {
2969 
2970  v->s.esc3_level_length = 0;
2971  if (v->x8_type) {
2973  &v->s.gb, &v->s.mb_x, &v->s.mb_y,
2974  2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
2975  v->s.loop_filter, v->s.low_delay);
2976 
2977  ff_er_add_slice(&v->s.er, 0, 0,
2978  (v->s.mb_x >> 1) - 1, (v->s.mb_y >> 1) - 1,
2979  ER_MB_END);
2980  } else {
2981  v->cur_blk_idx = 0;
2982  v->left_blk_idx = -1;
2983  v->topleft_blk_idx = 1;
2984  v->top_blk_idx = 2;
2985  switch (v->s.pict_type) {
2986  case AV_PICTURE_TYPE_I:
2987  if (v->profile == PROFILE_ADVANCED)
2989  else
2991  break;
2992  case AV_PICTURE_TYPE_P:
2993  if (v->p_frame_skipped)
2995  else
2997  break;
2998  case AV_PICTURE_TYPE_B:
2999  if (v->bi_type) {
3000  if (v->profile == PROFILE_ADVANCED)
3002  else
3004  } else
3006  break;
3007  }
3008  }
3009 }
vc1_decode_p_block
static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n, int mquant, int ttmb, int first_block, uint8_t *dst, int linesize, int skip_block, int *ttmb_out)
Decode P block.
Definition: vc1_block.c:1110
VC1Context::zz_8x8
uint8_t zz_8x8[4][64]
Zigzag table for TT_8x8, permuted for IDCT.
Definition: vc1.h:237
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
q1
static const uint8_t q1[256]
Definition: twofish.c:100
level
uint8_t level
Definition: svq3.c:204
vc1_index_decode_table
static const uint8_t vc1_index_decode_table[AC_MODES][185][2]
Definition: vc1acdata.h:34
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
VC1Context
The VC1 Context.
Definition: vc1.h:173
PROGRESSIVE
@ PROGRESSIVE
in the bitstream is reported as 00b
Definition: vc1.h:149
ff_vc1_ttblk_to_tt
const int ff_vc1_ttblk_to_tt[3][8]
Table for conversion between TTBLK and TTMB.
Definition: vc1data.c:34
VC1Context::condover
uint8_t condover
Definition: vc1.h:324
VC1Context::left_blk_idx
int left_blk_idx
Definition: vc1.h:387
AC_VLC_BITS
#define AC_VLC_BITS
Definition: intrax8.c:41
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:425
block_map
static const int block_map[6]
Definition: vc1_block.c:47
VC1Context::topleft_blk_idx
int topleft_blk_idx
Definition: vc1.h:387
VC1Context::cbp
uint32_t * cbp
Definition: vc1.h:388
VC1Context::end_mb_x
int end_mb_x
Horizontal macroblock limit (used only by mss2)
Definition: vc1.h:395
vc1_b_mc
static void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
Reconstruct motion vector for B-frame and do motion compensation.
Definition: vc1_block.c:318
VC1Context::overlap
int overlap
overlapped transforms in use
Definition: vc1.h:224
get_mvdata_interlaced
static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x, int *dmv_y, int *pred_flag)
Definition: vc1_block.c:267
vc1.h
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:122
ILACE_FRAME
@ ILACE_FRAME
in the bitstream is reported as 10b
Definition: vc1.h:150
vc1_decode_p_blocks
static void vc1_decode_p_blocks(VC1Context *v)
Definition: vc1_block.c:2781
GET_MVDATA
#define GET_MVDATA(_dmv_x, _dmv_y)
Get MV differentials.
Definition: vc1_block.c:229
VC1DSPContext::vc1_inv_trans_4x4
void(* vc1_inv_trans_4x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:40
vc1_i_pred_dc
static int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n, int16_t **dc_val_ptr, int *dir_ptr)
Get predicted DC value for I-frames only prediction dir: left=0, top=1.
Definition: vc1_block.c:344
decode210
static int BS_FUNC() decode210(BSCTX *bc)
Return decoded truncated unary code for the values 2, 1, 0.
Definition: bitstream_template.h:447
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:169
TT_8X4_BOTTOM
@ TT_8X4_BOTTOM
Definition: vc1.h:113
TT_8X4_TOP
@ TT_8X4_TOP
Definition: vc1.h:114
VC1Context::left_blk_sh
int left_blk_sh
Definition: vc1.h:238
BMV_TYPE_DIRECT
@ BMV_TYPE_DIRECT
Definition: vc1.h:105
vc1acdata.h
ff_vc1_mc_4mv_luma
void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
Do motion compensation for 4-MV macroblock - luminance block.
Definition: vc1_mc.c:452
VC1_IF_MBMODE_VLC_BITS
#define VC1_IF_MBMODE_VLC_BITS
Definition: vc1data.h:96
vc1_decode_i_block
static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n, int coded, int codingset)
Decode intra block in intra frames - should be faster than decode_intra_block.
Definition: vc1_block.c:583
CS_HIGH_RATE_INTER
@ CS_HIGH_RATE_INTER
Definition: vc1.h:131
MSMP4_MB_INTRA_VLC_BITS
#define MSMP4_MB_INTRA_VLC_BITS
Definition: msmpeg4_vc1_data.h:36
vc1_coded_block_pred
static int vc1_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: vc1_block.c:480
b
#define b
Definition: input.c:41
VC1_SUBBLKPAT_VLC_BITS
#define VC1_SUBBLKPAT_VLC_BITS
Definition: vc1data.h:79
VC1Context::cbp_base
uint32_t * cbp_base
Definition: vc1.h:388
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
VC1Context::mv_type_mb_plane
uint8_t * mv_type_mb_plane
bitplane for mv_type == (4MV)
Definition: vc1.h:284
GET_MQUANT
#define GET_MQUANT()
Get macroblock-level quantizer scale.
Definition: vc1_block.c:186
ff_vc1_adv_interlaced_4x8_zz
const uint8_t ff_vc1_adv_interlaced_4x8_zz[32]
Definition: vc1data.c:225
VC1Context::zz_8x4
const uint8_t * zz_8x4
Zigzag scan table for TT_8x4 coding mode.
Definition: vc1.h:239
VC1_CBPCY_P_VLC_BITS
#define VC1_CBPCY_P_VLC_BITS
Definition: vc1data.h:69
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:822
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:845
VC1DSPContext::vc1_inv_trans_8x8_dc
void(* vc1_inv_trans_8x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:41
mpegvideo.h
VC1Context::dmvrange
uint8_t dmvrange
Frame decoding info for interlaced picture.
Definition: vc1.h:332
VC1DSPContext::vc1_inv_trans_4x4_dc
void(* vc1_inv_trans_4x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:44
VC1Context::luma_mv
int16_t((* luma_mv)[2]
Definition: vc1.h:390
mpegutils.h
vc1_decode_p_mb_intfr
static int vc1_decode_p_mb_intfr(VC1Context *v)
Definition: vc1_block.c:1514
CS_HIGH_RATE_INTRA
@ CS_HIGH_RATE_INTRA
Definition: vc1.h:130
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
ff_vc1_interp_mc
void ff_vc1_interp_mc(VC1Context *v)
Motion compensation for direct or interpolated blocks in B-frames.
Definition: vc1_mc.c:1004
VC1Context::fieldtx_is_raw
int fieldtx_is_raw
Definition: vc1.h:344
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:201
ILACE_FIELD
@ ILACE_FIELD
in the bitstream is reported as 11b
Definition: vc1.h:151
VC1_INTFR_NON4MV_MBMODE_VLC_BITS
#define VC1_INTFR_NON4MV_MBMODE_VLC_BITS
Definition: vc1data.h:83
wrap
#define wrap(func)
Definition: neontest.h:65
ff_intrax8_decode_picture
int ff_intrax8_decode_picture(IntraX8Context *w, Picture *pict, GetBitContext *gb, int *mb_x, int *mb_y, int dquant, int quant_offset, int loopfilter, int lowdelay)
Decode single IntraX8 frame.
Definition: intrax8.c:732
CS_LOW_MOT_INTER
@ CS_LOW_MOT_INTER
Definition: vc1.h:127
GetBitContext
Definition: get_bits.h:108
VC1Context::numref
int numref
number of past field pictures used as reference
Definition: vc1.h:353
val
static double val(void *priv, double ch)
Definition: aeval.c:78
MV_PMODE_INTFR_2MV_FIELD
@ MV_PMODE_INTFR_2MV_FIELD
Definition: vc1.h:91
ff_vc1_p_overlap_filter
void ff_vc1_p_overlap_filter(VC1Context *v)
Definition: vc1_loopfilter.c:161
init_block_index
static void init_block_index(VC1Context *v)
Definition: vc1_block.c:57
VC1_TTMB_VLC_BITS
#define VC1_TTMB_VLC_BITS
Definition: vc1data.h:65
vc1_put_blocks_clamped
static void vc1_put_blocks_clamped(VC1Context *v, int put_signed)
Definition: vc1_block.c:77
VC1Context::c_ac_table_index
int c_ac_table_index
AC coding set indexes.
Definition: vc1.h:252
VC1Context::k_y
int k_y
Number of bits for MVs (depends on MV range)
Definition: vc1.h:234
VC1Context::imv_vlc
const VLCElem * imv_vlc
Definition: vc1.h:338
ff_vc1_decode_blocks
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2967
CONDOVER_NONE
@ CONDOVER_NONE
Definition: vc1.h:137
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
CS_MID_RATE_INTER
@ CS_MID_RATE_INTER
Definition: vc1.h:129
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
VC1DSPContext::vc1_inv_trans_8x4_dc
void(* vc1_inv_trans_8x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:42
VC1Context::twomvbp_vlc
const VLCElem * twomvbp_vlc
Definition: vc1.h:339
ff_vc1_pred_b_mv_intfi
void ff_vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
Definition: vc1_pred.c:891
VC1Context::mb_type
uint8_t * mb_type[3]
Definition: vc1.h:262
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_vc1_mc_1mv
void ff_vc1_mc_1mv(VC1Context *v, int dir)
Do motion compensation over 1 macroblock Mostly adapted hpel_motion and qpel_motion from mpegvideo....
Definition: vc1_mc.c:172
VC1Context::x8
IntraX8Context x8
Definition: vc1.h:175
vc1_decode_b_blocks
static void vc1_decode_b_blocks(VC1Context *v)
Definition: vc1_block.c:2869
VC1Context::over_flags_plane
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:322
bits
uint8_t bits
Definition: vp3data.h:128
TT_8X4
@ TT_8X4
Definition: vc1.h:115
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
PROFILE_ADVANCED
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
MpegEncContext::loop_filter
int loop_filter
Definition: mpegvideo.h:367
vc1_decode_ac_coeff
static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
Decode one AC coefficient.
Definition: vc1_block.c:516
vc1_decode_i_block_adv
static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n, int coded, int codingset, int mquant)
Decode intra block in intra frames - should be faster than decode_intra_block.
Definition: vc1_block.c:718
VC1Context::tt_index
int tt_index
Index for Transform Type tables (to decode TTMB)
Definition: vc1.h:283
ff_vc1_i_overlap_filter
void ff_vc1_i_overlap_filter(VC1Context *v)
Definition: vc1_loopfilter.c:105
CS_HIGH_MOT_INTER
@ CS_HIGH_MOT_INTER
Definition: vc1.h:125
TT_4X8_LEFT
@ TT_4X8_LEFT
Definition: vc1.h:117
B_FRACTION_DEN
#define B_FRACTION_DEN
Definition: vc1data.h:100
ff_vc1_mc_4mv_chroma4
void ff_vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
Definition: vc1_mc.c:839
ff_vc1_ttblk_vlc
const VLCElem * ff_vc1_ttblk_vlc[3]
Definition: vc1data.c:115
size_table
static const uint8_t size_table[6]
Definition: vc1_block.c:1278
VC1Context::top_blk_sh
int top_blk_sh
Either 3 or 0, positions of l/t in blk[].
Definition: vc1.h:238
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
VC1_INTFR_4MV_MBMODE_VLC_BITS
#define VC1_INTFR_4MV_MBMODE_VLC_BITS
Definition: vc1data.h:81
VC1Context::pq
uint8_t pq
Definition: vc1.h:236
MpegEncContext::low_delay
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:388
VC1_1REF_MVDATA_VLC_BITS
#define VC1_1REF_MVDATA_VLC_BITS
Definition: vc1data.h:89
VC1Context::forward_mb_plane
uint8_t * forward_mb_plane
bitplane for "forward" MBs
Definition: vc1.h:286
vc1_decode_p_mb_intfi
static int vc1_decode_p_mb_intfi(VC1Context *v)
Definition: vc1_block.c:1724
VC1Context::pqindex
int pqindex
raw pqindex used in coding set selection
Definition: vc1.h:260
VC1Context::skip_is_raw
int skip_is_raw
skip mb plane is not coded
Definition: vc1.h:290
NULL
#define NULL
Definition: coverity.c:32
vc1_decode_b_mb_intfi
static int vc1_decode_b_mb_intfi(VC1Context *v)
Decode one B-frame MB (in interlaced field B picture)
Definition: vc1_block.c:2006
run
uint8_t run
Definition: svq3.c:203
VC1Context::direct_mb_plane
uint8_t * direct_mb_plane
bitplane for "direct" MBs
Definition: vc1.h:285
VC1DSPContext::vc1_inv_trans_8x4
void(* vc1_inv_trans_8x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:38
vc1_decode_b_mb
static int vc1_decode_b_mb(VC1Context *v)
Decode one B-frame MB (in Main profile)
Definition: vc1_block.c:1848
MpegEncContext::mb_y
int mb_y
Definition: mpegvideo.h:283
VC1Context::field_mode
int field_mode
1 for interlaced field pictures
Definition: vc1.h:349
MpegEncContext::esc3_run_length
int esc3_run_length
Definition: mpegvideo.h:420
VC1Context::a_avail
int a_avail
Definition: vc1.h:261
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:37
VC1Context::block
int16_t(* block)[6][64]
Definition: vc1.h:386
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
CS_LOW_MOT_INTRA
@ CS_LOW_MOT_INTRA
Definition: vc1.h:126
VC1Context::fmb_is_raw
int fmb_is_raw
forward mb plane is raw
Definition: vc1.h:289
VC1Context::mbmode_vlc
const VLCElem * mbmode_vlc
Definition: vc1.h:337
VC1Context::vc1dsp
VC1DSPContext vc1dsp
Definition: vc1.h:177
VC1Context::cbpcy_vlc
const VLCElem * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
offset_table
static const uint8_t offset_table[2][9]
Definition: vc1_block.c:41
abs
#define abs(x)
Definition: cuda_runtime.h:35
inc_blk_idx
#define inc_blk_idx(idx)
Definition: vc1_block.c:169
VC1Context::luma_mv_base
int16_t(* luma_mv_base)[2]
Definition: vc1.h:390
VC1_ICBPCY_VLC_BITS
#define VC1_ICBPCY_VLC_BITS
Definition: vc1data.h:71
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
VC1Context::halfpq
uint8_t halfpq
Uniform quant over image and qp+.5.
Definition: vc1.h:271
VC1DSPContext::vc1_inv_trans_4x8_dc
void(* vc1_inv_trans_4x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:43
VC1Context::ttmbf
uint8_t ttmbf
Transform type flag.
Definition: vc1.h:256
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_vc1_i_loop_filter
void ff_vc1_i_loop_filter(VC1Context *v)
Definition: vc1_loopfilter.c:271
ff_vc1_simple_progressive_4x4_zz
const uint8_t ff_vc1_simple_progressive_4x4_zz[16]
Definition: vc1data.c:182
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
VC1Context::fieldtx_plane
uint8_t * fieldtx_plane
Definition: vc1.h:343
VC1Context::fourmvbp
uint8_t fourmvbp
Definition: vc1.h:342
ff_msmp4_mb_i_vlc
VLCElem ff_msmp4_mb_i_vlc[536]
Definition: msmpeg4_vc1_data.c:35
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
ff_vc1_p_intfr_loop_filter
void ff_vc1_p_intfr_loop_filter(VC1Context *v)
Definition: vc1_loopfilter.c:909
vc1_pred.h
MV_PMODE_INTFR_4MV
@ MV_PMODE_INTFR_4MV
Definition: vc1.h:94
VC1_TTBLK_VLC_BITS
#define VC1_TTBLK_VLC_BITS
Definition: vc1data.h:77
VC1Context::is_intra
uint8_t * is_intra
Definition: vc1.h:389
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:290
VC1Context::ttfrm
int ttfrm
Transform type info present at frame level.
Definition: vc1.h:255
VC1Context::codingset
int codingset
index of current table set from 11.8 to use for luma block decoding
Definition: vc1.h:258
VC1Context::ttblk_base
int * ttblk_base
Definition: vc1.h:257
VC1Context::mb_off
int mb_off
Definition: vc1.h:361
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
Definition: mpegvideo.h:594
VC1Context::bfraction
int16_t bfraction
Relative position % anchors=> how to scale MVs.
Definition: vc1.h:270
update_block_index
static void update_block_index(MpegEncContext *s)
Definition: vc1_block.c:68
ff_vc1_p_loop_filter
void ff_vc1_p_loop_filter(VC1Context *v)
Definition: vc1_loopfilter.c:470
MSMP4_DC_VLC_BITS
#define MSMP4_DC_VLC_BITS
Definition: msmpeg4_vc1_data.h:38
VC1Context::zzi_8x8
uint8_t zzi_8x8[64]
Definition: vc1.h:345
BMV_TYPE_INTERPOLATED
@ BMV_TYPE_INTERPOLATED
Definition: vc1.h:104
ff_vc1_pred_b_mv
void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
Definition: vc1_pred.c:691
ff_vc1_ac_coeff_table
const VLCElem * ff_vc1_ac_coeff_table[8]
Definition: vc1data.c:124
scale_mv
#define scale_mv(n, dim)
VC1Context::fourmvswitch
int fourmvswitch
Definition: vc1.h:333
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
VC1Context::rangeredfrm
uint8_t rangeredfrm
Frame decoding info for S/M profiles only.
Definition: vc1.h:301
VC1Context::top_blk_idx
int top_blk_idx
Definition: vc1.h:387
MpegEncContext::mbskip_table
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for B-frame encodin...
Definition: mpegvideo.h:186
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
vc1data.h
CS_HIGH_MOT_INTRA
@ CS_HIGH_MOT_INTRA
Definition: vc1.h:124
ff_vc1_adv_interlaced_8x4_zz
const uint8_t ff_vc1_adv_interlaced_8x4_zz[32]
Definition: vc1data.c:218
MV_PMODE_INTFR_INTRA
@ MV_PMODE_INTFR_INTRA
Definition: vc1.h:95
VC1DSPContext::vc1_inv_trans_8x8
void(* vc1_inv_trans_8x8)(int16_t *b)
Definition: vc1dsp.h:37
unary.h
apply_loop_filter
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
Definition: vp3.c:1788
ff_vc1_pred_dc
static int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, int a_avail, int c_avail, int16_t **dc_val_ptr, int *dir_ptr)
Get predicted DC value prediction dir: left=0, top=1.
Definition: vc1_block.c:409
VC1Context::k_x
int k_x
Number of bits for MVs (depends on MV range)
Definition: vc1.h:233
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
MV_PMODE_INTFR_4MV_FIELD
@ MV_PMODE_INTFR_4MV_FIELD
Definition: vc1.h:93
VC1Context::range_x
int range_x
Definition: vc1.h:235
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:436
MpegEncContext::esc3_level_length
int esc3_level_length
Definition: mpegvideo.h:419
VC1_4MV_BLOCK_PATTERN_VLC_BITS
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.h:73
BMV_TYPE_FORWARD
@ BMV_TYPE_FORWARD
Definition: vc1.h:103
MpegEncContext::mb_x
int mb_x
Definition: mpegvideo.h:283
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
ff_vc1_ac_sizes
const int ff_vc1_ac_sizes[AC_MODES]
Definition: vc1_vlc_data.h:1059
VC1Context::zz_4x8
const uint8_t * zz_4x8
Zigzag scan table for TT_4x8 coding mode.
Definition: vc1.h:240
VC1Context::ttblk
int * ttblk
Transform type at the block level.
Definition: vc1.h:257
ff_vc1_pred_mv_intfr
void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, int mvn, int r_x, int r_y, int dir)
Predict and set motion vector for interlaced frame picture MBs.
Definition: vc1_pred.c:470
ff_vc1_mbmode_intfrp
const uint8_t ff_vc1_mbmode_intfrp[2][15][4]
Definition: vc1data.c:53
MpegEncContext::er
ERContext er
Definition: mpegvideo.h:521
VC1Context::is_intra_base
uint8_t * is_intra_base
Definition: vc1.h:389
vc1_last_delta_level_table
static const uint8_t vc1_last_delta_level_table[AC_MODES][44]
Definition: vc1acdata.h:246
avcodec.h
VC1Context::fourmvbp_vlc
const VLCElem * fourmvbp_vlc
Definition: vc1.h:340
VC1Context::second_field
int second_field
Definition: vc1.h:351
ret
ret
Definition: filter_design.txt:187
VC1Context::y_ac_table_index
int y_ac_table_index
Luma index from AC2FRM element.
Definition: vc1.h:253
pred
static const float pred[4]
Definition: siprdata.h:259
vc1_decode_intra_block
static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n, int coded, int mquant, int codingset)
Decode intra block in inter frames - more generic version than vc1_decode_i_block.
Definition: vc1_block.c:906
VC1Context::twomvbp
uint8_t twomvbp
Definition: vc1.h:341
VC1Context::overflg_is_raw
int overflg_is_raw
Definition: vc1.h:323
VC1Context::pquantizer
uint8_t pquantizer
Uniform (over sequence) quantizer in use.
Definition: vc1.h:281
CS_MID_RATE_INTRA
@ CS_MID_RATE_INTRA
Definition: vc1.h:128
VC1Context::codingset2
int codingset2
index of current table set from 11.8 to use for chroma block decoding
Definition: vc1.h:259
U
#define U(x)
Definition: vpx_arith.h:37
BMV_TYPE_BACKWARD
@ BMV_TYPE_BACKWARD
Definition: vc1.h:102
ff_vc1_subblkpat_vlc
const VLCElem * ff_vc1_subblkpat_vlc[3]
Definition: vc1data.c:116
VC1_2MV_BLOCK_PATTERN_VLC_BITS
#define VC1_2MV_BLOCK_PATTERN_VLC_BITS
Definition: vc1data.h:75
vc1_decode_p_mb
static int vc1_decode_p_mb(VC1Context *v)
Decode one P-frame MB.
Definition: vc1_block.c:1282
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:382
vc1_last_delta_run_table
static const uint8_t vc1_last_delta_run_table[AC_MODES][10]
Definition: vc1acdata.h:339
ff_vc1_adv_interlaced_4x4_zz
const uint8_t ff_vc1_adv_interlaced_4x4_zz[16]
Definition: vc1data.c:236
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
mode
mode
Definition: ebur128.h:83
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
VC1Context::tff
uint8_t tff
Definition: vc1.h:310
VC1Context::x8_type
int x8_type
Definition: vc1.h:384
vc1_decode_skip_blocks
static void vc1_decode_skip_blocks(VC1Context *v)
Definition: vc1_block.c:2947
VC1Context::res_rtm_flag
int res_rtm_flag
reserved, set to 1
Definition: vc1.h:189
VC1Context::profile
int profile
Sequence header data for all Profiles TODO: choose between ints, uint8_ts and monobit flags.
Definition: vc1.h:216
vc1_decode_i_blocks
static void vc1_decode_i_blocks(VC1Context *v)
Decode blocks of I-frame.
Definition: vc1_block.c:2523
VC1Context::c_avail
int c_avail
Definition: vc1.h:261
MpegEncContext::last_picture
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:151
ff_vc1_mc_4mv_chroma
void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir)
Do motion compensation for 4-MV macroblock - both chroma blocks.
Definition: vc1_mc.c:634
VC1Context::bi_type
int bi_type
Definition: vc1.h:383
vc1_last_decode_table
static const int vc1_last_decode_table[AC_MODES]
Definition: vc1acdata.h:30
VC1Context::range_y
int range_y
MV range.
Definition: vc1.h:235
MV_PMODE_INTFR_1MV
@ MV_PMODE_INTFR_1MV
Definition: vc1.h:90
TT_4X8
@ TT_4X8
Definition: vc1.h:118
VC1Context::fcm
enum FrameCodingMode fcm
Frame decoding info for Advanced profile.
Definition: vc1.h:307
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
VC1Context::mv_type_is_raw
int mv_type_is_raw
mv type mb plane is not coded
Definition: vc1.h:287
ff_vc1_ttmb_vlc
const VLCElem * ff_vc1_ttmb_vlc[3]
Definition: vc1data.c:109
msmpeg4_vc1_data.h
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:38
ff_msmp4_dc_vlc
const VLCElem * ff_msmp4_dc_vlc[2][2]
Definition: msmpeg4_vc1_data.c:36
vc1_delta_run_table
static const uint8_t vc1_delta_run_table[AC_MODES][57]
Definition: vc1acdata.h:295
VC1Context::bmvtype
int bmvtype
Definition: vc1.h:363
VC1Context::dmb_is_raw
int dmb_is_raw
direct mb plane is raw
Definition: vc1.h:288
VC1Context::cur_blk_idx
int cur_blk_idx
Definition: vc1.h:387
VC1Context::acpred_plane
uint8_t * acpred_plane
AC prediction flags bitplane.
Definition: vc1.h:320
TT_8X8
@ TT_8X8
Definition: vc1.h:112
VC1_2REF_MVDATA_VLC_BITS
#define VC1_2REF_MVDATA_VLC_BITS
Definition: vc1data.h:91
VC1Context::acpred_is_raw
int acpred_is_raw
Definition: vc1.h:321
TT_4X8_RIGHT
@ TT_4X8_RIGHT
Definition: vc1.h:116
ff_vc1_pred_mv
void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t *is_intra, int pred_flag, int dir)
Predict and set motion vector.
Definition: vc1_pred.c:212
ff_vc1_dqscale
const int32_t ff_vc1_dqscale[63]
Definition: vc1data.c:245
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
VC1Context::blk_mv_type
uint8_t * blk_mv_type
0: frame MV, 1: field MV (interlaced frame)
Definition: vc1.h:346
vc1_decode_i_blocks_adv
static int vc1_decode_i_blocks_adv(VC1Context *v)
Decode blocks of I-frame for advanced profile.
Definition: vc1_block.c:2643
ff_vc1_b_intfi_loop_filter
void ff_vc1_b_intfi_loop_filter(VC1Context *v)
Definition: vc1_loopfilter.c:1172
VC1Context::dquantfrm
uint8_t dquantfrm
pquant parameters
Definition: vc1.h:243
vc1_delta_level_table
static const uint8_t vc1_delta_level_table[AC_MODES][31]
Definition: vc1acdata.h:203
CONDOVER_SELECT
@ CONDOVER_SELECT
Definition: vc1.h:139
VC1DSPContext::vc1_inv_trans_4x8
void(* vc1_inv_trans_4x8)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: vc1dsp.h:39
vc1_decode_b_mb_intfr
static int vc1_decode_b_mb_intfr(VC1Context *v)
Decode one B-frame MB (in interlaced frame B picture)
Definition: vc1_block.c:2173
VC1Context::blocks_off
int blocks_off
Definition: vc1.h:361
TT_4X4
@ TT_4X4
Definition: vc1.h:119
int
int
Definition: ffmpeg_filter.c:424
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:66
MpegEncContext::ac_pred
int ac_pred
Definition: mpegvideo.h:71