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