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