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