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