vc1.c
Go to the documentation of this file.
1 /*
2  * VC-1 and WMV3 decoder common code
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of Libav.
8  *
9  * Libav is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * Libav is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with Libav; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
30 #include "internal.h"
31 #include "dsputil.h"
32 #include "avcodec.h"
33 #include "mpegvideo.h"
34 #include "vc1.h"
35 #include "vc1data.h"
36 #include "msmpeg4data.h"
37 #include "unary.h"
38 #include "simple_idct.h"
39 
40 #undef NDEBUG
41 #include <assert.h>
42 
43 /***********************************************************************/
54 enum Imode {
62 }; //imode defines
64 
71 static void decode_rowskip(uint8_t* plane, int width, int height, int stride,
72  GetBitContext *gb)
73 {
74  int x, y;
75 
76  for (y = 0; y < height; y++) {
77  if (!get_bits1(gb)) //rowskip
78  memset(plane, 0, width);
79  else
80  for (x = 0; x < width; x++)
81  plane[x] = get_bits1(gb);
82  plane += stride;
83  }
84 }
85 
93 static void decode_colskip(uint8_t* plane, int width, int height, int stride,
94  GetBitContext *gb)
95 {
96  int x, y;
97 
98  for (x = 0; x < width; x++) {
99  if (!get_bits1(gb)) //colskip
100  for (y = 0; y < height; y++)
101  plane[y*stride] = 0;
102  else
103  for (y = 0; y < height; y++)
104  plane[y*stride] = get_bits1(gb);
105  plane ++;
106  }
107 }
108 
116 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
117 {
118  GetBitContext *gb = &v->s.gb;
119 
120  int imode, x, y, code, offset;
121  uint8_t invert, *planep = data;
122  int width, height, stride;
123 
124  width = v->s.mb_width;
125  height = v->s.mb_height >> v->field_mode;
126  stride = v->s.mb_stride;
127  invert = get_bits1(gb);
129 
130  *raw_flag = 0;
131  switch (imode) {
132  case IMODE_RAW:
133  //Data is actually read in the MB layer (same for all tests == "raw")
134  *raw_flag = 1; //invert ignored
135  return invert;
136  case IMODE_DIFF2:
137  case IMODE_NORM2:
138  if ((height * width) & 1) {
139  *planep++ = get_bits1(gb);
140  offset = 1;
141  }
142  else
143  offset = 0;
144  // decode bitplane as one long line
145  for (y = offset; y < height * width; y += 2) {
147  *planep++ = code & 1;
148  offset++;
149  if (offset == width) {
150  offset = 0;
151  planep += stride - width;
152  }
153  *planep++ = code >> 1;
154  offset++;
155  if (offset == width) {
156  offset = 0;
157  planep += stride - width;
158  }
159  }
160  break;
161  case IMODE_DIFF6:
162  case IMODE_NORM6:
163  if (!(height % 3) && (width % 3)) { // use 2x3 decoding
164  for (y = 0; y < height; y += 3) {
165  for (x = width & 1; x < width; x += 2) {
167  if (code < 0) {
168  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
169  return -1;
170  }
171  planep[x + 0] = (code >> 0) & 1;
172  planep[x + 1] = (code >> 1) & 1;
173  planep[x + 0 + stride] = (code >> 2) & 1;
174  planep[x + 1 + stride] = (code >> 3) & 1;
175  planep[x + 0 + stride * 2] = (code >> 4) & 1;
176  planep[x + 1 + stride * 2] = (code >> 5) & 1;
177  }
178  planep += stride * 3;
179  }
180  if (width & 1)
181  decode_colskip(data, 1, height, stride, &v->s.gb);
182  } else { // 3x2
183  planep += (height & 1) * stride;
184  for (y = height & 1; y < height; y += 2) {
185  for (x = width % 3; x < width; x += 3) {
187  if (code < 0) {
188  av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
189  return -1;
190  }
191  planep[x + 0] = (code >> 0) & 1;
192  planep[x + 1] = (code >> 1) & 1;
193  planep[x + 2] = (code >> 2) & 1;
194  planep[x + 0 + stride] = (code >> 3) & 1;
195  planep[x + 1 + stride] = (code >> 4) & 1;
196  planep[x + 2 + stride] = (code >> 5) & 1;
197  }
198  planep += stride * 2;
199  }
200  x = width % 3;
201  if (x)
202  decode_colskip(data, x, height, stride, &v->s.gb);
203  if (height & 1)
204  decode_rowskip(data + x, width - x, 1, stride, &v->s.gb);
205  }
206  break;
207  case IMODE_ROWSKIP:
208  decode_rowskip(data, width, height, stride, &v->s.gb);
209  break;
210  case IMODE_COLSKIP:
211  decode_colskip(data, width, height, stride, &v->s.gb);
212  break;
213  default:
214  break;
215  }
216 
217  /* Applying diff operator */
218  if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
219  planep = data;
220  planep[0] ^= invert;
221  for (x = 1; x < width; x++)
222  planep[x] ^= planep[x-1];
223  for (y = 1; y < height; y++) {
224  planep += stride;
225  planep[0] ^= planep[-stride];
226  for (x = 1; x < width; x++) {
227  if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
228  else planep[x] ^= planep[x-1];
229  }
230  }
231  } else if (invert) {
232  planep = data;
233  for (x = 0; x < stride * height; x++)
234  planep[x] = !planep[x]; //FIXME stride
235  }
236  return (imode << 1) + invert;
237 }
238  //Bitplane group
240 
241 /***********************************************************************/
246 {
247  GetBitContext *gb = &v->s.gb;
248  int pqdiff;
249 
250  //variable size
251  if (v->dquant == 2) {
252  pqdiff = get_bits(gb, 3);
253  if (pqdiff == 7)
254  v->altpq = get_bits(gb, 5);
255  else
256  v->altpq = v->pq + pqdiff + 1;
257  } else {
258  v->dquantfrm = get_bits1(gb);
259  if (v->dquantfrm) {
260  v->dqprofile = get_bits(gb, 2);
261  switch (v->dqprofile) {
264  v->dqsbedge = get_bits(gb, 2);
265  break;
266  case DQPROFILE_ALL_MBS:
267  v->dqbilevel = get_bits1(gb);
268  if (!v->dqbilevel)
269  v->halfpq = 0;
270  default:
271  break; //Forbidden ?
272  }
273  if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS) {
274  pqdiff = get_bits(gb, 3);
275  if (pqdiff == 7)
276  v->altpq = get_bits(gb, 5);
277  else
278  v->altpq = v->pq + pqdiff + 1;
279  }
280  }
281  }
282  return 0;
283 }
284 
286 
295 {
296  av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
297  v->profile = get_bits(gb, 2);
298  if (v->profile == PROFILE_COMPLEX) {
299  av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");
300  }
301 
302  if (v->profile == PROFILE_ADVANCED) {
305  return decode_sequence_header_adv(v, gb);
306  } else {
307  v->zz_8x4 = wmv2_scantableA;
308  v->zz_4x8 = wmv2_scantableB;
309  v->res_y411 = get_bits1(gb);
310  v->res_sprite = get_bits1(gb);
311  if (v->res_y411) {
312  av_log(avctx, AV_LOG_ERROR,
313  "Old interlaced mode is not supported\n");
314  return -1;
315  }
316  }
317 
318  // (fps-2)/4 (->30)
319  v->frmrtq_postproc = get_bits(gb, 3); //common
320  // (bitrate-32kbps)/64kbps
321  v->bitrtq_postproc = get_bits(gb, 5); //common
322  v->s.loop_filter = get_bits1(gb); //common
323  if (v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE) {
324  av_log(avctx, AV_LOG_ERROR,
325  "LOOPFILTER shall not be enabled in Simple Profile\n");
326  }
328  v->s.loop_filter = 0;
329 
330  v->res_x8 = get_bits1(gb); //reserved
331  v->multires = get_bits1(gb);
332  v->res_fasttx = get_bits1(gb);
333  if (!v->res_fasttx) {
342  }
343 
344  v->fastuvmc = get_bits1(gb); //common
345  if (!v->profile && !v->fastuvmc) {
346  av_log(avctx, AV_LOG_ERROR,
347  "FASTUVMC unavailable in Simple Profile\n");
348  return -1;
349  }
350  v->extended_mv = get_bits1(gb); //common
351  if (!v->profile && v->extended_mv)
352  {
353  av_log(avctx, AV_LOG_ERROR,
354  "Extended MVs unavailable in Simple Profile\n");
355  return -1;
356  }
357  v->dquant = get_bits(gb, 2); //common
358  v->vstransform = get_bits1(gb); //common
359 
360  v->res_transtab = get_bits1(gb);
361  if (v->res_transtab)
362  {
363  av_log(avctx, AV_LOG_ERROR,
364  "1 for reserved RES_TRANSTAB is forbidden\n");
365  return -1;
366  }
367 
368  v->overlap = get_bits1(gb); //common
369 
370  v->s.resync_marker = get_bits1(gb);
371  v->rangered = get_bits1(gb);
372  if (v->rangered && v->profile == PROFILE_SIMPLE) {
373  av_log(avctx, AV_LOG_INFO,
374  "RANGERED should be set to 0 in Simple Profile\n");
375  }
376 
377  v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
378  v->quantizer_mode = get_bits(gb, 2); //common
379 
380  v->finterpflag = get_bits1(gb); //common
381 
382  if (v->res_sprite) {
383  v->s.avctx->width = v->s.avctx->coded_width = get_bits(gb, 11);
384  v->s.avctx->height = v->s.avctx->coded_height = get_bits(gb, 11);
385  skip_bits(gb, 5); //frame rate
386  v->res_x8 = get_bits1(gb);
387  if (get_bits1(gb)) { // something to do with DC VLC selection
388  av_log(avctx, AV_LOG_ERROR, "Unsupported sprite feature\n");
389  return -1;
390  }
391  skip_bits(gb, 3); //slice code
392  v->res_rtm_flag = 0;
393  } else {
394  v->res_rtm_flag = get_bits1(gb); //reserved
395  }
396  if (!v->res_rtm_flag) {
397 // av_log(avctx, AV_LOG_ERROR,
398 // "0 for reserved RES_RTM_FLAG is forbidden\n");
399  av_log(avctx, AV_LOG_ERROR,
400  "Old WMV3 version detected, some frames may be decoded incorrectly\n");
401  //return -1;
402  }
403  //TODO: figure out what they mean (always 0x402F)
404  if (!v->res_fasttx)
405  skip_bits(gb, 16);
406  av_log(avctx, AV_LOG_DEBUG,
407  "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
408  "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
409  "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
410  "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
412  v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
413  v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
414  v->dquant, v->quantizer_mode, avctx->max_b_frames);
415  return 0;
416 }
417 
419 {
420  v->res_rtm_flag = 1;
421  v->level = get_bits(gb, 3);
422  if (v->level >= 5) {
423  av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
424  }
425  v->chromaformat = get_bits(gb, 2);
426  if (v->chromaformat != 1) {
428  "Only 4:2:0 chroma format supported\n");
429  return -1;
430  }
431 
432  // (fps-2)/4 (->30)
433  v->frmrtq_postproc = get_bits(gb, 3); //common
434  // (bitrate-32kbps)/64kbps
435  v->bitrtq_postproc = get_bits(gb, 5); //common
436  v->postprocflag = get_bits1(gb); //common
437 
438  v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
439  v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
440  v->s.avctx->width = v->s.avctx->coded_width;
441  v->s.avctx->height = v->s.avctx->coded_height;
442  v->broadcast = get_bits1(gb);
443  v->interlace = get_bits1(gb);
444  v->tfcntrflag = get_bits1(gb);
445  v->finterpflag = get_bits1(gb);
446  skip_bits1(gb); // reserved
447 
449  "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
450  "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
451  "TFCTRflag=%i, FINTERPflag=%i\n",
454  v->tfcntrflag, v->finterpflag);
455 
456  v->psf = get_bits1(gb);
457  if (v->psf) { //PsF, 6.1.13
458  av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
459  return -1;
460  }
461  v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
462  if (get_bits1(gb)) { //Display Info - decoding is not affected by it
463  int w, h, ar = 0;
464  av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
465  w = get_bits(gb, 14) + 1;
466  h = get_bits(gb, 14) + 1;
467  av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
468  if (get_bits1(gb))
469  ar = get_bits(gb, 4);
470  if (ar && ar < 14) {
472  } else if (ar == 15) {
473  w = get_bits(gb, 8) + 1;
474  h = get_bits(gb, 8) + 1;
475  v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
476  } else {
479  v->s.avctx->height * w,
480  v->s.avctx->width * h,
481  1 << 30);
482  }
483  av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",
486 
487  if (get_bits1(gb)) { //framerate stuff
488  if (get_bits1(gb)) {
489  v->s.avctx->time_base.num = 32;
490  v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
491  } else {
492  int nr, dr;
493  nr = get_bits(gb, 8);
494  dr = get_bits(gb, 4);
495  if (nr > 0 && nr < 8 && dr > 0 && dr < 3) {
496  v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];
497  v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;
498  }
499  }
500  if (v->broadcast) { // Pulldown may be present
501  v->s.avctx->time_base.den *= 2;
502  v->s.avctx->ticks_per_frame = 2;
503  }
504  }
505 
506  if (get_bits1(gb)) {
507  v->color_prim = get_bits(gb, 8);
508  v->transfer_char = get_bits(gb, 8);
509  v->matrix_coef = get_bits(gb, 8);
510  }
511  }
512 
513  v->hrd_param_flag = get_bits1(gb);
514  if (v->hrd_param_flag) {
515  int i;
516  v->hrd_num_leaky_buckets = get_bits(gb, 5);
517  skip_bits(gb, 4); //bitrate exponent
518  skip_bits(gb, 4); //buffer size exponent
519  for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
520  skip_bits(gb, 16); //hrd_rate[n]
521  skip_bits(gb, 16); //hrd_buffer[n]
522  }
523  }
524  return 0;
525 }
526 
528 {
529  int i;
530 
531  av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
532  v->broken_link = get_bits1(gb);
533  v->closed_entry = get_bits1(gb);
534  v->panscanflag = get_bits1(gb);
535  v->refdist_flag = get_bits1(gb);
536  v->s.loop_filter = get_bits1(gb);
537  v->fastuvmc = get_bits1(gb);
538  v->extended_mv = get_bits1(gb);
539  v->dquant = get_bits(gb, 2);
540  v->vstransform = get_bits1(gb);
541  v->overlap = get_bits1(gb);
542  v->quantizer_mode = get_bits(gb, 2);
543 
544  if (v->hrd_param_flag) {
545  for (i = 0; i < v->hrd_num_leaky_buckets; i++) {
546  skip_bits(gb, 8); //hrd_full[n]
547  }
548  }
549 
550  if (get_bits1(gb)) {
551  avctx->width = avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
552  avctx->height = avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
553  }
554  if (v->extended_mv)
555  v->extended_dmv = get_bits1(gb);
556  if ((v->range_mapy_flag = get_bits1(gb))) {
557  av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
558  v->range_mapy = get_bits(gb, 3);
559  }
560  if ((v->range_mapuv_flag = get_bits1(gb))) {
561  av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
562  v->range_mapuv = get_bits(gb, 3);
563  }
564 
565  av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
566  "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
567  "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
568  "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
571 
572  return 0;
573 }
574 
576 {
577  int pqindex, lowquant, status;
578 
579  if (v->finterpflag)
580  v->interpfrm = get_bits1(gb);
581  skip_bits(gb, 2); //framecnt unused
582  v->rangeredfrm = 0;
583  if (v->rangered)
584  v->rangeredfrm = get_bits1(gb);
585  v->s.pict_type = get_bits1(gb);
586  if (v->s.avctx->max_b_frames) {
587  if (!v->s.pict_type) {
588  if (get_bits1(gb))
590  else
592  } else
594  } else
596 
597  v->bi_type = 0;
598  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
601  if (v->bfraction == 0) {
603  }
604  }
606  skip_bits(gb, 7); // skip buffer fullness
607 
608  if (v->parse_only)
609  return 0;
610 
611  /* calculate RND */
613  v->rnd = 1;
614  if (v->s.pict_type == AV_PICTURE_TYPE_P)
615  v->rnd ^= 1;
616 
617  /* Quantizer stuff */
618  pqindex = get_bits(gb, 5);
619  if (!pqindex)
620  return -1;
622  v->pq = ff_vc1_pquant_table[0][pqindex];
623  else
624  v->pq = ff_vc1_pquant_table[1][pqindex];
625 
626  v->pquantizer = 1;
628  v->pquantizer = pqindex < 9;
630  v->pquantizer = 0;
631  v->pqindex = pqindex;
632  if (pqindex < 9)
633  v->halfpq = get_bits1(gb);
634  else
635  v->halfpq = 0;
637  v->pquantizer = get_bits1(gb);
638  v->dquantfrm = 0;
639  if (v->extended_mv == 1)
640  v->mvrange = get_unary(gb, 0, 3);
641  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
642  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
643  v->range_x = 1 << (v->k_x - 1);
644  v->range_y = 1 << (v->k_y - 1);
645  if (v->multires && v->s.pict_type != AV_PICTURE_TYPE_B)
646  v->respic = get_bits(gb, 2);
647 
648  if (v->res_x8 && (v->s.pict_type == AV_PICTURE_TYPE_I || v->s.pict_type == AV_PICTURE_TYPE_BI)) {
649  v->x8_type = get_bits1(gb);
650  } else
651  v->x8_type = 0;
652 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
653 // (v->s.pict_type == AV_PICTURE_TYPE_P) ? 'P' : ((v->s.pict_type == AV_PICTURE_TYPE_I) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
654 
656  v->use_ic = 0;
657 
658  switch (v->s.pict_type) {
659  case AV_PICTURE_TYPE_P:
660  if (v->pq < 5) v->tt_index = 0;
661  else if (v->pq < 13) v->tt_index = 1;
662  else v->tt_index = 2;
663 
664  lowquant = (v->pq > 12) ? 0 : 1;
665  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][get_unary(gb, 1, 4)];
666  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
667  int scale, shift, i;
668  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][get_unary(gb, 1, 3)];
669  v->lumscale = get_bits(gb, 6);
670  v->lumshift = get_bits(gb, 6);
671  v->use_ic = 1;
672  /* fill lookup tables for intensity compensation */
673  if (!v->lumscale) {
674  scale = -64;
675  shift = (255 - v->lumshift * 2) << 6;
676  if (v->lumshift > 31)
677  shift += 128 << 6;
678  } else {
679  scale = v->lumscale + 32;
680  if (v->lumshift > 31)
681  shift = (v->lumshift - 64) << 6;
682  else
683  shift = v->lumshift << 6;
684  }
685  for (i = 0; i < 256; i++) {
686  v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
687  v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
688  }
689  }
690  v->qs_last = v->s.quarter_sample;
692  v->s.quarter_sample = 0;
693  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
695  v->s.quarter_sample = 0;
696  else
697  v->s.quarter_sample = 1;
698  } else
699  v->s.quarter_sample = 1;
701 
702  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
703  v->mv_mode2 == MV_PMODE_MIXED_MV) ||
704  v->mv_mode == MV_PMODE_MIXED_MV) {
706  if (status < 0)
707  return -1;
708  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
709  "Imode: %i, Invert: %i\n", status>>1, status&1);
710  } else {
711  v->mv_type_is_raw = 0;
712  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
713  }
714  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
715  if (status < 0)
716  return -1;
717  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
718  "Imode: %i, Invert: %i\n", status>>1, status&1);
719 
720  /* Hopefully this is correct for P frames */
721  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
722  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
723 
724  if (v->dquant) {
725  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
727  }
728 
729  v->ttfrm = 0; //FIXME Is that so ?
730  if (v->vstransform) {
731  v->ttmbf = get_bits1(gb);
732  if (v->ttmbf) {
733  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
734  }
735  } else {
736  v->ttmbf = 1;
737  v->ttfrm = TT_8X8;
738  }
739  break;
740  case AV_PICTURE_TYPE_B:
741  if (v->pq < 5) v->tt_index = 0;
742  else if (v->pq < 13) v->tt_index = 1;
743  else v->tt_index = 2;
744 
746  v->qs_last = v->s.quarter_sample;
747  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
748  v->s.mspel = v->s.quarter_sample;
749 
750  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
751  if (status < 0)
752  return -1;
753  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
754  "Imode: %i, Invert: %i\n", status>>1, status&1);
755  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
756  if (status < 0)
757  return -1;
758  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
759  "Imode: %i, Invert: %i\n", status>>1, status&1);
760 
761  v->s.mv_table_index = get_bits(gb, 2);
762  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
763 
764  if (v->dquant) {
765  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
767  }
768 
769  v->ttfrm = 0;
770  if (v->vstransform) {
771  v->ttmbf = get_bits1(gb);
772  if (v->ttmbf) {
773  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
774  }
775  } else {
776  v->ttmbf = 1;
777  v->ttfrm = TT_8X8;
778  }
779  break;
780  }
781 
782  if (!v->x8_type) {
783  /* AC Syntax */
784  v->c_ac_table_index = decode012(gb);
786  v->y_ac_table_index = decode012(gb);
787  }
788  /* DC Syntax */
789  v->s.dc_table_index = get_bits1(gb);
790  }
791 
792  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
794  v->bi_type = 1;
795  }
796  return 0;
797 }
798 
799 /* fill lookup tables for intensity compensation */
800 #define INIT_LUT(lumscale, lumshift, luty, lutuv) \
801  if (!lumscale) { \
802  scale = -64; \
803  shift = (255 - lumshift * 2) << 6; \
804  if (lumshift > 31) \
805  shift += 128 << 6; \
806  } else { \
807  scale = lumscale + 32; \
808  if (lumshift > 31) \
809  shift = (lumshift - 64) << 6; \
810  else \
811  shift = lumshift << 6; \
812  } \
813  for (i = 0; i < 256; i++) { \
814  luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6); \
815  lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6); \
816  }
817 
819 {
820  int pqindex, lowquant;
821  int status;
822  int mbmodetab, imvtab, icbptab, twomvbptab, fourmvbptab; /* useful only for debugging */
823  int scale, shift, i; /* for initializing LUT for intensity compensation */
824 
825  v->p_frame_skipped = 0;
826  if (v->second_field) {
828  if (v->fptype & 4)
831  if (!v->pic_header_flag)
832  goto parse_common_info;
833  }
834 
835  v->field_mode = 0;
836  if (v->interlace) {
837  v->fcm = decode012(gb);
838  if (v->fcm) {
839  if (v->fcm == ILACE_FIELD)
840  v->field_mode = 1;
841  if (!v->warn_interlaced++)
843  "Interlaced frames/fields support is incomplete\n");
844  }
845  } else {
846  v->fcm = PROGRESSIVE;
847  }
848 
849  if (v->field_mode) {
850  v->fptype = get_bits(gb, 3);
852  if (v->fptype & 4) // B-picture
854  } else {
855  switch (get_unary(gb, 0, 4)) {
856  case 0:
858  break;
859  case 1:
861  break;
862  case 2:
864  break;
865  case 3:
867  break;
868  case 4:
869  v->s.pict_type = AV_PICTURE_TYPE_P; // skipped pic
870  v->p_frame_skipped = 1;
871  break;
872  }
873  }
874  if (v->tfcntrflag)
875  skip_bits(gb, 8);
876  if (v->broadcast) {
877  if (!v->interlace || v->psf) {
878  v->rptfrm = get_bits(gb, 2);
879  } else {
880  v->tff = get_bits1(gb);
881  v->rff = get_bits1(gb);
882  }
883  }
884  if (v->panscanflag) {
885  av_log_missing_feature(v->s.avctx, "Pan-scan", 0);
886  //...
887  }
888  if (v->p_frame_skipped) {
889  return 0;
890  }
891  v->rnd = get_bits1(gb);
892  if (v->interlace)
893  v->uvsamp = get_bits1(gb);
894  if (v->field_mode) {
895  if (!v->refdist_flag)
896  v->refdist = 0;
897  else {
898  if ((v->s.pict_type != AV_PICTURE_TYPE_B)
899  && (v->s.pict_type != AV_PICTURE_TYPE_BI)) {
900  v->refdist = get_bits(gb, 2);
901  if (v->refdist == 3)
902  v->refdist += get_unary(gb, 0, 16);
903  } else {
906  v->frfd = (v->bfraction * v->refdist) >> 8;
907  v->brfd = v->refdist - v->frfd - 1;
908  if (v->brfd < 0)
909  v->brfd = 0;
910  }
911  }
912  goto parse_common_info;
913  }
914  if (v->finterpflag)
915  v->interpfrm = get_bits1(gb);
916  if (v->s.pict_type == AV_PICTURE_TYPE_B) {
919  if (v->bfraction == 0) {
920  v->s.pict_type = AV_PICTURE_TYPE_BI; /* XXX: should not happen here */
921  }
922  }
923 
924  parse_common_info:
925  if (v->field_mode)
926  v->cur_field_type = !(v->tff ^ v->second_field);
927  pqindex = get_bits(gb, 5);
928  if (!pqindex)
929  return -1;
930  v->pqindex = pqindex;
932  v->pq = ff_vc1_pquant_table[0][pqindex];
933  else
934  v->pq = ff_vc1_pquant_table[1][pqindex];
935 
936  v->pquantizer = 1;
938  v->pquantizer = pqindex < 9;
940  v->pquantizer = 0;
941  v->pqindex = pqindex;
942  if (pqindex < 9)
943  v->halfpq = get_bits1(gb);
944  else
945  v->halfpq = 0;
947  v->pquantizer = get_bits1(gb);
948  if (v->postprocflag)
949  v->postproc = get_bits(gb, 2);
950 
952  v->use_ic = 0;
953 
954  if (v->parse_only)
955  return 0;
956 
957  switch (v->s.pict_type) {
958  case AV_PICTURE_TYPE_I:
959  case AV_PICTURE_TYPE_BI:
960  if (v->fcm == ILACE_FRAME) { //interlace frame picture
961  status = bitplane_decoding(v->fieldtx_plane, &v->fieldtx_is_raw, v);
962  if (status < 0)
963  return -1;
964  av_log(v->s.avctx, AV_LOG_DEBUG, "FIELDTX plane encoding: "
965  "Imode: %i, Invert: %i\n", status>>1, status&1);
966  }
967  status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
968  if (status < 0)
969  return -1;
970  av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
971  "Imode: %i, Invert: %i\n", status>>1, status&1);
972  v->condover = CONDOVER_NONE;
973  if (v->overlap && v->pq <= 8) {
974  v->condover = decode012(gb);
975  if (v->condover == CONDOVER_SELECT) {
977  if (status < 0)
978  return -1;
979  av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
980  "Imode: %i, Invert: %i\n", status>>1, status&1);
981  }
982  }
983  break;
984  case AV_PICTURE_TYPE_P:
985  if (v->field_mode) {
986  v->numref = get_bits1(gb);
987  if (!v->numref) {
988  v->reffield = get_bits1(gb);
989  v->ref_field_type[0] = v->reffield ^ !v->cur_field_type;
990  }
991  }
992  if (v->extended_mv)
993  v->mvrange = get_unary(gb, 0, 3);
994  else
995  v->mvrange = 0;
996  if (v->interlace) {
997  if (v->extended_dmv)
998  v->dmvrange = get_unary(gb, 0, 3);
999  else
1000  v->dmvrange = 0;
1001  if (v->fcm == ILACE_FRAME) { // interlaced frame picture
1002  v->fourmvswitch = get_bits1(gb);
1003  v->intcomp = get_bits1(gb);
1004  if (v->intcomp) {
1005  v->lumscale = get_bits(gb, 6);
1006  v->lumshift = get_bits(gb, 6);
1007  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1008  }
1009  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1010  av_log(v->s.avctx, AV_LOG_DEBUG, "SKIPMB plane encoding: "
1011  "Imode: %i, Invert: %i\n", status>>1, status&1);
1012  mbmodetab = get_bits(gb, 2);
1013  if (v->fourmvswitch)
1014  v->mbmode_vlc = &ff_vc1_intfr_4mv_mbmode_vlc[mbmodetab];
1015  else
1016  v->mbmode_vlc = &ff_vc1_intfr_non4mv_mbmode_vlc[mbmodetab];
1017  imvtab = get_bits(gb, 2);
1018  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1019  // interlaced p-picture cbpcy range is [1, 63]
1020  icbptab = get_bits(gb, 3);
1021  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1022  twomvbptab = get_bits(gb, 2);
1023  v->twomvbp_vlc = &ff_vc1_2mv_block_pattern_vlc[twomvbptab];
1024  if (v->fourmvswitch) {
1025  fourmvbptab = get_bits(gb, 2);
1026  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1027  }
1028  }
1029  }
1030  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1031  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1032  v->range_x = 1 << (v->k_x - 1);
1033  v->range_y = 1 << (v->k_y - 1);
1034 
1035  if (v->pq < 5)
1036  v->tt_index = 0;
1037  else if (v->pq < 13)
1038  v->tt_index = 1;
1039  else
1040  v->tt_index = 2;
1041  if (v->fcm != ILACE_FRAME) {
1042  int mvmode;
1043  mvmode = get_unary(gb, 1, 4);
1044  lowquant = (v->pq > 12) ? 0 : 1;
1045  v->mv_mode = ff_vc1_mv_pmode_table[lowquant][mvmode];
1046  if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1047  int mvmode2;
1048  mvmode2 = get_unary(gb, 1, 3);
1049  v->mv_mode2 = ff_vc1_mv_pmode_table2[lowquant][mvmode2];
1050  if (v->field_mode)
1051  v->intcompfield = decode210(gb);
1052  v->lumscale = get_bits(gb, 6);
1053  v->lumshift = get_bits(gb, 6);
1054  INIT_LUT(v->lumscale, v->lumshift, v->luty, v->lutuv);
1055  if ((v->field_mode) && !v->intcompfield) {
1056  v->lumscale2 = get_bits(gb, 6);
1057  v->lumshift2 = get_bits(gb, 6);
1058  INIT_LUT(v->lumscale2, v->lumshift2, v->luty2, v->lutuv2);
1059  }
1060  v->use_ic = 1;
1061  }
1062  v->qs_last = v->s.quarter_sample;
1064  v->s.quarter_sample = 0;
1065  else if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1067  v->s.quarter_sample = 0;
1068  else
1069  v->s.quarter_sample = 1;
1070  } else
1071  v->s.quarter_sample = 1;
1072  v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN
1074  && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1075  }
1076  if (v->fcm == PROGRESSIVE) { // progressive
1077  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1079  || v->mv_mode == MV_PMODE_MIXED_MV) {
1080  status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1081  if (status < 0)
1082  return -1;
1083  av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1084  "Imode: %i, Invert: %i\n", status>>1, status&1);
1085  } else {
1086  v->mv_type_is_raw = 0;
1087  memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1088  }
1089  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1090  if (status < 0)
1091  return -1;
1092  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1093  "Imode: %i, Invert: %i\n", status>>1, status&1);
1094 
1095  /* Hopefully this is correct for P frames */
1096  v->s.mv_table_index = get_bits(gb, 2); //but using ff_vc1_ tables
1097  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1098  } else if (v->fcm == ILACE_FRAME) { // frame interlaced
1099  v->qs_last = v->s.quarter_sample;
1100  v->s.quarter_sample = 1;
1101  v->s.mspel = 1;
1102  } else { // field interlaced
1103  mbmodetab = get_bits(gb, 3);
1104  imvtab = get_bits(gb, 2 + v->numref);
1105  if (!v->numref)
1106  v->imv_vlc = &ff_vc1_1ref_mvdata_vlc[imvtab];
1107  else
1108  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1109  icbptab = get_bits(gb, 3);
1110  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1111  if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1113  fourmvbptab = get_bits(gb, 2);
1114  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1115  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1116  } else {
1117  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1118  }
1119  }
1120  if (v->dquant) {
1121  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1123  }
1124 
1125  v->ttfrm = 0; //FIXME Is that so ?
1126  if (v->vstransform) {
1127  v->ttmbf = get_bits1(gb);
1128  if (v->ttmbf) {
1129  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1130  }
1131  } else {
1132  v->ttmbf = 1;
1133  v->ttfrm = TT_8X8;
1134  }
1135  break;
1136  case AV_PICTURE_TYPE_B:
1137  // TODO: implement interlaced frame B picture decoding
1138  if (v->fcm == ILACE_FRAME)
1139  return -1;
1140  if (v->extended_mv)
1141  v->mvrange = get_unary(gb, 0, 3);
1142  else
1143  v->mvrange = 0;
1144  v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1145  v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1146  v->range_x = 1 << (v->k_x - 1);
1147  v->range_y = 1 << (v->k_y - 1);
1148 
1149  if (v->pq < 5)
1150  v->tt_index = 0;
1151  else if (v->pq < 13)
1152  v->tt_index = 1;
1153  else
1154  v->tt_index = 2;
1155 
1156  if (v->field_mode) {
1157  int mvmode;
1158  if (v->extended_dmv)
1159  v->dmvrange = get_unary(gb, 0, 3);
1160  mvmode = get_unary(gb, 1, 3);
1161  lowquant = (v->pq > 12) ? 0 : 1;
1162  v->mv_mode = ff_vc1_mv_pmode_table2[lowquant][mvmode];
1163  v->qs_last = v->s.quarter_sample;
1166  status = bitplane_decoding(v->forward_mb_plane, &v->fmb_is_raw, v);
1167  if (status < 0)
1168  return -1;
1169  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Forward Type plane encoding: "
1170  "Imode: %i, Invert: %i\n", status>>1, status&1);
1171  mbmodetab = get_bits(gb, 3);
1172  if (v->mv_mode == MV_PMODE_MIXED_MV)
1173  v->mbmode_vlc = &ff_vc1_if_mmv_mbmode_vlc[mbmodetab];
1174  else
1175  v->mbmode_vlc = &ff_vc1_if_1mv_mbmode_vlc[mbmodetab];
1176  imvtab = get_bits(gb, 3);
1177  v->imv_vlc = &ff_vc1_2ref_mvdata_vlc[imvtab];
1178  icbptab = get_bits(gb, 3);
1179  v->cbpcy_vlc = &ff_vc1_icbpcy_vlc[icbptab];
1180  if (v->mv_mode == MV_PMODE_MIXED_MV) {
1181  fourmvbptab = get_bits(gb, 2);
1182  v->fourmvbp_vlc = &ff_vc1_4mv_block_pattern_vlc[fourmvbptab];
1183  }
1184  v->numref = 1; // interlaced field B pictures are always 2-ref
1185  } else {
1187  v->qs_last = v->s.quarter_sample;
1188  v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1189  v->s.mspel = v->s.quarter_sample;
1190  status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1191  if (status < 0)
1192  return -1;
1193  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1194  "Imode: %i, Invert: %i\n", status>>1, status&1);
1195  status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1196  if (status < 0)
1197  return -1;
1198  av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1199  "Imode: %i, Invert: %i\n", status>>1, status&1);
1200  v->s.mv_table_index = get_bits(gb, 2);
1201  v->cbpcy_vlc = &ff_vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1202  }
1203 
1204  if (v->dquant) {
1205  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1207  }
1208 
1209  v->ttfrm = 0;
1210  if (v->vstransform) {
1211  v->ttmbf = get_bits1(gb);
1212  if (v->ttmbf) {
1213  v->ttfrm = ff_vc1_ttfrm_to_tt[get_bits(gb, 2)];
1214  }
1215  } else {
1216  v->ttmbf = 1;
1217  v->ttfrm = TT_8X8;
1218  }
1219  break;
1220  }
1221 
1222  /* AC Syntax */
1223  v->c_ac_table_index = decode012(gb);
1225  v->y_ac_table_index = decode012(gb);
1226  }
1227  /* DC Syntax */
1228  v->s.dc_table_index = get_bits1(gb);
1230  && v->dquant) {
1231  av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1233  }
1234 
1235  v->bi_type = 0;
1236  if (v->s.pict_type == AV_PICTURE_TYPE_BI) {
1238  v->bi_type = 1;
1239  }
1240  return 0;
1241 }