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