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;
60  ff_init_block_index(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].table, \
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 
267 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
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) {
277  bits = VC1_2REF_MVDATA_VLC_BITS;
278  esc = 125;
279  } else {
280  bits = VC1_1REF_MVDATA_VLC_BITS;
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->table, 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 
332  ff_vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
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].table, 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].table, 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  if (n < 4) {
596  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
597  MSMP4_DC_VLC_BITS, 3);
598  } else {
599  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
600  MSMP4_DC_VLC_BITS, 3);
601  }
602  if (dcdiff) {
603  const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0;
604  if (dcdiff == 119 /* ESC index value */) {
605  dcdiff = get_bits(gb, 8 + m);
606  } else {
607  if (m)
608  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
609  }
610  if (get_bits1(gb))
611  dcdiff = -dcdiff;
612  }
613 
614  /* Prediction */
615  dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
616  *dc_val = dcdiff;
617 
618  /* Store the quantized DC coeff, used for prediction */
619  if (n < 4)
620  scale = s->y_dc_scale;
621  else
622  scale = s->c_dc_scale;
623  block[0] = dcdiff * scale;
624 
625  ac_val = s->ac_val[0][s->block_index[n]];
626  ac_val2 = ac_val;
627  if (dc_pred_dir) // left
628  ac_val -= 16;
629  else // top
630  ac_val -= 16 * s->block_wrap[n];
631 
632  scale = v->pq * 2 + v->halfpq;
633 
634  //AC Decoding
635  i = !!coded;
636 
637  if (coded) {
638  int last = 0, skip, value;
639  const uint8_t *zz_table;
640  int k;
641 
642  if (v->s.ac_pred) {
643  if (!dc_pred_dir)
644  zz_table = v->zz_8x8[2];
645  else
646  zz_table = v->zz_8x8[3];
647  } else
648  zz_table = v->zz_8x8[1];
649 
650  while (!last) {
651  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
652  if (ret < 0)
653  return ret;
654  i += skip;
655  if (i > 63)
656  break;
657  block[zz_table[i++]] = value;
658  }
659 
660  /* apply AC prediction if needed */
661  if (s->ac_pred) {
662  int sh;
663  if (dc_pred_dir) { // left
664  sh = v->left_blk_sh;
665  } else { // top
666  sh = v->top_blk_sh;
667  ac_val += 8;
668  }
669  for (k = 1; k < 8; k++)
670  block[k << sh] += ac_val[k];
671  }
672  /* save AC coeffs for further prediction */
673  for (k = 1; k < 8; k++) {
674  ac_val2[k] = block[k << v->left_blk_sh];
675  ac_val2[k + 8] = block[k << v->top_blk_sh];
676  }
677 
678  /* scale AC coeffs */
679  for (k = 1; k < 64; k++)
680  if (block[k]) {
681  block[k] *= scale;
682  if (!v->pquantizer)
683  block[k] += (block[k] < 0) ? -v->pq : v->pq;
684  }
685 
686  } else {
687  int k;
688 
689  memset(ac_val2, 0, 16 * 2);
690 
691  /* apply AC prediction if needed */
692  if (s->ac_pred) {
693  int sh;
694  if (dc_pred_dir) { //left
695  sh = v->left_blk_sh;
696  } else { // top
697  sh = v->top_blk_sh;
698  ac_val += 8;
699  ac_val2 += 8;
700  }
701  memcpy(ac_val2, ac_val, 8 * 2);
702  for (k = 1; k < 8; k++) {
703  block[k << sh] = ac_val[k] * scale;
704  if (!v->pquantizer && block[k << sh])
705  block[k << sh] += (block[k << sh] < 0) ? -v->pq : v->pq;
706  }
707  }
708  }
709  if (s->ac_pred) i = 63;
710  s->block_last_index[n] = i;
711 
712  return 0;
713 }
714 
715 /** Decode intra block in intra frames - should be faster than decode_intra_block
716  * @param v VC1Context
717  * @param block block to decode
718  * @param[in] n subblock number
719  * @param coded are AC coeffs present or not
720  * @param codingset set of VLC to decode data
721  * @param mquant quantizer value for this macroblock
722  */
723 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
724  int coded, int codingset, int mquant)
725 {
726  GetBitContext *gb = &v->s.gb;
727  MpegEncContext *s = &v->s;
728  int dc_pred_dir = 0; /* Direction of the DC prediction used */
729  int i;
730  int16_t *dc_val = NULL;
731  int16_t *ac_val, *ac_val2;
732  int dcdiff;
733  int a_avail = v->a_avail, c_avail = v->c_avail;
734  int use_pred = s->ac_pred;
735  int scale;
736  int q1, q2 = 0;
737  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
738  int quant = FFABS(mquant);
739 
740  /* Get DC differential */
741  if (n < 4) {
742  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
743  MSMP4_DC_VLC_BITS, 3);
744  } else {
745  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
746  MSMP4_DC_VLC_BITS, 3);
747  }
748  if (dcdiff) {
749  const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
750  if (dcdiff == 119 /* ESC index value */) {
751  dcdiff = get_bits(gb, 8 + m);
752  } else {
753  if (m)
754  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
755  }
756  if (get_bits1(gb))
757  dcdiff = -dcdiff;
758  }
759 
760  /* Prediction */
761  dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
762  *dc_val = dcdiff;
763 
764  /* Store the quantized DC coeff, used for prediction */
765  if (n < 4)
766  scale = s->y_dc_scale;
767  else
768  scale = s->c_dc_scale;
769  block[0] = dcdiff * scale;
770 
771  /* check if AC is needed at all */
772  if (!a_avail && !c_avail)
773  use_pred = 0;
774 
775  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
776 
777  ac_val = s->ac_val[0][s->block_index[n]];
778  ac_val2 = ac_val;
779  if (dc_pred_dir) // left
780  ac_val -= 16;
781  else // top
782  ac_val -= 16 * s->block_wrap[n];
783 
784  q1 = s->current_picture.qscale_table[mb_pos];
785  if (n == 3)
786  q2 = q1;
787  else if (dc_pred_dir) {
788  if (n == 1)
789  q2 = q1;
790  else if (c_avail && mb_pos)
791  q2 = s->current_picture.qscale_table[mb_pos - 1];
792  } else {
793  if (n == 2)
794  q2 = q1;
795  else if (a_avail && mb_pos >= s->mb_stride)
796  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
797  }
798 
799  //AC Decoding
800  i = 1;
801 
802  if (coded) {
803  int last = 0, skip, value;
804  const uint8_t *zz_table;
805  int k;
806 
807  if (v->s.ac_pred) {
808  if (!use_pred && v->fcm == ILACE_FRAME) {
809  zz_table = v->zzi_8x8;
810  } else {
811  if (!dc_pred_dir) // top
812  zz_table = v->zz_8x8[2];
813  else // left
814  zz_table = v->zz_8x8[3];
815  }
816  } else {
817  if (v->fcm != ILACE_FRAME)
818  zz_table = v->zz_8x8[1];
819  else
820  zz_table = v->zzi_8x8;
821  }
822 
823  while (!last) {
824  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
825  if (ret < 0)
826  return ret;
827  i += skip;
828  if (i > 63)
829  break;
830  block[zz_table[i++]] = value;
831  }
832 
833  /* apply AC prediction if needed */
834  if (use_pred) {
835  int sh;
836  if (dc_pred_dir) { // left
837  sh = v->left_blk_sh;
838  } else { // top
839  sh = v->top_blk_sh;
840  ac_val += 8;
841  }
842  /* scale predictors if needed*/
843  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
844  if (q1 < 1)
845  return AVERROR_INVALIDDATA;
846  if (q2)
847  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
848  if (q2 && q1 != q2) {
849  for (k = 1; k < 8; k++)
850  block[k << sh] += (int)(ac_val[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
851  } else {
852  for (k = 1; k < 8; k++)
853  block[k << sh] += ac_val[k];
854  }
855  }
856  /* save AC coeffs for further prediction */
857  for (k = 1; k < 8; k++) {
858  ac_val2[k ] = block[k << v->left_blk_sh];
859  ac_val2[k + 8] = block[k << v->top_blk_sh];
860  }
861 
862  /* scale AC coeffs */
863  for (k = 1; k < 64; k++)
864  if (block[k]) {
865  block[k] *= scale;
866  if (!v->pquantizer)
867  block[k] += (block[k] < 0) ? -quant : quant;
868  }
869 
870  } else { // no AC coeffs
871  int k;
872 
873  memset(ac_val2, 0, 16 * 2);
874 
875  /* apply AC prediction if needed */
876  if (use_pred) {
877  int sh;
878  if (dc_pred_dir) { // left
879  sh = v->left_blk_sh;
880  } else { // top
881  sh = v->top_blk_sh;
882  ac_val += 8;
883  ac_val2 += 8;
884  }
885  memcpy(ac_val2, ac_val, 8 * 2);
886  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
887  if (q1 < 1)
888  return AVERROR_INVALIDDATA;
889  if (q2)
890  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
891  if (q2 && q1 != q2) {
892  for (k = 1; k < 8; k++)
893  ac_val2[k] = (int)(ac_val2[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
894  }
895  for (k = 1; k < 8; k++) {
896  block[k << sh] = ac_val2[k] * scale;
897  if (!v->pquantizer && block[k << sh])
898  block[k << sh] += (block[k << sh] < 0) ? -quant : quant;
899  }
900  }
901  }
902  if (use_pred) i = 63;
903  s->block_last_index[n] = i;
904 
905  return 0;
906 }
907 
908 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
909  * @param v VC1Context
910  * @param block block to decode
911  * @param[in] n subblock index
912  * @param coded are AC coeffs present or not
913  * @param mquant block quantizer
914  * @param codingset set of VLC to decode data
915  */
916 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
917  int coded, int mquant, int codingset)
918 {
919  GetBitContext *gb = &v->s.gb;
920  MpegEncContext *s = &v->s;
921  int dc_pred_dir = 0; /* Direction of the DC prediction used */
922  int i;
923  int16_t *dc_val = NULL;
924  int16_t *ac_val, *ac_val2;
925  int dcdiff;
926  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
927  int a_avail = v->a_avail, c_avail = v->c_avail;
928  int use_pred = s->ac_pred;
929  int scale;
930  int q1, q2 = 0;
931  int quant = FFABS(mquant);
932 
933  s->bdsp.clear_block(block);
934 
935  /* XXX: Guard against dumb values of mquant */
936  quant = av_clip_uintp2(quant, 5);
937 
938  /* Set DC scale - y and c use the same */
939  s->y_dc_scale = s->y_dc_scale_table[quant];
940  s->c_dc_scale = s->c_dc_scale_table[quant];
941 
942  /* Get DC differential */
943  if (n < 4) {
944  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
945  MSMP4_DC_VLC_BITS, 3);
946  } else {
947  dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
948  MSMP4_DC_VLC_BITS, 3);
949  }
950  if (dcdiff) {
951  const int m = (quant == 1 || quant == 2) ? 3 - quant : 0;
952  if (dcdiff == 119 /* ESC index value */) {
953  dcdiff = get_bits(gb, 8 + m);
954  } else {
955  if (m)
956  dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1);
957  }
958  if (get_bits1(gb))
959  dcdiff = -dcdiff;
960  }
961 
962  /* Prediction */
963  dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
964  *dc_val = dcdiff;
965 
966  /* Store the quantized DC coeff, used for prediction */
967 
968  if (n < 4) {
969  block[0] = dcdiff * s->y_dc_scale;
970  } else {
971  block[0] = dcdiff * s->c_dc_scale;
972  }
973 
974  //AC Decoding
975  i = 1;
976 
977  /* check if AC is needed at all and adjust direction if needed */
978  if (!a_avail) dc_pred_dir = 1;
979  if (!c_avail) dc_pred_dir = 0;
980  if (!a_avail && !c_avail) use_pred = 0;
981  ac_val = s->ac_val[0][s->block_index[n]];
982  ac_val2 = ac_val;
983 
984  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
985 
986  if (dc_pred_dir) //left
987  ac_val -= 16;
988  else //top
989  ac_val -= 16 * s->block_wrap[n];
990 
991  q1 = s->current_picture.qscale_table[mb_pos];
992  if (dc_pred_dir && c_avail && mb_pos)
993  q2 = s->current_picture.qscale_table[mb_pos - 1];
994  if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
995  q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
996  if (dc_pred_dir && n == 1)
997  q2 = q1;
998  if (!dc_pred_dir && n == 2)
999  q2 = q1;
1000  if (n == 3) q2 = q1;
1001 
1002  if (coded) {
1003  int last = 0, skip, value;
1004  int k;
1005 
1006  while (!last) {
1007  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1008  if (ret < 0)
1009  return ret;
1010  i += skip;
1011  if (i > 63)
1012  break;
1013  if (v->fcm == PROGRESSIVE)
1014  block[v->zz_8x8[0][i++]] = value;
1015  else {
1016  if (use_pred && (v->fcm == ILACE_FRAME)) {
1017  if (!dc_pred_dir) // top
1018  block[v->zz_8x8[2][i++]] = value;
1019  else // left
1020  block[v->zz_8x8[3][i++]] = value;
1021  } else {
1022  block[v->zzi_8x8[i++]] = value;
1023  }
1024  }
1025  }
1026 
1027  /* apply AC prediction if needed */
1028  if (use_pred) {
1029  /* scale predictors if needed*/
1030  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1031  if (q1 < 1)
1032  return AVERROR_INVALIDDATA;
1033  if (q2)
1034  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1035  if (q2 && q1 != q2) {
1036  if (dc_pred_dir) { // left
1037  for (k = 1; k < 8; k++)
1038  block[k << v->left_blk_sh] += (int)(ac_val[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1039  } else { //top
1040  for (k = 1; k < 8; k++)
1041  block[k << v->top_blk_sh] += (int)(ac_val[k + 8] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1042  }
1043  } else {
1044  if (dc_pred_dir) { // left
1045  for (k = 1; k < 8; k++)
1046  block[k << v->left_blk_sh] += ac_val[k];
1047  } else { // top
1048  for (k = 1; k < 8; k++)
1049  block[k << v->top_blk_sh] += ac_val[k + 8];
1050  }
1051  }
1052  }
1053  /* save AC coeffs for further prediction */
1054  for (k = 1; k < 8; k++) {
1055  ac_val2[k ] = block[k << v->left_blk_sh];
1056  ac_val2[k + 8] = block[k << v->top_blk_sh];
1057  }
1058 
1059  /* scale AC coeffs */
1060  for (k = 1; k < 64; k++)
1061  if (block[k]) {
1062  block[k] *= scale;
1063  if (!v->pquantizer)
1064  block[k] += (block[k] < 0) ? -quant : quant;
1065  }
1066 
1067  if (use_pred) i = 63;
1068  } else { // no AC coeffs
1069  int k;
1070 
1071  memset(ac_val2, 0, 16 * 2);
1072  if (dc_pred_dir) { // left
1073  if (use_pred) {
1074  memcpy(ac_val2, ac_val, 8 * 2);
1075  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1076  if (q1 < 1)
1077  return AVERROR_INVALIDDATA;
1078  if (q2)
1079  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1080  if (q2 && q1 != q2) {
1081  for (k = 1; k < 8; k++)
1082  ac_val2[k] = (int)(ac_val2[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1083  }
1084  }
1085  } else { // top
1086  if (use_pred) {
1087  memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1088  q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1;
1089  if (q1 < 1)
1090  return AVERROR_INVALIDDATA;
1091  if (q2)
1092  q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1;
1093  if (q2 && q1 != q2) {
1094  for (k = 1; k < 8; k++)
1095  ac_val2[k + 8] = (int)(ac_val2[k + 8] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1096  }
1097  }
1098  }
1099 
1100  /* apply AC prediction if needed */
1101  if (use_pred) {
1102  if (dc_pred_dir) { // left
1103  for (k = 1; k < 8; k++) {
1104  block[k << v->left_blk_sh] = ac_val2[k] * scale;
1105  if (!v->pquantizer && block[k << v->left_blk_sh])
1106  block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -quant : quant;
1107  }
1108  } else { // top
1109  for (k = 1; k < 8; k++) {
1110  block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
1111  if (!v->pquantizer && block[k << v->top_blk_sh])
1112  block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -quant : quant;
1113  }
1114  }
1115  i = 63;
1116  }
1117  }
1118  s->block_last_index[n] = i;
1119 
1120  return 0;
1121 }
1122 
1123 /** Decode P block
1124  */
1125 static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
1126  int mquant, int ttmb, int first_block,
1127  uint8_t *dst, int linesize, int skip_block,
1128  int *ttmb_out)
1129 {
1130  MpegEncContext *s = &v->s;
1131  GetBitContext *gb = &s->gb;
1132  int i, j;
1133  int subblkpat = 0;
1134  int scale, off, idx, last, skip, value;
1135  int ttblk = ttmb & 7;
1136  int pat = 0;
1137  int quant = FFABS(mquant);
1138 
1139  s->bdsp.clear_block(block);
1140 
1141  if (ttmb == -1) {
1142  ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
1143  }
1144  if (ttblk == TT_4X4) {
1145  subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
1146  }
1147  if ((ttblk != TT_8X8 && ttblk != TT_4X4)
1148  && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
1149  || (!v->res_rtm_flag && !first_block))) {
1150  subblkpat = decode012(gb);
1151  if (subblkpat)
1152  subblkpat ^= 3; // swap decoded pattern bits
1153  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
1154  ttblk = TT_8X4;
1155  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
1156  ttblk = TT_4X8;
1157  }
1158  scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq);
1159 
1160  // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
1161  if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
1162  subblkpat = 2 - (ttblk == TT_8X4_TOP);
1163  ttblk = TT_8X4;
1164  }
1165  if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
1166  subblkpat = 2 - (ttblk == TT_4X8_LEFT);
1167  ttblk = TT_4X8;
1168  }
1169  switch (ttblk) {
1170  case TT_8X8:
1171  pat = 0xF;
1172  i = 0;
1173  last = 0;
1174  while (!last) {
1175  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1176  if (ret < 0)
1177  return ret;
1178  i += skip;
1179  if (i > 63)
1180  break;
1181  if (!v->fcm)
1182  idx = v->zz_8x8[0][i++];
1183  else
1184  idx = v->zzi_8x8[i++];
1185  block[idx] = value * scale;
1186  if (!v->pquantizer)
1187  block[idx] += (block[idx] < 0) ? -quant : quant;
1188  }
1189  if (!skip_block) {
1190  if (i == 1)
1191  v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
1192  else {
1193  v->vc1dsp.vc1_inv_trans_8x8(block);
1194  s->idsp.add_pixels_clamped(block, dst, linesize);
1195  }
1196  }
1197  break;
1198  case TT_4X4:
1199  pat = ~subblkpat & 0xF;
1200  for (j = 0; j < 4; j++) {
1201  last = subblkpat & (1 << (3 - j));
1202  i = 0;
1203  off = (j & 1) * 4 + (j & 2) * 16;
1204  while (!last) {
1205  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1206  if (ret < 0)
1207  return ret;
1208  i += skip;
1209  if (i > 15)
1210  break;
1211  if (!v->fcm)
1212  idx = ff_vc1_simple_progressive_4x4_zz[i++];
1213  else
1214  idx = ff_vc1_adv_interlaced_4x4_zz[i++];
1215  block[idx + off] = value * scale;
1216  if (!v->pquantizer)
1217  block[idx + off] += (block[idx + off] < 0) ? -quant : quant;
1218  }
1219  if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
1220  if (i == 1)
1221  v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
1222  else
1223  v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
1224  }
1225  }
1226  break;
1227  case TT_8X4:
1228  pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
1229  for (j = 0; j < 2; j++) {
1230  last = subblkpat & (1 << (1 - j));
1231  i = 0;
1232  off = j * 32;
1233  while (!last) {
1234  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1235  if (ret < 0)
1236  return ret;
1237  i += skip;
1238  if (i > 31)
1239  break;
1240  if (!v->fcm)
1241  idx = v->zz_8x4[i++] + off;
1242  else
1243  idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
1244  block[idx] = value * scale;
1245  if (!v->pquantizer)
1246  block[idx] += (block[idx] < 0) ? -quant : quant;
1247  }
1248  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
1249  if (i == 1)
1250  v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
1251  else
1252  v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
1253  }
1254  }
1255  break;
1256  case TT_4X8:
1257  pat = ~(subblkpat * 5) & 0xF;
1258  for (j = 0; j < 2; j++) {
1259  last = subblkpat & (1 << (1 - j));
1260  i = 0;
1261  off = j * 4;
1262  while (!last) {
1263  int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
1264  if (ret < 0)
1265  return ret;
1266  i += skip;
1267  if (i > 31)
1268  break;
1269  if (!v->fcm)
1270  idx = v->zz_4x8[i++] + off;
1271  else
1272  idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
1273  block[idx] = value * scale;
1274  if (!v->pquantizer)
1275  block[idx] += (block[idx] < 0) ? -quant : quant;
1276  }
1277  if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
1278  if (i == 1)
1279  v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
1280  else
1281  v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
1282  }
1283  }
1284  break;
1285  }
1286  if (ttmb_out)
1287  *ttmb_out |= ttblk << (n * 4);
1288  return pat;
1289 }
1290 
1291 /** @} */ // Macroblock group
1292 
1293 static const uint8_t size_table[6] = { 0, 2, 3, 4, 5, 8 };
1294 
1295 /** Decode one P-frame MB
1296  */
1297 static int vc1_decode_p_mb(VC1Context *v)
1298 {
1299  MpegEncContext *s = &v->s;
1300  GetBitContext *gb = &s->gb;
1301  int i, j;
1302  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1303  int cbp; /* cbp decoding stuff */
1304  int mqdiff, mquant; /* MB quantization */
1305  int ttmb = v->ttfrm; /* MB Transform type */
1306 
1307  int mb_has_coeffs = 1; /* last_flag */
1308  int dmv_x, dmv_y; /* Differential MV components */
1309  int index, index1; /* LUT indexes */
1310  int val, sign; /* temp values */
1311  int first_block = 1;
1312  int dst_idx, off;
1313  int skipped, fourmv;
1314  int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
1315 
1316  mquant = v->pq; /* lossy initialization */
1317 
1318  if (v->mv_type_is_raw)
1319  fourmv = get_bits1(gb);
1320  else
1321  fourmv = v->mv_type_mb_plane[mb_pos];
1322  if (v->skip_is_raw)
1323  skipped = get_bits1(gb);
1324  else
1325  skipped = v->s.mbskip_table[mb_pos];
1326 
1327  if (!fourmv) { /* 1MV mode */
1328  if (!skipped) {
1329  GET_MVDATA(dmv_x, dmv_y);
1330 
1331  if (s->mb_intra) {
1332  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
1333  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
1334  }
1335  s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
1336  ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1337 
1338  /* FIXME Set DC val for inter block ? */
1339  if (s->mb_intra && !mb_has_coeffs) {
1340  GET_MQUANT();
1341  s->ac_pred = get_bits1(gb);
1342  cbp = 0;
1343  } else if (mb_has_coeffs) {
1344  if (s->mb_intra)
1345  s->ac_pred = get_bits1(gb);
1346  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1347  GET_MQUANT();
1348  } else {
1349  mquant = v->pq;
1350  cbp = 0;
1351  }
1352  s->current_picture.qscale_table[mb_pos] = mquant;
1353 
1354  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1355  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
1356  VC1_TTMB_VLC_BITS, 2);
1357  if (!s->mb_intra) ff_vc1_mc_1mv(v, 0);
1358  dst_idx = 0;
1359  for (i = 0; i < 6; i++) {
1360  s->dc_val[0][s->block_index[i]] = 0;
1361  dst_idx += i >> 2;
1362  val = ((cbp >> (5 - i)) & 1);
1363  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1364  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1365  if (s->mb_intra) {
1366  /* check if prediction blocks A and C are available */
1367  v->a_avail = v->c_avail = 0;
1368  if (i == 2 || i == 3 || !s->first_slice_line)
1369  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1370  if (i == 1 || i == 3 || s->mb_x)
1371  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1372 
1373  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1374  (i & 4) ? v->codingset2 : v->codingset);
1375  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1376  continue;
1377  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]);
1378  if (v->rangeredfrm)
1379  for (j = 0; j < 64; j++)
1380  v->block[v->cur_blk_idx][block_map[i]][j] *= 2;
1381  block_cbp |= 0xF << (i << 2);
1382  block_intra |= 1 << i;
1383  } else if (val) {
1384  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, first_block,
1385  s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
1386  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
1387  if (pat < 0)
1388  return pat;
1389  block_cbp |= pat << (i << 2);
1390  if (!v->ttmbf && ttmb < 8)
1391  ttmb = -1;
1392  first_block = 0;
1393  }
1394  }
1395  } else { // skipped
1396  s->mb_intra = 0;
1397  for (i = 0; i < 6; i++) {
1398  v->mb_type[0][s->block_index[i]] = 0;
1399  s->dc_val[0][s->block_index[i]] = 0;
1400  }
1401  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
1402  s->current_picture.qscale_table[mb_pos] = 0;
1403  ff_vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1404  ff_vc1_mc_1mv(v, 0);
1405  }
1406  } else { // 4MV mode
1407  if (!skipped /* unskipped MB */) {
1408  int intra_count = 0, coded_inter = 0;
1409  int is_intra[6], is_coded[6];
1410  /* Get CBPCY */
1411  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1412  for (i = 0; i < 6; i++) {
1413  val = ((cbp >> (5 - i)) & 1);
1414  s->dc_val[0][s->block_index[i]] = 0;
1415  s->mb_intra = 0;
1416  if (i < 4) {
1417  dmv_x = dmv_y = 0;
1418  s->mb_intra = 0;
1419  mb_has_coeffs = 0;
1420  if (val) {
1421  GET_MVDATA(dmv_x, dmv_y);
1422  }
1423  ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1424  if (!s->mb_intra)
1425  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1426  intra_count += s->mb_intra;
1427  is_intra[i] = s->mb_intra;
1428  is_coded[i] = mb_has_coeffs;
1429  }
1430  if (i & 4) {
1431  is_intra[i] = (intra_count >= 3);
1432  is_coded[i] = val;
1433  }
1434  if (i == 4)
1435  ff_vc1_mc_4mv_chroma(v, 0);
1436  v->mb_type[0][s->block_index[i]] = is_intra[i];
1437  if (!coded_inter)
1438  coded_inter = !is_intra[i] & is_coded[i];
1439  }
1440  // if there are no coded blocks then don't do anything more
1441  dst_idx = 0;
1442  if (!intra_count && !coded_inter)
1443  goto end;
1444  GET_MQUANT();
1445  s->current_picture.qscale_table[mb_pos] = mquant;
1446  /* test if block is intra and has pred */
1447  {
1448  int intrapred = 0;
1449  for (i = 0; i < 6; i++)
1450  if (is_intra[i]) {
1451  if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
1452  || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
1453  intrapred = 1;
1454  break;
1455  }
1456  }
1457  if (intrapred)
1458  s->ac_pred = get_bits1(gb);
1459  else
1460  s->ac_pred = 0;
1461  }
1462  if (!v->ttmbf && coded_inter)
1463  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
1464  for (i = 0; i < 6; i++) {
1465  dst_idx += i >> 2;
1466  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1467  s->mb_intra = is_intra[i];
1468  if (is_intra[i]) {
1469  /* check if prediction blocks A and C are available */
1470  v->a_avail = v->c_avail = 0;
1471  if (i == 2 || i == 3 || !s->first_slice_line)
1472  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1473  if (i == 1 || i == 3 || s->mb_x)
1474  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1475 
1476  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, is_coded[i], mquant,
1477  (i & 4) ? v->codingset2 : v->codingset);
1478  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1479  continue;
1480  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]);
1481  if (v->rangeredfrm)
1482  for (j = 0; j < 64; j++)
1483  v->block[v->cur_blk_idx][block_map[i]][j] *= 2;
1484  block_cbp |= 0xF << (i << 2);
1485  block_intra |= 1 << i;
1486  } else if (is_coded[i]) {
1487  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1488  first_block, s->dest[dst_idx] + off,
1489  (i & 4) ? s->uvlinesize : s->linesize,
1490  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY),
1491  &block_tt);
1492  if (pat < 0)
1493  return pat;
1494  block_cbp |= pat << (i << 2);
1495  if (!v->ttmbf && ttmb < 8)
1496  ttmb = -1;
1497  first_block = 0;
1498  }
1499  }
1500  } else { // skipped MB
1501  s->mb_intra = 0;
1502  s->current_picture.qscale_table[mb_pos] = 0;
1503  for (i = 0; i < 6; i++) {
1504  v->mb_type[0][s->block_index[i]] = 0;
1505  s->dc_val[0][s->block_index[i]] = 0;
1506  }
1507  for (i = 0; i < 4; i++) {
1508  ff_vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
1509  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1510  }
1511  ff_vc1_mc_4mv_chroma(v, 0);
1512  s->current_picture.qscale_table[mb_pos] = 0;
1513  }
1514  }
1515 end:
1516  if (v->overlap && v->pq >= 9)
1517  ff_vc1_p_overlap_filter(v);
1518  vc1_put_blocks_clamped(v, 1);
1519 
1520  v->cbp[s->mb_x] = block_cbp;
1521  v->ttblk[s->mb_x] = block_tt;
1522  v->is_intra[s->mb_x] = block_intra;
1523 
1524  return 0;
1525 }
1526 
1527 /* Decode one macroblock in an interlaced frame p picture */
1528 
1529 static int vc1_decode_p_mb_intfr(VC1Context *v)
1530 {
1531  MpegEncContext *s = &v->s;
1532  GetBitContext *gb = &s->gb;
1533  int i;
1534  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1535  int cbp = 0; /* cbp decoding stuff */
1536  int mqdiff, mquant; /* MB quantization */
1537  int ttmb = v->ttfrm; /* MB Transform type */
1538 
1539  int mb_has_coeffs = 1; /* last_flag */
1540  int dmv_x, dmv_y; /* Differential MV components */
1541  int val; /* temp value */
1542  int first_block = 1;
1543  int dst_idx, off;
1544  int skipped, fourmv = 0, twomv = 0;
1545  int block_cbp = 0, pat, block_tt = 0;
1546  int idx_mbmode = 0, mvbp;
1547  int fieldtx;
1548 
1549  mquant = v->pq; /* Lossy initialization */
1550 
1551  if (v->skip_is_raw)
1552  skipped = get_bits1(gb);
1553  else
1554  skipped = v->s.mbskip_table[mb_pos];
1555  if (!skipped) {
1556  if (v->fourmvswitch)
1557  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
1558  else
1559  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
1560  switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
1561  /* store the motion vector type in a flag (useful later) */
1562  case MV_PMODE_INTFR_4MV:
1563  fourmv = 1;
1564  v->blk_mv_type[s->block_index[0]] = 0;
1565  v->blk_mv_type[s->block_index[1]] = 0;
1566  v->blk_mv_type[s->block_index[2]] = 0;
1567  v->blk_mv_type[s->block_index[3]] = 0;
1568  break;
1569  case MV_PMODE_INTFR_4MV_FIELD:
1570  fourmv = 1;
1571  v->blk_mv_type[s->block_index[0]] = 1;
1572  v->blk_mv_type[s->block_index[1]] = 1;
1573  v->blk_mv_type[s->block_index[2]] = 1;
1574  v->blk_mv_type[s->block_index[3]] = 1;
1575  break;
1576  case MV_PMODE_INTFR_2MV_FIELD:
1577  twomv = 1;
1578  v->blk_mv_type[s->block_index[0]] = 1;
1579  v->blk_mv_type[s->block_index[1]] = 1;
1580  v->blk_mv_type[s->block_index[2]] = 1;
1581  v->blk_mv_type[s->block_index[3]] = 1;
1582  break;
1583  case MV_PMODE_INTFR_1MV:
1584  v->blk_mv_type[s->block_index[0]] = 0;
1585  v->blk_mv_type[s->block_index[1]] = 0;
1586  v->blk_mv_type[s->block_index[2]] = 0;
1587  v->blk_mv_type[s->block_index[3]] = 0;
1588  break;
1589  }
1590  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
1591  for (i = 0; i < 4; i++) {
1592  s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
1593  s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
1594  }
1595  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1596  s->mb_intra = 1;
1597  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
1598  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
1599  mb_has_coeffs = get_bits1(gb);
1600  if (mb_has_coeffs)
1601  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1602  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1603  GET_MQUANT();
1604  s->current_picture.qscale_table[mb_pos] = mquant;
1605  /* Set DC scale - y and c use the same (not sure if necessary here) */
1606  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1607  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
1608  dst_idx = 0;
1609  for (i = 0; i < 6; i++) {
1610  v->a_avail = v->c_avail = 0;
1611  v->mb_type[0][s->block_index[i]] = 1;
1612  s->dc_val[0][s->block_index[i]] = 0;
1613  dst_idx += i >> 2;
1614  val = ((cbp >> (5 - i)) & 1);
1615  if (i == 2 || i == 3 || !s->first_slice_line)
1616  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1617  if (i == 1 || i == 3 || s->mb_x)
1618  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1619 
1620  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1621  (i & 4) ? v->codingset2 : v->codingset);
1622  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1623  continue;
1624  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]);
1625  if (i < 4)
1626  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
1627  else
1628  off = 0;
1629  block_cbp |= 0xf << (i << 2);
1630  }
1631 
1632  } else { // inter MB
1633  mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
1634  if (mb_has_coeffs)
1635  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1636  if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
1637  v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
1638  } else {
1639  if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
1640  || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
1641  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
1642  }
1643  }
1644  s->mb_intra = v->is_intra[s->mb_x] = 0;
1645  for (i = 0; i < 6; i++)
1646  v->mb_type[0][s->block_index[i]] = 0;
1647  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
1648  /* for all motion vector read MVDATA and motion compensate each block */
1649  dst_idx = 0;
1650  if (fourmv) {
1651  mvbp = v->fourmvbp;
1652  for (i = 0; i < 4; i++) {
1653  dmv_x = dmv_y = 0;
1654  if (mvbp & (8 >> i))
1655  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1656  ff_vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, 0);
1657  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1658  }
1659  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
1660  } else if (twomv) {
1661  mvbp = v->twomvbp;
1662  dmv_x = dmv_y = 0;
1663  if (mvbp & 2) {
1664  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1665  }
1666  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0);
1667  ff_vc1_mc_4mv_luma(v, 0, 0, 0);
1668  ff_vc1_mc_4mv_luma(v, 1, 0, 0);
1669  dmv_x = dmv_y = 0;
1670  if (mvbp & 1) {
1671  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1672  }
1673  ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0);
1674  ff_vc1_mc_4mv_luma(v, 2, 0, 0);
1675  ff_vc1_mc_4mv_luma(v, 3, 0, 0);
1676  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
1677  } else {
1678  mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
1679  dmv_x = dmv_y = 0;
1680  if (mvbp) {
1681  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
1682  }
1683  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0);
1684  ff_vc1_mc_1mv(v, 0);
1685  }
1686  if (cbp)
1687  GET_MQUANT(); // p. 227
1688  s->current_picture.qscale_table[mb_pos] = mquant;
1689  if (!v->ttmbf && cbp)
1690  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
1691  for (i = 0; i < 6; i++) {
1692  s->dc_val[0][s->block_index[i]] = 0;
1693  dst_idx += i >> 2;
1694  val = ((cbp >> (5 - i)) & 1);
1695  if (!fieldtx)
1696  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1697  else
1698  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
1699  if (val) {
1700  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1701  first_block, s->dest[dst_idx] + off,
1702  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
1703  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
1704  if (pat < 0)
1705  return pat;
1706  block_cbp |= pat << (i << 2);
1707  if (!v->ttmbf && ttmb < 8)
1708  ttmb = -1;
1709  first_block = 0;
1710  }
1711  }
1712  }
1713  } else { // skipped
1714  s->mb_intra = v->is_intra[s->mb_x] = 0;
1715  for (i = 0; i < 6; i++) {
1716  v->mb_type[0][s->block_index[i]] = 0;
1717  s->dc_val[0][s->block_index[i]] = 0;
1718  }
1719  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
1720  s->current_picture.qscale_table[mb_pos] = 0;
1721  v->blk_mv_type[s->block_index[0]] = 0;
1722  v->blk_mv_type[s->block_index[1]] = 0;
1723  v->blk_mv_type[s->block_index[2]] = 0;
1724  v->blk_mv_type[s->block_index[3]] = 0;
1725  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0);
1726  ff_vc1_mc_1mv(v, 0);
1727  v->fieldtx_plane[mb_pos] = 0;
1728  }
1729  if (v->overlap && v->pq >= 9)
1730  ff_vc1_p_overlap_filter(v);
1731  vc1_put_blocks_clamped(v, 1);
1732 
1733  v->cbp[s->mb_x] = block_cbp;
1734  v->ttblk[s->mb_x] = block_tt;
1735 
1736  return 0;
1737 }
1738 
1739 static int vc1_decode_p_mb_intfi(VC1Context *v)
1740 {
1741  MpegEncContext *s = &v->s;
1742  GetBitContext *gb = &s->gb;
1743  int i;
1744  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1745  int cbp = 0; /* cbp decoding stuff */
1746  int mqdiff, mquant; /* MB quantization */
1747  int ttmb = v->ttfrm; /* MB Transform type */
1748 
1749  int mb_has_coeffs = 1; /* last_flag */
1750  int dmv_x, dmv_y; /* Differential MV components */
1751  int val; /* temp values */
1752  int first_block = 1;
1753  int dst_idx, off;
1754  int pred_flag = 0;
1755  int block_cbp = 0, pat, block_tt = 0;
1756  int idx_mbmode = 0;
1757 
1758  mquant = v->pq; /* Lossy initialization */
1759 
1760  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
1761  if (idx_mbmode <= 1) { // intra MB
1762  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
1763  s->mb_intra = 1;
1764  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
1765  s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
1766  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
1767  GET_MQUANT();
1768  s->current_picture.qscale_table[mb_pos] = mquant;
1769  /* Set DC scale - y and c use the same (not sure if necessary here) */
1770  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
1771  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
1772  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
1773  mb_has_coeffs = idx_mbmode & 1;
1774  if (mb_has_coeffs)
1775  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
1776  dst_idx = 0;
1777  for (i = 0; i < 6; i++) {
1778  v->a_avail = v->c_avail = 0;
1779  v->mb_type[0][s->block_index[i]] = 1;
1780  s->dc_val[0][s->block_index[i]] = 0;
1781  dst_idx += i >> 2;
1782  val = ((cbp >> (5 - i)) & 1);
1783  if (i == 2 || i == 3 || !s->first_slice_line)
1784  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1785  if (i == 1 || i == 3 || s->mb_x)
1786  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1787 
1788  vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant,
1789  (i & 4) ? v->codingset2 : v->codingset);
1790  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1791  continue;
1792  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]);
1793  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1794  block_cbp |= 0xf << (i << 2);
1795  }
1796  } else {
1797  s->mb_intra = v->is_intra[s->mb_x] = 0;
1798  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
1799  for (i = 0; i < 6; i++)
1800  v->mb_type[0][s->block_index[i]] = 0;
1801  if (idx_mbmode <= 5) { // 1-MV
1802  dmv_x = dmv_y = pred_flag = 0;
1803  if (idx_mbmode & 1) {
1804  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
1805  }
1806  ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
1807  ff_vc1_mc_1mv(v, 0);
1808  mb_has_coeffs = !(idx_mbmode & 2);
1809  } else { // 4-MV
1810  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
1811  for (i = 0; i < 4; i++) {
1812  dmv_x = dmv_y = pred_flag = 0;
1813  if (v->fourmvbp & (8 >> i))
1814  get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
1815  ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
1816  ff_vc1_mc_4mv_luma(v, i, 0, 0);
1817  }
1818  ff_vc1_mc_4mv_chroma(v, 0);
1819  mb_has_coeffs = idx_mbmode & 1;
1820  }
1821  if (mb_has_coeffs)
1822  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1823  if (cbp) {
1824  GET_MQUANT();
1825  }
1826  s->current_picture.qscale_table[mb_pos] = mquant;
1827  if (!v->ttmbf && cbp) {
1828  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
1829  }
1830  dst_idx = 0;
1831  for (i = 0; i < 6; i++) {
1832  s->dc_val[0][s->block_index[i]] = 0;
1833  dst_idx += i >> 2;
1834  val = ((cbp >> (5 - i)) & 1);
1835  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
1836  if (val) {
1837  pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb,
1838  first_block, s->dest[dst_idx] + off,
1839  (i & 4) ? s->uvlinesize : s->linesize,
1840  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY),
1841  &block_tt);
1842  if (pat < 0)
1843  return pat;
1844  block_cbp |= pat << (i << 2);
1845  if (!v->ttmbf && ttmb < 8)
1846  ttmb = -1;
1847  first_block = 0;
1848  }
1849  }
1850  }
1851  if (v->overlap && v->pq >= 9)
1852  ff_vc1_p_overlap_filter(v);
1853  vc1_put_blocks_clamped(v, 1);
1854 
1855  v->cbp[s->mb_x] = block_cbp;
1856  v->ttblk[s->mb_x] = block_tt;
1857 
1858  return 0;
1859 }
1860 
1861 /** Decode one B-frame MB (in Main profile)
1862  */
1863 static int vc1_decode_b_mb(VC1Context *v)
1864 {
1865  MpegEncContext *s = &v->s;
1866  GetBitContext *gb = &s->gb;
1867  int i, j;
1868  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1869  int cbp = 0; /* cbp decoding stuff */
1870  int mqdiff, mquant; /* MB quantization */
1871  int ttmb = v->ttfrm; /* MB Transform type */
1872  int mb_has_coeffs = 0; /* last_flag */
1873  int index, index1; /* LUT indexes */
1874  int val, sign; /* temp values */
1875  int first_block = 1;
1876  int dst_idx, off;
1877  int skipped, direct;
1878  int dmv_x[2], dmv_y[2];
1879  int bmvtype = BMV_TYPE_BACKWARD;
1880 
1881  mquant = v->pq; /* lossy initialization */
1882  s->mb_intra = 0;
1883 
1884  if (v->dmb_is_raw)
1885  direct = get_bits1(gb);
1886  else
1887  direct = v->direct_mb_plane[mb_pos];
1888  if (v->skip_is_raw)
1889  skipped = get_bits1(gb);
1890  else
1891  skipped = v->s.mbskip_table[mb_pos];
1892 
1893  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
1894  for (i = 0; i < 6; i++) {
1895  v->mb_type[0][s->block_index[i]] = 0;
1896  s->dc_val[0][s->block_index[i]] = 0;
1897  }
1898  s->current_picture.qscale_table[mb_pos] = 0;
1899 
1900  if (!direct) {
1901  if (!skipped) {
1902  GET_MVDATA(dmv_x[0], dmv_y[0]);
1903  dmv_x[1] = dmv_x[0];
1904  dmv_y[1] = dmv_y[0];
1905  }
1906  if (skipped || !s->mb_intra) {
1907  bmvtype = decode012(gb);
1908  switch (bmvtype) {
1909  case 0:
1910  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
1911  break;
1912  case 1:
1913  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
1914  break;
1915  case 2:
1916  bmvtype = BMV_TYPE_INTERPOLATED;
1917  dmv_x[0] = dmv_y[0] = 0;
1918  }
1919  }
1920  }
1921  for (i = 0; i < 6; i++)
1922  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1923 
1924  if (skipped) {
1925  if (direct)
1926  bmvtype = BMV_TYPE_INTERPOLATED;
1927  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1928  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1929  return 0;
1930  }
1931  if (direct) {
1932  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1933  GET_MQUANT();
1934  s->mb_intra = 0;
1935  s->current_picture.qscale_table[mb_pos] = mquant;
1936  if (!v->ttmbf)
1937  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
1938  dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
1939  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1940  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1941  } else {
1942  if (!mb_has_coeffs && !s->mb_intra) {
1943  /* no coded blocks - effectively skipped */
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  if (s->mb_intra && !mb_has_coeffs) {
1949  GET_MQUANT();
1950  s->current_picture.qscale_table[mb_pos] = mquant;
1951  s->ac_pred = get_bits1(gb);
1952  cbp = 0;
1953  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1954  } else {
1955  if (bmvtype == BMV_TYPE_INTERPOLATED) {
1956  GET_MVDATA(dmv_x[0], dmv_y[0]);
1957  if (!mb_has_coeffs) {
1958  /* interpolated skipped block */
1959  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1960  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1961  return 0;
1962  }
1963  }
1964  ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
1965  if (!s->mb_intra) {
1966  vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
1967  }
1968  if (s->mb_intra)
1969  s->ac_pred = get_bits1(gb);
1970  cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
1971  GET_MQUANT();
1972  s->current_picture.qscale_table[mb_pos] = mquant;
1973  if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
1974  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
1975  }
1976  }
1977  dst_idx = 0;
1978  for (i = 0; i < 6; i++) {
1979  s->dc_val[0][s->block_index[i]] = 0;
1980  dst_idx += i >> 2;
1981  val = ((cbp >> (5 - i)) & 1);
1982  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
1983  v->mb_type[0][s->block_index[i]] = s->mb_intra;
1984  if (s->mb_intra) {
1985  /* check if prediction blocks A and C are available */
1986  v->a_avail = v->c_avail = 0;
1987  if (i == 2 || i == 3 || !s->first_slice_line)
1988  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
1989  if (i == 1 || i == 3 || s->mb_x)
1990  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
1991 
1992  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
1993  (i & 4) ? v->codingset2 : v->codingset);
1994  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1995  continue;
1996  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
1997  if (v->rangeredfrm)
1998  for (j = 0; j < 64; j++)
1999  s->block[i][j] *= 2;
2000  s->idsp.put_signed_pixels_clamped(s->block[i],
2001  s->dest[dst_idx] + off,
2002  i & 4 ? s->uvlinesize
2003  : s->linesize);
2004  } else if (val) {
2005  int pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
2006  first_block, s->dest[dst_idx] + off,
2007  (i & 4) ? s->uvlinesize : s->linesize,
2008  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), NULL);
2009  if (pat < 0)
2010  return pat;
2011  if (!v->ttmbf && ttmb < 8)
2012  ttmb = -1;
2013  first_block = 0;
2014  }
2015  }
2016  return 0;
2017 }
2018 
2019 /** Decode one B-frame MB (in interlaced field B picture)
2020  */
2021 static int vc1_decode_b_mb_intfi(VC1Context *v)
2022 {
2023  MpegEncContext *s = &v->s;
2024  GetBitContext *gb = &s->gb;
2025  int i, j;
2026  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2027  int cbp = 0; /* cbp decoding stuff */
2028  int mqdiff, mquant; /* MB quantization */
2029  int ttmb = v->ttfrm; /* MB Transform type */
2030  int mb_has_coeffs = 0; /* last_flag */
2031  int val; /* temp value */
2032  int first_block = 1;
2033  int dst_idx, off;
2034  int fwd;
2035  int dmv_x[2], dmv_y[2], pred_flag[2];
2036  int bmvtype = BMV_TYPE_BACKWARD;
2037  int block_cbp = 0, pat, block_tt = 0;
2038  int idx_mbmode;
2039 
2040  mquant = v->pq; /* Lossy initialization */
2041  s->mb_intra = 0;
2042 
2043  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
2044  if (idx_mbmode <= 1) { // intra MB
2045  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2046  s->mb_intra = 1;
2047  s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
2048  s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
2049  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2050  GET_MQUANT();
2051  s->current_picture.qscale_table[mb_pos] = mquant;
2052  /* Set DC scale - y and c use the same (not sure if necessary here) */
2053  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2054  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2055  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2056  mb_has_coeffs = idx_mbmode & 1;
2057  if (mb_has_coeffs)
2058  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
2059  dst_idx = 0;
2060  for (i = 0; i < 6; i++) {
2061  v->a_avail = v->c_avail = 0;
2062  v->mb_type[0][s->block_index[i]] = 1;
2063  s->dc_val[0][s->block_index[i]] = 0;
2064  dst_idx += i >> 2;
2065  val = ((cbp >> (5 - i)) & 1);
2066  if (i == 2 || i == 3 || !s->first_slice_line)
2067  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2068  if (i == 1 || i == 3 || s->mb_x)
2069  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2070 
2071  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
2072  (i & 4) ? v->codingset2 : v->codingset);
2073  if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2074  continue;
2075  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2076  if (v->rangeredfrm)
2077  for (j = 0; j < 64; j++)
2078  s->block[i][j] <<= 1;
2079  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2080  s->idsp.put_signed_pixels_clamped(s->block[i],
2081  s->dest[dst_idx] + off,
2082  (i & 4) ? s->uvlinesize
2083  : s->linesize);
2084  }
2085  } else {
2086  s->mb_intra = v->is_intra[s->mb_x] = 0;
2087  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
2088  for (i = 0; i < 6; i++)
2089  v->mb_type[0][s->block_index[i]] = 0;
2090  if (v->fmb_is_raw)
2091  fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
2092  else
2093  fwd = v->forward_mb_plane[mb_pos];
2094  if (idx_mbmode <= 5) { // 1-MV
2095  int interpmvp = 0;
2096  dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
2097  pred_flag[0] = pred_flag[1] = 0;
2098  if (fwd)
2099  bmvtype = BMV_TYPE_FORWARD;
2100  else {
2101  bmvtype = decode012(gb);
2102  switch (bmvtype) {
2103  case 0:
2104  bmvtype = BMV_TYPE_BACKWARD;
2105  break;
2106  case 1:
2107  bmvtype = BMV_TYPE_DIRECT;
2108  break;
2109  case 2:
2110  bmvtype = BMV_TYPE_INTERPOLATED;
2111  interpmvp = get_bits1(gb);
2112  }
2113  }
2114  v->bmvtype = bmvtype;
2115  if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
2116  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
2117  }
2118  if (interpmvp) {
2119  get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
2120  }
2121  if (bmvtype == BMV_TYPE_DIRECT) {
2122  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
2123  dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
2124  if (!s->next_picture_ptr->field_picture) {
2125  av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n");
2126  return AVERROR_INVALIDDATA;
2127  }
2128  }
2129  ff_vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
2130  vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
2131  mb_has_coeffs = !(idx_mbmode & 2);
2132  } else { // 4-MV
2133  if (fwd)
2134  bmvtype = BMV_TYPE_FORWARD;
2135  v->bmvtype = bmvtype;
2136  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
2137  for (i = 0; i < 4; i++) {
2138  dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
2139  dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
2140  if (v->fourmvbp & (8 >> i)) {
2141  get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
2142  &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
2143  &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
2144  }
2145  ff_vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
2146  ff_vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0);
2147  }
2148  ff_vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
2149  mb_has_coeffs = idx_mbmode & 1;
2150  }
2151  if (mb_has_coeffs)
2152  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2153  if (cbp) {
2154  GET_MQUANT();
2155  }
2156  s->current_picture.qscale_table[mb_pos] = mquant;
2157  if (!v->ttmbf && cbp) {
2158  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2159  }
2160  dst_idx = 0;
2161  for (i = 0; i < 6; i++) {
2162  s->dc_val[0][s->block_index[i]] = 0;
2163  dst_idx += i >> 2;
2164  val = ((cbp >> (5 - i)) & 1);
2165  off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
2166  if (val) {
2167  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
2168  first_block, s->dest[dst_idx] + off,
2169  (i & 4) ? s->uvlinesize : s->linesize,
2170  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
2171  if (pat < 0)
2172  return pat;
2173  block_cbp |= pat << (i << 2);
2174  if (!v->ttmbf && ttmb < 8)
2175  ttmb = -1;
2176  first_block = 0;
2177  }
2178  }
2179  }
2180  v->cbp[s->mb_x] = block_cbp;
2181  v->ttblk[s->mb_x] = block_tt;
2182 
2183  return 0;
2184 }
2185 
2186 /** Decode one B-frame MB (in interlaced frame B picture)
2187  */
2188 static int vc1_decode_b_mb_intfr(VC1Context *v)
2189 {
2190  MpegEncContext *s = &v->s;
2191  GetBitContext *gb = &s->gb;
2192  int i, j;
2193  int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2194  int cbp = 0; /* cbp decoding stuff */
2195  int mqdiff, mquant; /* MB quantization */
2196  int ttmb = v->ttfrm; /* MB Transform type */
2197  int mvsw = 0; /* motion vector switch */
2198  int mb_has_coeffs = 1; /* last_flag */
2199  int dmv_x, dmv_y; /* Differential MV components */
2200  int val; /* temp value */
2201  int first_block = 1;
2202  int dst_idx, off;
2203  int skipped, direct, twomv = 0;
2204  int block_cbp = 0, pat, block_tt = 0;
2205  int idx_mbmode = 0, mvbp;
2206  int stride_y, fieldtx;
2207  int bmvtype = BMV_TYPE_BACKWARD;
2208  int dir, dir2;
2209 
2210  mquant = v->pq; /* Lossy initialization */
2211  s->mb_intra = 0;
2212  if (v->skip_is_raw)
2213  skipped = get_bits1(gb);
2214  else
2215  skipped = v->s.mbskip_table[mb_pos];
2216 
2217  if (!skipped) {
2218  idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2);
2219  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
2220  twomv = 1;
2221  v->blk_mv_type[s->block_index[0]] = 1;
2222  v->blk_mv_type[s->block_index[1]] = 1;
2223  v->blk_mv_type[s->block_index[2]] = 1;
2224  v->blk_mv_type[s->block_index[3]] = 1;
2225  } else {
2226  v->blk_mv_type[s->block_index[0]] = 0;
2227  v->blk_mv_type[s->block_index[1]] = 0;
2228  v->blk_mv_type[s->block_index[2]] = 0;
2229  v->blk_mv_type[s->block_index[3]] = 0;
2230  }
2231  }
2232 
2233  if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
2234  for (i = 0; i < 4; i++) {
2235  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = 0;
2236  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = 0;
2237  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
2238  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
2239  }
2240  v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1.
2241  s->mb_intra = 1;
2242  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2243  fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
2244  mb_has_coeffs = get_bits1(gb);
2245  if (mb_has_coeffs)
2246  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2247  v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
2248  GET_MQUANT();
2249  s->current_picture.qscale_table[mb_pos] = mquant;
2250  /* Set DC scale - y and c use the same (not sure if necessary here) */
2251  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2252  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2253  dst_idx = 0;
2254  for (i = 0; i < 6; i++) {
2255  v->a_avail = v->c_avail = 0;
2256  v->mb_type[0][s->block_index[i]] = 1;
2257  s->dc_val[0][s->block_index[i]] = 0;
2258  dst_idx += i >> 2;
2259  val = ((cbp >> (5 - i)) & 1);
2260  if (i == 2 || i == 3 || !s->first_slice_line)
2261  v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2262  if (i == 1 || i == 3 || s->mb_x)
2263  v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2264 
2265  vc1_decode_intra_block(v, s->block[i], i, val, mquant,
2266  (i & 4) ? v->codingset2 : v->codingset);
2267  if (CONFIG_GRAY && i > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2268  continue;
2269  v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2270  if (i < 4) {
2271  stride_y = s->linesize << fieldtx;
2272  off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
2273  } else {
2274  stride_y = s->uvlinesize;
2275  off = 0;
2276  }
2277  s->idsp.put_signed_pixels_clamped(s->block[i],
2278  s->dest[dst_idx] + off,
2279  stride_y);
2280  }
2281  } else {
2282  s->mb_intra = v->is_intra[s->mb_x] = 0;
2283 
2284  if (v->dmb_is_raw)
2285  direct = get_bits1(gb);
2286  else
2287  direct = v->direct_mb_plane[mb_pos];
2288 
2289  if (direct) {
2290  if (s->next_picture_ptr->field_picture)
2291  av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
2292  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);
2293  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);
2294  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);
2295  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);
2296 
2297  if (twomv) {
2298  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);
2299  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);
2300  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);
2301  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);
2302 
2303  for (i = 1; i < 4; i += 2) {
2304  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0];
2305  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1];
2306  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0];
2307  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1];
2308  }
2309  } else {
2310  for (i = 1; i < 4; i++) {
2311  s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0];
2312  s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1];
2313  s->mv[1][i][0] = s->current_picture.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0];
2314  s->mv[1][i][1] = s->current_picture.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1];
2315  }
2316  }
2317  }
2318 
2319  if (!direct) {
2320  if (skipped || !s->mb_intra) {
2321  bmvtype = decode012(gb);
2322  switch (bmvtype) {
2323  case 0:
2324  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
2325  break;
2326  case 1:
2327  bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
2328  break;
2329  case 2:
2330  bmvtype = BMV_TYPE_INTERPOLATED;
2331  }
2332  }
2333 
2334  if (twomv && bmvtype != BMV_TYPE_INTERPOLATED)
2335  mvsw = get_bits1(gb);
2336  }
2337 
2338  if (!skipped) { // inter MB
2339  mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3];
2340  if (mb_has_coeffs)
2341  cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2342  if (!direct) {
2343  if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) {
2344  v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
2345  } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) {
2346  v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
2347  }
2348  }
2349 
2350  for (i = 0; i < 6; i++)
2351  v->mb_type[0][s->block_index[i]] = 0;
2352  fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1];
2353  /* for all motion vector read MVDATA and motion compensate each block */
2354  dst_idx = 0;
2355  if (direct) {
2356  if (twomv) {
2357  for (i = 0; i < 4; i++) {
2358  ff_vc1_mc_4mv_luma(v, i, 0, 0);
2359  ff_vc1_mc_4mv_luma(v, i, 1, 1);
2360  }
2361  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
2362  ff_vc1_mc_4mv_chroma4(v, 1, 1, 1);
2363  } else {
2364  ff_vc1_mc_1mv(v, 0);
2365  ff_vc1_interp_mc(v);
2366  }
2367  } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) {
2368  mvbp = v->fourmvbp;
2369  for (i = 0; i < 4; i++) {
2370  dir = i==1 || i==3;
2371  dmv_x = dmv_y = 0;
2372  val = ((mvbp >> (3 - i)) & 1);
2373  if (val)
2374  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2375  j = i > 1 ? 2 : 0;
2376  ff_vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir);
2377  ff_vc1_mc_4mv_luma(v, j, dir, dir);
2378  ff_vc1_mc_4mv_luma(v, j+1, dir, dir);
2379  }
2380 
2381  ff_vc1_mc_4mv_chroma4(v, 0, 0, 0);
2382  ff_vc1_mc_4mv_chroma4(v, 1, 1, 1);
2383  } else if (bmvtype == BMV_TYPE_INTERPOLATED) {
2384  mvbp = v->twomvbp;
2385  dmv_x = dmv_y = 0;
2386  if (mvbp & 2)
2387  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2388 
2389  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0);
2390  ff_vc1_mc_1mv(v, 0);
2391 
2392  dmv_x = dmv_y = 0;
2393  if (mvbp & 1)
2394  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2395 
2396  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 1);
2397  ff_vc1_interp_mc(v);
2398  } else if (twomv) {
2399  dir = bmvtype == BMV_TYPE_BACKWARD;
2400  dir2 = dir;
2401  if (mvsw)
2402  dir2 = !dir;
2403  mvbp = v->twomvbp;
2404  dmv_x = dmv_y = 0;
2405  if (mvbp & 2)
2406  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2407  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir);
2408 
2409  dmv_x = dmv_y = 0;
2410  if (mvbp & 1)
2411  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2412  ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir2);
2413 
2414  if (mvsw) {
2415  for (i = 0; i < 2; i++) {
2416  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];
2417  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];
2418  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];
2419  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];
2420  }
2421  } else {
2422  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2423  ff_vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, !dir);
2424  }
2425 
2426  ff_vc1_mc_4mv_luma(v, 0, dir, 0);
2427  ff_vc1_mc_4mv_luma(v, 1, dir, 0);
2428  ff_vc1_mc_4mv_luma(v, 2, dir2, 0);
2429  ff_vc1_mc_4mv_luma(v, 3, dir2, 0);
2430  ff_vc1_mc_4mv_chroma4(v, dir, dir2, 0);
2431  } else {
2432  dir = bmvtype == BMV_TYPE_BACKWARD;
2433 
2434  mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2];
2435  dmv_x = dmv_y = 0;
2436  if (mvbp)
2437  get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
2438 
2439  ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, dir);
2440  v->blk_mv_type[s->block_index[0]] = 1;
2441  v->blk_mv_type[s->block_index[1]] = 1;
2442  v->blk_mv_type[s->block_index[2]] = 1;
2443  v->blk_mv_type[s->block_index[3]] = 1;
2444  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2445  for (i = 0; i < 2; i++) {
2446  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];
2447  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];
2448  }
2449  ff_vc1_mc_1mv(v, dir);
2450  }
2451 
2452  if (cbp)
2453  GET_MQUANT(); // p. 227
2454  s->current_picture.qscale_table[mb_pos] = mquant;
2455  if (!v->ttmbf && cbp)
2456  ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2457  for (i = 0; i < 6; i++) {
2458  s->dc_val[0][s->block_index[i]] = 0;
2459  dst_idx += i >> 2;
2460  val = ((cbp >> (5 - i)) & 1);
2461  if (!fieldtx)
2462  off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2463  else
2464  off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
2465  if (val) {
2466  pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
2467  first_block, s->dest[dst_idx] + off,
2468  (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
2469  CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt);
2470  if (pat < 0)
2471  return pat;
2472  block_cbp |= pat << (i << 2);
2473  if (!v->ttmbf && ttmb < 8)
2474  ttmb = -1;
2475  first_block = 0;
2476  }
2477  }
2478 
2479  } else { // skipped
2480  dir = 0;
2481  for (i = 0; i < 6; i++) {
2482  v->mb_type[0][s->block_index[i]] = 0;
2483  s->dc_val[0][s->block_index[i]] = 0;
2484  }
2485  s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2486  s->current_picture.qscale_table[mb_pos] = 0;
2487  v->blk_mv_type[s->block_index[0]] = 0;
2488  v->blk_mv_type[s->block_index[1]] = 0;
2489  v->blk_mv_type[s->block_index[2]] = 0;
2490  v->blk_mv_type[s->block_index[3]] = 0;
2491 
2492  if (!direct) {
2493  if (bmvtype == BMV_TYPE_INTERPOLATED) {
2494  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0);
2495  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 1);
2496  } else {
2497  dir = bmvtype == BMV_TYPE_BACKWARD;
2498  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, dir);
2499  if (mvsw) {
2500  int dir2 = dir;
2501  if (mvsw)
2502  dir2 = !dir;
2503  for (i = 0; i < 2; i++) {
2504  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];
2505  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];
2506  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];
2507  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];
2508  }
2509  } else {
2510  v->blk_mv_type[s->block_index[0]] = 1;
2511  v->blk_mv_type[s->block_index[1]] = 1;
2512  v->blk_mv_type[s->block_index[2]] = 1;
2513  v->blk_mv_type[s->block_index[3]] = 1;
2514  ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir);
2515  for (i = 0; i < 2; i++) {
2516  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];
2517  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];
2518  }
2519  }
2520  }
2521  }
2522 
2523  ff_vc1_mc_1mv(v, dir);
2524  if (direct || bmvtype == BMV_TYPE_INTERPOLATED) {
2525  ff_vc1_interp_mc(v);
2526  }
2527  v->fieldtx_plane[mb_pos] = 0;
2528  }
2529  }
2530  v->cbp[s->mb_x] = block_cbp;
2531  v->ttblk[s->mb_x] = block_tt;
2532 
2533  return 0;
2534 }
2535 
2536 /** Decode blocks of I-frame
2537  */
2538 static void vc1_decode_i_blocks(VC1Context *v)
2539 {
2540  int k, j;
2541  MpegEncContext *s = &v->s;
2542  int cbp, val;
2543  uint8_t *coded_val;
2544  int mb_pos;
2545 
2546  /* select coding mode used for VLC tables selection */
2547  switch (v->y_ac_table_index) {
2548  case 0:
2549  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2550  break;
2551  case 1:
2552  v->codingset = CS_HIGH_MOT_INTRA;
2553  break;
2554  case 2:
2555  v->codingset = CS_MID_RATE_INTRA;
2556  break;
2557  }
2558 
2559  switch (v->c_ac_table_index) {
2560  case 0:
2561  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2562  break;
2563  case 1:
2564  v->codingset2 = CS_HIGH_MOT_INTER;
2565  break;
2566  case 2:
2567  v->codingset2 = CS_MID_RATE_INTER;
2568  break;
2569  }
2570 
2571  /* Set DC scale - y and c use the same */
2572  s->y_dc_scale = s->y_dc_scale_table[v->pq];
2573  s->c_dc_scale = s->c_dc_scale_table[v->pq];
2574 
2575  //do frame decode
2576  s->mb_x = s->mb_y = 0;
2577  s->mb_intra = 1;
2578  s->first_slice_line = 1;
2579  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2580  s->mb_x = 0;
2581  init_block_index(v);
2582  for (; s->mb_x < v->end_mb_x; s->mb_x++) {
2583  update_block_index(s);
2584  s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2585  mb_pos = s->mb_x + s->mb_y * s->mb_width;
2586  s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2587  s->current_picture.qscale_table[mb_pos] = v->pq;
2588  for (int i = 0; i < 4; i++) {
2589  s->current_picture.motion_val[1][s->block_index[i]][0] = 0;
2590  s->current_picture.motion_val[1][s->block_index[i]][1] = 0;
2591  }
2592 
2593  // do actual MB decoding and displaying
2594  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table,
2595  MSMP4_MB_INTRA_VLC_BITS, 2);
2596  v->s.ac_pred = get_bits1(&v->s.gb);
2597 
2598  for (k = 0; k < 6; k++) {
2599  v->mb_type[0][s->block_index[k]] = 1;
2600 
2601  val = ((cbp >> (5 - k)) & 1);
2602 
2603  if (k < 4) {
2604  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2605  val = val ^ pred;
2606  *coded_val = val;
2607  }
2608  cbp |= val << (5 - k);
2609 
2610  vc1_decode_i_block(v, v->block[v->cur_blk_idx][block_map[k]], k, val, (k < 4) ? v->codingset : v->codingset2);
2611 
2612  if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2613  continue;
2614  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[k]]);
2615  }
2616 
2617  if (v->overlap && v->pq >= 9) {
2618  ff_vc1_i_overlap_filter(v);
2619  if (v->rangeredfrm)
2620  for (k = 0; k < 6; k++)
2621  for (j = 0; j < 64; j++)
2622  v->block[v->cur_blk_idx][block_map[k]][j] *= 2;
2623  vc1_put_blocks_clamped(v, 1);
2624  } else {
2625  if (v->rangeredfrm)
2626  for (k = 0; k < 6; k++)
2627  for (j = 0; j < 64; j++)
2628  v->block[v->cur_blk_idx][block_map[k]][j] = (v->block[v->cur_blk_idx][block_map[k]][j] - 64) * 2;
2629  vc1_put_blocks_clamped(v, 0);
2630  }
2631 
2632  if (v->s.loop_filter)
2633  ff_vc1_i_loop_filter(v);
2634 
2635  if (get_bits_left(&s->gb) < 0) {
2636  ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
2637  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2638  get_bits_count(&s->gb), s->gb.size_in_bits);
2639  return;
2640  }
2641 
2642  v->topleft_blk_idx = (v->topleft_blk_idx + 1) % (v->end_mb_x + 2);
2643  v->top_blk_idx = (v->top_blk_idx + 1) % (v->end_mb_x + 2);
2644  v->left_blk_idx = (v->left_blk_idx + 1) % (v->end_mb_x + 2);
2645  v->cur_blk_idx = (v->cur_blk_idx + 1) % (v->end_mb_x + 2);
2646  }
2647 
2648  s->first_slice_line = 0;
2649  }
2650 
2651  /* This is intentionally mb_height and not end_mb_y - unlike in advanced
2652  * profile, these only differ are when decoding MSS2 rectangles. */
2653  ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
2654 }
2655 
2656 /** Decode blocks of I-frame for advanced profile
2657  */
2658 static int vc1_decode_i_blocks_adv(VC1Context *v)
2659 {
2660  int k;
2661  MpegEncContext *s = &v->s;
2662  int cbp, val;
2663  uint8_t *coded_val;
2664  int mb_pos;
2665  int mquant;
2666  int mqdiff;
2667  GetBitContext *gb = &s->gb;
2668 
2669  if (get_bits_left(gb) <= 1)
2670  return AVERROR_INVALIDDATA;
2671 
2672  /* select coding mode used for VLC tables selection */
2673  switch (v->y_ac_table_index) {
2674  case 0:
2675  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2676  break;
2677  case 1:
2678  v->codingset = CS_HIGH_MOT_INTRA;
2679  break;
2680  case 2:
2681  v->codingset = CS_MID_RATE_INTRA;
2682  break;
2683  }
2684 
2685  switch (v->c_ac_table_index) {
2686  case 0:
2687  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2688  break;
2689  case 1:
2690  v->codingset2 = CS_HIGH_MOT_INTER;
2691  break;
2692  case 2:
2693  v->codingset2 = CS_MID_RATE_INTER;
2694  break;
2695  }
2696 
2697  // do frame decode
2698  s->mb_x = s->mb_y = 0;
2699  s->mb_intra = 1;
2700  s->first_slice_line = 1;
2701  s->mb_y = s->start_mb_y;
2702  if (s->start_mb_y) {
2703  s->mb_x = 0;
2704  init_block_index(v);
2705  memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
2706  (1 + s->b8_stride) * sizeof(*s->coded_block));
2707  }
2708  for (; s->mb_y < s->end_mb_y; s->mb_y++) {
2709  s->mb_x = 0;
2710  init_block_index(v);
2711  for (;s->mb_x < s->mb_width; s->mb_x++) {
2712  mquant = v->pq;
2713  update_block_index(s);
2714  s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]);
2715  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2716  s->current_picture.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
2717  for (int i = 0; i < 4; i++) {
2718  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = 0;
2719  s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = 0;
2720  }
2721 
2722  // do actual MB decoding and displaying
2723  if (v->fieldtx_is_raw)
2724  v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
2725  if (get_bits_left(&v->s.gb) <= 1) {
2726  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2727  return 0;
2728  }
2729 
2730  cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table,
2731  MSMP4_MB_INTRA_VLC_BITS, 2);
2732  if (v->acpred_is_raw)
2733  v->s.ac_pred = get_bits1(&v->s.gb);
2734  else
2735  v->s.ac_pred = v->acpred_plane[mb_pos];
2736 
2737  if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
2738  v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
2739 
2740  GET_MQUANT();
2741 
2742  s->current_picture.qscale_table[mb_pos] = mquant;
2743  /* Set DC scale - y and c use the same */
2744  s->y_dc_scale = s->y_dc_scale_table[FFABS(mquant)];
2745  s->c_dc_scale = s->c_dc_scale_table[FFABS(mquant)];
2746 
2747  for (k = 0; k < 6; k++) {
2748  v->mb_type[0][s->block_index[k]] = 1;
2749 
2750  val = ((cbp >> (5 - k)) & 1);
2751 
2752  if (k < 4) {
2753  int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2754  val = val ^ pred;
2755  *coded_val = val;
2756  }
2757  cbp |= val << (5 - k);
2758 
2759  v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
2760  v->c_avail = !!s->mb_x || (k == 1 || k == 3);
2761 
2762  vc1_decode_i_block_adv(v, v->block[v->cur_blk_idx][block_map[k]], k, val,
2763  (k < 4) ? v->codingset : v->codingset2, mquant);
2764 
2765  if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
2766  continue;
2767  v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[k]]);
2768  }
2769 
2770  if (v->overlap && (v->pq >= 9 || v->condover != CONDOVER_NONE))
2771  ff_vc1_i_overlap_filter(v);
2772  vc1_put_blocks_clamped(v, 1);
2773  if (v->s.loop_filter)
2774  ff_vc1_i_loop_filter(v);
2775 
2776  if (get_bits_left(&s->gb) < 0) {
2777  // TODO: may need modification to handle slice coding
2778  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2779  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
2780  get_bits_count(&s->gb), s->gb.size_in_bits);
2781  return 0;
2782  }
2783  inc_blk_idx(v->topleft_blk_idx);
2784  inc_blk_idx(v->top_blk_idx);
2785  inc_blk_idx(v->left_blk_idx);
2786  inc_blk_idx(v->cur_blk_idx);
2787  }
2788  s->first_slice_line = 0;
2789  }
2790 
2791  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2792  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2793  return 0;
2794 }
2795 
2796 static void vc1_decode_p_blocks(VC1Context *v)
2797 {
2798  MpegEncContext *s = &v->s;
2799  int apply_loop_filter;
2800 
2801  /* select coding mode used for VLC tables selection */
2802  switch (v->c_ac_table_index) {
2803  case 0:
2804  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2805  break;
2806  case 1:
2807  v->codingset = CS_HIGH_MOT_INTRA;
2808  break;
2809  case 2:
2810  v->codingset = CS_MID_RATE_INTRA;
2811  break;
2812  }
2813 
2814  switch (v->c_ac_table_index) {
2815  case 0:
2816  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2817  break;
2818  case 1:
2819  v->codingset2 = CS_HIGH_MOT_INTER;
2820  break;
2821  case 2:
2822  v->codingset2 = CS_MID_RATE_INTER;
2823  break;
2824  }
2825 
2826  apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
2827  s->first_slice_line = 1;
2828  memset(v->cbp_base, 0, sizeof(v->cbp_base[0]) * 3 * s->mb_stride);
2829  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2830  s->mb_x = 0;
2831  init_block_index(v);
2832  for (; s->mb_x < s->mb_width; s->mb_x++) {
2833  update_block_index(s);
2834 
2835  if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw)
2836  if (get_bits_left(&v->s.gb) <= 1) {
2837  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2838  return;
2839  }
2840 
2841  if (v->fcm == ILACE_FIELD) {
2842  vc1_decode_p_mb_intfi(v);
2843  if (apply_loop_filter)
2844  ff_vc1_p_loop_filter(v);
2845  } else if (v->fcm == ILACE_FRAME) {
2846  vc1_decode_p_mb_intfr(v);
2847  if (apply_loop_filter)
2848  ff_vc1_p_intfr_loop_filter(v);
2849  } else {
2850  vc1_decode_p_mb(v);
2851  if (apply_loop_filter)
2852  ff_vc1_p_loop_filter(v);
2853  }
2854  if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
2855  // TODO: may need modification to handle slice coding
2856  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2857  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
2858  get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
2859  return;
2860  }
2861  inc_blk_idx(v->topleft_blk_idx);
2862  inc_blk_idx(v->top_blk_idx);
2863  inc_blk_idx(v->left_blk_idx);
2864  inc_blk_idx(v->cur_blk_idx);
2865  }
2866  memmove(v->cbp_base,
2867  v->cbp - s->mb_stride,
2868  sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
2869  memmove(v->ttblk_base,
2870  v->ttblk - s->mb_stride,
2871  sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
2872  memmove(v->is_intra_base,
2873  v->is_intra - s->mb_stride,
2874  sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
2875  memmove(v->luma_mv_base,
2876  v->luma_mv - s->mb_stride,
2877  sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
2878  s->first_slice_line = 0;
2879  }
2880  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2881  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2882 }
2883 
2884 static void vc1_decode_b_blocks(VC1Context *v)
2885 {
2886  MpegEncContext *s = &v->s;
2887 
2888  /* select coding mode used for VLC tables selection */
2889  switch (v->c_ac_table_index) {
2890  case 0:
2891  v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2892  break;
2893  case 1:
2894  v->codingset = CS_HIGH_MOT_INTRA;
2895  break;
2896  case 2:
2897  v->codingset = CS_MID_RATE_INTRA;
2898  break;
2899  }
2900 
2901  switch (v->c_ac_table_index) {
2902  case 0:
2903  v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2904  break;
2905  case 1:
2906  v->codingset2 = CS_HIGH_MOT_INTER;
2907  break;
2908  case 2:
2909  v->codingset2 = CS_MID_RATE_INTER;
2910  break;
2911  }
2912 
2913  s->first_slice_line = 1;
2914  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2915  s->mb_x = 0;
2916  init_block_index(v);
2917  for (; s->mb_x < s->mb_width; s->mb_x++) {
2918  update_block_index(s);
2919 
2920  if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw)
2921  if (get_bits_left(&v->s.gb) <= 1) {
2922  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2923  return;
2924  }
2925 
2926  if (v->fcm == ILACE_FIELD) {
2927  vc1_decode_b_mb_intfi(v);
2928  if (v->s.loop_filter)
2929  ff_vc1_b_intfi_loop_filter(v);
2930  } else if (v->fcm == ILACE_FRAME) {
2931  vc1_decode_b_mb_intfr(v);
2932  if (v->s.loop_filter)
2933  ff_vc1_p_intfr_loop_filter(v);
2934  } else {
2935  vc1_decode_b_mb(v);
2936  if (v->s.loop_filter)
2937  ff_vc1_i_loop_filter(v);
2938  }
2939  if (get_bits_left(&s->gb) < 0 || get_bits_count(&s->gb) < 0) {
2940  // TODO: may need modification to handle slice coding
2941  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
2942  av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
2943  get_bits_count(&s->gb), s->gb.size_in_bits, s->mb_x, s->mb_y);
2944  return;
2945  }
2946  }
2947  memmove(v->cbp_base,
2948  v->cbp - s->mb_stride,
2949  sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
2950  memmove(v->ttblk_base,
2951  v->ttblk - s->mb_stride,
2952  sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
2953  memmove(v->is_intra_base,
2954  v->is_intra - s->mb_stride,
2955  sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
2956  s->first_slice_line = 0;
2957  }
2958  ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
2959  (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
2960 }
2961 
2962 static void vc1_decode_skip_blocks(VC1Context *v)
2963 {
2964  MpegEncContext *s = &v->s;
2965 
2966  if (!v->s.last_picture.f->data[0])
2967  return;
2968 
2969  ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
2970  s->first_slice_line = 1;
2971  for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2972  s->mb_x = 0;
2973  init_block_index(v);
2974  update_block_index(s);
2975  memcpy(s->dest[0], s->last_picture.f->data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
2976  memcpy(s->dest[1], s->last_picture.f->data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2977  memcpy(s->dest[2], s->last_picture.f->data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
2978  s->first_slice_line = 0;
2979  }
2980 }
2981 
2982 void ff_vc1_decode_blocks(VC1Context *v)
2983 {
2984 
2985  v->s.esc3_level_length = 0;
2986  if (v->x8_type) {
2987  ff_intrax8_decode_picture(&v->x8, &v->s.current_picture,
2988  &v->s.gb, &v->s.mb_x, &v->s.mb_y,
2989  2 * v->pq + v->halfpq, v->pq * !v->pquantizer,
2990  v->s.loop_filter, v->s.low_delay);
2991 
2992  ff_er_add_slice(&v->s.er, 0, 0,
2993  (v->s.mb_x >> 1) - 1, (v->s.mb_y >> 1) - 1,
2994  ER_MB_END);
2995  } else {
2996  v->cur_blk_idx = 0;
2997  v->left_blk_idx = -1;
2998  v->topleft_blk_idx = 1;
2999  v->top_blk_idx = 2;
3000  switch (v->s.pict_type) {
3001  case AV_PICTURE_TYPE_I:
3002  if (v->profile == PROFILE_ADVANCED)
3003  vc1_decode_i_blocks_adv(v);
3004  else
3005  vc1_decode_i_blocks(v);
3006  break;
3007  case AV_PICTURE_TYPE_P:
3008  if (v->p_frame_skipped)
3009  vc1_decode_skip_blocks(v);
3010  else
3011  vc1_decode_p_blocks(v);
3012  break;
3013  case AV_PICTURE_TYPE_B:
3014  if (v->bi_type) {
3015  if (v->profile == PROFILE_ADVANCED)
3016  vc1_decode_i_blocks_adv(v);
3017  else
3018  vc1_decode_i_blocks(v);
3019  } else
3020  vc1_decode_b_blocks(v);
3021  break;
3022  }
3023  }
3024 }
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:1125
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:664
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:426
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:119
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:2796
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:256
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:170
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
ff_vc1_ttblk_vlc
VLC ff_vc1_ttblk_vlc[3]
Definition: vc1data.c:115
ff_msmp4_dc_luma_vlc
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4_vc1_data.c:36
ff_msmp4_mb_i_vlc
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4_vc1_data.c:35
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
table
static const uint16_t table[]
Definition: prosumer.c:205
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:848
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:1529
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:351
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:325
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:202
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:738
CS_LOW_MOT_INTER
@ CS_LOW_MOT_INTER
Definition: vc1.h:127
GetBitContext
Definition: get_bits.h:107
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:77
MV_PMODE_INTFR_2MV_FIELD
@ MV_PMODE_INTFR_2MV_FIELD
Definition: vc1.h:91
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
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
ff_vc1_decode_blocks
void ff_vc1_decode_blocks(VC1Context *v)
Definition: vc1_block.c:2982
CONDOVER_NONE
@ CONDOVER_NONE
Definition: vc1.h:137
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
ff_msmp4_dc_chroma_vlc
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4_vc1_data.c:37
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:256
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::imv_vlc
VLC * imv_vlc
Definition: vc1.h:338
VC1Context::x8
IntraX8Context x8
Definition: vc1.h:175
vc1_decode_b_blocks
static void vc1_decode_b_blocks(VC1Context *v)
Definition: vc1_block.c:2884
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:37
PROFILE_ADVANCED
@ PROFILE_ADVANCED
Definition: vc1_common.h:52
MpegEncContext::loop_filter
int loop_filter
Definition: mpegvideo.h:368
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:723
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
size_table
static const uint8_t size_table[6]
Definition: vc1_block.c:1293
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:64
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:389
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:1739
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:2021
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:1863
MpegEncContext::mb_y
int mb_y
Definition: mpegvideo.h:284
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:421
VC1Context::a_avail
int a_avail
Definition: vc1.h:261
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:38
VC1Context::block
int16_t(* block)[6][64]
Definition: vc1.h:386
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:378
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::vc1dsp
VC1DSPContext vc1dsp
Definition: vc1.h:177
VC1Context::twomvbp_vlc
VLC * twomvbp_vlc
Definition: vc1.h:339
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:631
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
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:75
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:301
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:595
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
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:187
VC1Context::mbmode_vlc
VLC * mbmode_vlc
Definition: vc1.h:337
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
ff_vc1_ttmb_vlc
VLC ff_vc1_ttmb_vlc[3]
Definition: vc1data.c:109
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:1796
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:269
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:420
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:284
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
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:522
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::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:916
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_ac_coeff_table
VLC ff_vc1_ac_coeff_table[8]
Definition: vc1data.c:124
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:1297
VC1Context::p_frame_skipped
int p_frame_skipped
Definition: vc1.h:382
ff_vc1_subblkpat_vlc
VLC ff_vc1_subblkpat_vlc[3]
Definition: vc1data.c:116
vc1_last_delta_run_table
static const uint8_t vc1_last_delta_run_table[AC_MODES][10]
Definition: vc1acdata.h:339
VC1Context::cbpcy_vlc
VLC * cbpcy_vlc
CBPCY VLC table.
Definition: vc1.h:282
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:276
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:2962
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:2538
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:152
VLC::table
VLCElem * table
Definition: vlc.h:33
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:275
VC1Context::mv_type_is_raw
int mv_type_is_raw
mv type mb plane is not coded
Definition: vc1.h:287
msmpeg4_vc1_data.h
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:39
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
VC1Context::fourmvbp_vlc
VLC * fourmvbp_vlc
Definition: vc1.h:340
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:2658
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:2188
VC1Context::blocks_off
int blocks_off
Definition: vc1.h:361
TT_4X4
@ TT_4X4
Definition: vc1.h:119
int
int
Definition: ffmpeg_filter.c:156
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
Generated on Tue Feb 28 2023 21:33:41 for FFmpeg by   doxygen 1.8.17