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