Libav
msmpeg4dec.c
Go to the documentation of this file.
1 /*
2  * MSMPEG4 backend for encoder and decoder
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include "avcodec.h"
26 #include "internal.h"
27 #include "mpegutils.h"
28 #include "mpegvideo.h"
29 #include "msmpeg4.h"
30 #include "h263.h"
31 #include "mpeg4video.h"
32 #include "msmpeg4data.h"
33 #include "vc1data.h"
34 #include "wmv2.h"
35 
36 #define DC_VLC_BITS 9
37 #define V2_INTRA_CBPC_VLC_BITS 3
38 #define V2_MB_TYPE_VLC_BITS 7
39 #define MV_VLC_BITS 9
40 #define V2_MV_VLC_BITS 9
41 #define TEX_VLC_BITS 9
42 
43 #define DEFAULT_INTER_INDEX 3
44 
45 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
46  int32_t **dc_val_ptr)
47 {
48  int i;
49 
50  if (n < 4) {
51  i= 0;
52  } else {
53  i= n-3;
54  }
55 
56  *dc_val_ptr= &s->last_dc[i];
57  return s->last_dc[i];
58 }
59 
60 /****************************************/
61 /* decoding stuff */
62 
68 static VLC v2_mv_vlc;
70 
71 /* This is identical to H.263 except that its range is multiplied by 2. */
72 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
73 {
74  int code, val, sign, shift;
75 
76  code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
77  ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
78  if (code < 0)
79  return 0xffff;
80 
81  if (code == 0)
82  return pred;
83  sign = get_bits1(&s->gb);
84  shift = f_code - 1;
85  val = code;
86  if (shift) {
87  val = (val - 1) << shift;
88  val |= get_bits(&s->gb, shift);
89  val++;
90  }
91  if (sign)
92  val = -val;
93 
94  val += pred;
95  if (val <= -64)
96  val += 64;
97  else if (val >= 64)
98  val -= 64;
99 
100  return val;
101 }
102 
103 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
104 {
105  int cbp, code, i;
106 
107  if (s->pict_type == AV_PICTURE_TYPE_P) {
108  if (s->use_skip_mb_code) {
109  if (get_bits1(&s->gb)) {
110  /* skip mb */
111  s->mb_intra = 0;
112  for(i=0;i<6;i++)
113  s->block_last_index[i] = -1;
114  s->mv_dir = MV_DIR_FORWARD;
115  s->mv_type = MV_TYPE_16X16;
116  s->mv[0][0][0] = 0;
117  s->mv[0][0][1] = 0;
118  s->mb_skipped = 1;
119  return 0;
120  }
121  }
122 
123  if(s->msmpeg4_version==2)
124  code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
125  else
127  if(code<0 || code>7){
128  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
129  return -1;
130  }
131 
132  s->mb_intra = code >>2;
133 
134  cbp = code & 0x3;
135  } else {
136  s->mb_intra = 1;
137  if(s->msmpeg4_version==2)
138  cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
139  else
141  if(cbp<0 || cbp>3){
142  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
143  return -1;
144  }
145  }
146 
147  if (!s->mb_intra) {
148  int mx, my, cbpy;
149 
151  if(cbpy<0){
152  av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
153  return -1;
154  }
155 
156  cbp|= cbpy<<2;
157  if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
158 
159  ff_h263_pred_motion(s, 0, 0, &mx, &my);
160  mx= msmpeg4v2_decode_motion(s, mx, 1);
161  my= msmpeg4v2_decode_motion(s, my, 1);
162 
163  s->mv_dir = MV_DIR_FORWARD;
164  s->mv_type = MV_TYPE_16X16;
165  s->mv[0][0][0] = mx;
166  s->mv[0][0][1] = my;
167  } else {
168  if(s->msmpeg4_version==2){
169  s->ac_pred = get_bits1(&s->gb);
170  cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
171  } else{
172  s->ac_pred = 0;
173  cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
174  if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
175  }
176  }
177 
178  s->bdsp.clear_blocks(s->block[0]);
179  for (i = 0; i < 6; i++) {
180  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
181  {
182  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
183  return -1;
184  }
185  }
186  return 0;
187 }
188 
189 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
190 {
191  int cbp, code, i;
192  uint8_t *coded_val;
193  uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
194 
195  if (s->pict_type == AV_PICTURE_TYPE_P) {
196  if (s->use_skip_mb_code) {
197  if (get_bits1(&s->gb)) {
198  /* skip mb */
199  s->mb_intra = 0;
200  for(i=0;i<6;i++)
201  s->block_last_index[i] = -1;
202  s->mv_dir = MV_DIR_FORWARD;
203  s->mv_type = MV_TYPE_16X16;
204  s->mv[0][0][0] = 0;
205  s->mv[0][0][1] = 0;
206  s->mb_skipped = 1;
207  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
208 
209  return 0;
210  }
211  }
212 
213  code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
214  if (code < 0)
215  return -1;
216  //s->mb_intra = (code & 0x40) ? 0 : 1;
217  s->mb_intra = (~code & 0x40) >> 6;
218 
219  cbp = code & 0x3f;
220  } else {
221  s->mb_intra = 1;
223  if (code < 0)
224  return -1;
225  /* predict coded block pattern */
226  cbp = 0;
227  for(i=0;i<6;i++) {
228  int val = ((code >> (5 - i)) & 1);
229  if (i < 4) {
230  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
231  val = val ^ pred;
232  *coded_val = val;
233  }
234  cbp |= val << (5 - i);
235  }
236  }
237 
238  if (!s->mb_intra) {
239  int mx, my;
240  if(s->per_mb_rl_table && cbp){
241  s->rl_table_index = decode012(&s->gb);
243  }
244  ff_h263_pred_motion(s, 0, 0, &mx, &my);
245  if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
246  return -1;
247  s->mv_dir = MV_DIR_FORWARD;
248  s->mv_type = MV_TYPE_16X16;
249  s->mv[0][0][0] = mx;
250  s->mv[0][0][1] = my;
251  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
252  } else {
253  ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
254  ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
255  show_bits(&s->gb, 24));
256  s->ac_pred = get_bits1(&s->gb);
257  *mb_type_ptr = MB_TYPE_INTRA;
258  if(s->inter_intra_pred){
259  s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
260  ff_dlog(s, "%d%d %d %d/",
261  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
262  }
263  if(s->per_mb_rl_table && cbp){
264  s->rl_table_index = decode012(&s->gb);
266  }
267  }
268 
269  s->bdsp.clear_blocks(s->block[0]);
270  for (i = 0; i < 6; i++) {
271  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
272  {
273  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
274  return -1;
275  }
276  }
277 
278  return 0;
279 }
280 
281 /* init all vlc decoding tables */
283 {
284  MpegEncContext *s = avctx->priv_data;
285  static int done = 0;
286  int i;
287  MVTable *mv;
288 
289  if (ff_h263_decode_init(avctx) < 0)
290  return -1;
291 
293 
294  if (!done) {
295  done = 1;
296 
297  for(i=0;i<NB_RL_TABLES;i++) {
299  }
300  INIT_VLC_RL(ff_rl_table[0], 642);
301  INIT_VLC_RL(ff_rl_table[1], 1104);
302  INIT_VLC_RL(ff_rl_table[2], 554);
303  INIT_VLC_RL(ff_rl_table[3], 940);
304  INIT_VLC_RL(ff_rl_table[4], 962);
305  INIT_VLC_RL(ff_rl_table[5], 554);
306 
307  mv = &ff_mv_tables[0];
308  INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
309  mv->table_mv_bits, 1, 1,
310  mv->table_mv_code, 2, 2, 3714);
311  mv = &ff_mv_tables[1];
312  INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
313  mv->table_mv_bits, 1, 1,
314  mv->table_mv_code, 2, 2, 2694);
315 
317  &ff_table0_dc_lum[0][1], 8, 4,
318  &ff_table0_dc_lum[0][0], 8, 4, 1158);
320  &ff_table0_dc_chroma[0][1], 8, 4,
321  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
323  &ff_table1_dc_lum[0][1], 8, 4,
324  &ff_table1_dc_lum[0][0], 8, 4, 1476);
326  &ff_table1_dc_chroma[0][1], 8, 4,
327  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
328 
329  INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
330  &ff_v2_dc_lum_table[0][1], 8, 4,
331  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
332  INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
333  &ff_v2_dc_chroma_table[0][1], 8, 4,
334  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
335 
336  INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
337  &ff_v2_intra_cbpc[0][1], 2, 1,
338  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
339  INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
340  &ff_v2_mb_type[0][1], 2, 1,
341  &ff_v2_mb_type[0][0], 2, 1, 128);
342  INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
343  &ff_mvtab[0][1], 2, 1,
344  &ff_mvtab[0][0], 2, 1, 538);
345 
346  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
347  &ff_wmv2_inter_table[0][0][1], 8, 4,
348  &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
349  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
350  &ff_wmv2_inter_table[1][0][1], 8, 4,
351  &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
352  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
353  &ff_wmv2_inter_table[2][0][1], 8, 4,
354  &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
355  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
356  &ff_wmv2_inter_table[3][0][1], 8, 4,
357  &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
358 
360  &ff_msmp4_mb_i_table[0][1], 4, 2,
361  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
362 
363  INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
364  &ff_table_inter_intra[0][1], 2, 1,
365  &ff_table_inter_intra[0][0], 2, 1, 8);
366  }
367 
368  switch(s->msmpeg4_version){
369  case 1:
370  case 2:
372  break;
373  case 3:
374  case 4:
376  break;
377  case 5:
380  case 6:
381  //FIXME + TODO VC1 decode mb
382  break;
383  }
384 
385  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
386 
387  return 0;
388 }
389 
391 {
392  int code;
393 
394  if(s->msmpeg4_version==1){
395  int start_code = get_bits_long(&s->gb, 32);
396  if(start_code!=0x00000100){
397  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
398  return -1;
399  }
400 
401  skip_bits(&s->gb, 5); // frame number */
402  }
403 
404  s->pict_type = get_bits(&s->gb, 2) + 1;
405  if (s->pict_type != AV_PICTURE_TYPE_I &&
407  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
408  return -1;
409  }
410  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
411  if(s->qscale==0){
412  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
413  return -1;
414  }
415 
416  if (s->pict_type == AV_PICTURE_TYPE_I) {
417  code = get_bits(&s->gb, 5);
418  if(s->msmpeg4_version==1){
419  if(code==0 || code>s->mb_height){
420  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
421  return -1;
422  }
423 
424  s->slice_height = code;
425  }else{
426  /* 0x17: one slice, 0x18: two slices, ... */
427  if (code < 0x17){
428  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
429  return -1;
430  }
431 
432  s->slice_height = s->mb_height / (code - 0x16);
433  }
434 
435  switch(s->msmpeg4_version){
436  case 1:
437  case 2:
438  s->rl_chroma_table_index = 2;
439  s->rl_table_index = 2;
440 
441  s->dc_table_index = 0; //not used
442  break;
443  case 3:
445  s->rl_table_index = decode012(&s->gb);
446 
447  s->dc_table_index = get_bits1(&s->gb);
448  break;
449  case 4:
450  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
451 
453  else s->per_mb_rl_table= 0;
454 
455  if(!s->per_mb_rl_table){
457  s->rl_table_index = decode012(&s->gb);
458  }
459 
460  s->dc_table_index = get_bits1(&s->gb);
461  s->inter_intra_pred= 0;
462  break;
463  }
464  s->no_rounding = 1;
466  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
467  s->qscale,
469  s->rl_table_index,
470  s->dc_table_index,
471  s->per_mb_rl_table,
472  s->slice_height);
473  } else {
474  switch(s->msmpeg4_version){
475  case 1:
476  case 2:
477  if(s->msmpeg4_version==1)
478  s->use_skip_mb_code = 1;
479  else
480  s->use_skip_mb_code = get_bits1(&s->gb);
481  s->rl_table_index = 2;
483  s->dc_table_index = 0; //not used
484  s->mv_table_index = 0;
485  break;
486  case 3:
487  s->use_skip_mb_code = get_bits1(&s->gb);
488  s->rl_table_index = decode012(&s->gb);
490 
491  s->dc_table_index = get_bits1(&s->gb);
492 
493  s->mv_table_index = get_bits1(&s->gb);
494  break;
495  case 4:
496  s->use_skip_mb_code = get_bits1(&s->gb);
497 
499  else s->per_mb_rl_table= 0;
500 
501  if(!s->per_mb_rl_table){
502  s->rl_table_index = decode012(&s->gb);
504  }
505 
506  s->dc_table_index = get_bits1(&s->gb);
507 
508  s->mv_table_index = get_bits1(&s->gb);
509  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
510  break;
511  }
512 
514  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
515  s->use_skip_mb_code,
516  s->rl_table_index,
518  s->dc_table_index,
519  s->mv_table_index,
520  s->per_mb_rl_table,
521  s->qscale);
522 
523  if(s->flipflop_rounding){
524  s->no_rounding ^= 1;
525  }else{
526  s->no_rounding = 0;
527  }
528  }
529  ff_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
530  s->inter_intra_pred, s->width, s->height);
531 
532  s->esc3_level_length= 0;
533  s->esc3_run_length= 0;
534 
535  return 0;
536 }
537 
539 {
540  int left= buf_size*8 - get_bits_count(&s->gb);
541  int length= s->msmpeg4_version>=3 ? 17 : 16;
542  /* the alt_bitstream reader could read over the end so we need to check it */
543  if(left>=length && left<length+8)
544  {
545  skip_bits(&s->gb, 5); /* fps */
546  s->bit_rate= get_bits(&s->gb, 11)*1024;
547  if(s->msmpeg4_version>=3)
548  s->flipflop_rounding= get_bits1(&s->gb);
549  else
550  s->flipflop_rounding= 0;
551  }
552  else if(left<length+8)
553  {
554  s->flipflop_rounding= 0;
555  if(s->msmpeg4_version != 2)
556  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
557  }
558  else
559  {
560  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
561  }
562 
563  return 0;
564 }
565 
566 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
567 {
568  int level, pred;
569 
570  if(s->msmpeg4_version<=2){
571  if (n < 4) {
572  level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
573  } else {
574  level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
575  }
576  if (level < 0)
577  return -1;
578  level-=256;
579  }else{ //FIXME optimize use unified tables & index
580  if (n < 4) {
582  } else {
584  }
585  if (level < 0){
586  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
587  return -1;
588  }
589 
590  if (level == DC_MAX) {
591  level = get_bits(&s->gb, 8);
592  if (get_bits1(&s->gb))
593  level = -level;
594  } else if (level != 0) {
595  if (get_bits1(&s->gb))
596  level = -level;
597  }
598  }
599 
600  if(s->msmpeg4_version==1){
601  int32_t *dc_val;
602  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
603  level += pred;
604 
605  /* update predictor */
606  *dc_val= level;
607  }else{
608  int16_t *dc_val;
609  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
610  level += pred;
611 
612  /* update predictor */
613  if (n < 4) {
614  *dc_val = level * s->y_dc_scale;
615  } else {
616  *dc_val = level * s->c_dc_scale;
617  }
618  }
619 
620  return level;
621 }
622 
624  int n, int coded, const uint8_t *scan_table)
625 {
626  int level, i, last, run, run_diff;
627  int av_uninit(dc_pred_dir);
628  RLTable *rl;
629  RL_VLC_ELEM *rl_vlc;
630  int qmul, qadd;
631 
632  if (s->mb_intra) {
633  qmul=1;
634  qadd=0;
635 
636  /* DC coef */
637  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
638 
639  if (level < 0){
640  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
641  if(s->inter_intra_pred) level=0;
642  else return -1;
643  }
644  if (n < 4) {
645  rl = &ff_rl_table[s->rl_table_index];
646  if(level > 256*s->y_dc_scale){
647  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
648  if(!s->inter_intra_pred) return -1;
649  }
650  } else {
651  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
652  if(level > 256*s->c_dc_scale){
653  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
654  if(!s->inter_intra_pred) return -1;
655  }
656  }
657  block[0] = level;
658 
659  run_diff = s->msmpeg4_version >= 4;
660  i = 0;
661  if (!coded) {
662  goto not_coded;
663  }
664  if (s->ac_pred) {
665  if (dc_pred_dir == 0)
666  scan_table = s->intra_v_scantable.permutated; /* left */
667  else
668  scan_table = s->intra_h_scantable.permutated; /* top */
669  } else {
670  scan_table = s->intra_scantable.permutated;
671  }
672  rl_vlc= rl->rl_vlc[0];
673  } else {
674  qmul = s->qscale << 1;
675  qadd = (s->qscale - 1) | 1;
676  i = -1;
677  rl = &ff_rl_table[3 + s->rl_table_index];
678 
679  if(s->msmpeg4_version==2)
680  run_diff = 0;
681  else
682  run_diff = 1;
683 
684  if (!coded) {
685  s->block_last_index[n] = i;
686  return 0;
687  }
688  if(!scan_table)
689  scan_table = s->inter_scantable.permutated;
690  rl_vlc= rl->rl_vlc[s->qscale];
691  }
692  {
693  OPEN_READER(re, &s->gb);
694  for(;;) {
695  UPDATE_CACHE(re, &s->gb);
696  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
697  if (level==0) {
698  int cache;
699  cache= GET_CACHE(re, &s->gb);
700  /* escape */
701  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
702  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
703  /* third escape */
704  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
705  UPDATE_CACHE(re, &s->gb);
706  if(s->msmpeg4_version<=3){
707  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
708  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
709  level= SHOW_SBITS(re, &s->gb, 8);
710  SKIP_COUNTER(re, &s->gb, 1+6+8);
711  }else{
712  int sign;
713  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
714  if(!s->esc3_level_length){
715  int ll;
716  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
717  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
718  if(s->qscale<8){
719  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
720  if(ll==0){
721  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
722  }
723  }else{
724  ll=2;
725  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
726  ll++;
727  SKIP_BITS(re, &s->gb, 1);
728  }
729  if(ll<8) SKIP_BITS(re, &s->gb, 1);
730  }
731 
732  s->esc3_level_length= ll;
733  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
734  UPDATE_CACHE(re, &s->gb);
735  }
736  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
737  SKIP_BITS(re, &s->gb, s->esc3_run_length);
738 
739  sign= SHOW_UBITS(re, &s->gb, 1);
740  SKIP_BITS(re, &s->gb, 1);
741 
742  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
743  SKIP_BITS(re, &s->gb, s->esc3_level_length);
744  if(sign) level= -level;
745  }
746 
747  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
748  if (level>0) level= level * qmul + qadd;
749  else level= level * qmul - qadd;
750  i+= run + 1;
751  if(last) i+=192;
752  } else {
753  /* second escape */
754  SKIP_BITS(re, &s->gb, 2);
755  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
756  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
757  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
758  LAST_SKIP_BITS(re, &s->gb, 1);
759  }
760  } else {
761  /* first escape */
762  SKIP_BITS(re, &s->gb, 1);
763  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
764  i+= run;
765  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
766  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
767  LAST_SKIP_BITS(re, &s->gb, 1);
768  }
769  } else {
770  i+= run;
771  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
772  LAST_SKIP_BITS(re, &s->gb, 1);
773  }
774  if (i > 62){
775  i-= 192;
776  if(i&(~63)){
777  const int left= get_bits_left(&s->gb);
778  if (((i + 192 == 64 && level / qmul == -1) ||
780  left >= 0) {
781  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
782  break;
783  }else{
784  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
785  return -1;
786  }
787  }
788 
789  block[scan_table[i]] = level;
790  break;
791  }
792 
793  block[scan_table[i]] = level;
794  }
795  CLOSE_READER(re, &s->gb);
796  }
797  not_coded:
798  if (s->mb_intra) {
799  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
800  if (s->ac_pred) {
801  i = 63; /* XXX: not optimal */
802  }
803  }
804  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
805  s->block_last_index[n] = i;
806 
807  return 0;
808 }
809 
811  int *mx_ptr, int *my_ptr)
812 {
813  MVTable *mv;
814  int code, mx, my;
815 
816  mv = &ff_mv_tables[s->mv_table_index];
817 
818  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
819  if (code < 0){
820  av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
821  return -1;
822  }
823  if (code == mv->n) {
824  mx = get_bits(&s->gb, 6);
825  my = get_bits(&s->gb, 6);
826  } else {
827  mx = mv->table_mvx[code];
828  my = mv->table_mvy[code];
829  }
830 
831  mx += *mx_ptr - 32;
832  my += *my_ptr - 32;
833  /* WARNING : they do not do exactly modulo encoding */
834  if (mx <= -64)
835  mx += 64;
836  else if (mx >= 64)
837  mx -= 64;
838 
839  if (my <= -64)
840  my += 64;
841  else if (my >= 64)
842  my -= 64;
843  *mx_ptr = mx;
844  *my_ptr = my;
845  return 0;
846 }
847 
849  .name = "msmpeg4v1",
850  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
851  .type = AVMEDIA_TYPE_VIDEO,
852  .id = AV_CODEC_ID_MSMPEG4V1,
853  .priv_data_size = sizeof(MpegEncContext),
855  .close = ff_h263_decode_end,
858  .pix_fmts = (const enum AVPixelFormat[]) {
861  },
862 };
863 
865  .name = "msmpeg4v2",
866  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
867  .type = AVMEDIA_TYPE_VIDEO,
868  .id = AV_CODEC_ID_MSMPEG4V2,
869  .priv_data_size = sizeof(MpegEncContext),
871  .close = ff_h263_decode_end,
874  .pix_fmts = (const enum AVPixelFormat[]) {
877  },
878 };
879 
881  .name = "msmpeg4",
882  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
883  .type = AVMEDIA_TYPE_VIDEO,
884  .id = AV_CODEC_ID_MSMPEG4V3,
885  .priv_data_size = sizeof(MpegEncContext),
887  .close = ff_h263_decode_end,
890  .pix_fmts = (const enum AVPixelFormat[]) {
893  },
894 };
895 
897  .name = "wmv1",
898  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
899  .type = AVMEDIA_TYPE_VIDEO,
900  .id = AV_CODEC_ID_WMV1,
901  .priv_data_size = sizeof(MpegEncContext),
903  .close = ff_h263_decode_end,
906  .pix_fmts = (const enum AVPixelFormat[]) {
909  },
910 };
static VLC v2_mv_vlc
Definition: msmpeg4dec.c:68
#define DEFAULT_INTER_INDEX
Definition: msmpeg4dec.c:43
int inter_intra_pred
Definition: mpegvideo.h:427
#define MB_TYPE_SKIP
Definition: avcodec.h:1093
ScanTable intra_v_scantable
Definition: mpegvideo.h:88
#define V2_MV_VLC_BITS
Definition: msmpeg4dec.c:40
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4dec.c:72
int esc3_level_length
Definition: mpegvideo.h:423
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:63
VLC ff_inter_intra_vlc
Definition: msmpeg4dec.c:69
#define CBPY_VLC_BITS
Definition: h263.h:41
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:34
float re
Definition: fft.c:69
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
const uint32_t ff_table0_dc_lum[120][2]
Definition: msmpeg4data.c:100
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:97
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:57
static VLC v2_dc_lum_vlc
Definition: msmpeg4dec.c:64
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:35
VLC ff_h263_cbpy_vlc
Definition: ituh263dec.c:99
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:158
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:421
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
#define MB_TYPE_INTRA
Definition: mpegutils.h:75
static VLC v2_dc_chroma_vlc
Definition: msmpeg4dec.c:65
#define TEX_VLC_BITS
Definition: msmpeg4dec.c:41
#define AV_EF_BITSTREAM
Definition: avcodec.h:2679
mpegvideo header.
#define NB_RL_TABLES
Definition: msmpeg4data.h:60
uint8_t permutated[64]
Definition: idctdsp.h:31
uint8_t run
Definition: svq3.c:203
AVCodec.
Definition: avcodec.h:3120
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4.h:34
RLTable.
Definition: rl.h:39
int qscale
QP.
Definition: mpegvideo.h:199
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:105
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:309
static int16_t block[64]
Definition: dct.c:97
int esc3_run_length
Definition: mpegvideo.h:424
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
VC-1 tables.
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1791
uint8_t
#define av_cold
Definition: attributes.h:66
int ff_msmpeg4_decode_block(MpegEncContext *s, int16_t *block, int n, int coded, const uint8_t *scan_table)
Definition: msmpeg4dec.c:623
uint8_t ff_static_rl_table_store[NB_RL_TABLES][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: msmpeg4data.c:36
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2627
#define MBAC_BITRATE
Definition: msmpeg4.h:38
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Definition: mpegvideo.h:278
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:103
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:175
MSMPEG4 data tables.
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:182
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
const uint32_t ff_table0_dc_chroma[120][2]
Definition: msmpeg4data.c:133
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:124
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
Definition: msmpeg4dec.c:45
int flipflop_rounding
Definition: mpegvideo.h:420
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:526
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:149
const uint16_t ff_msmp4_mb_i_table[64][2]
Definition: msmpeg4data.c:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:180
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:189
int rl_chroma_table_index
Definition: mpegvideo.h:415
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:390
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:190
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:68
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:36
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
#define DC_VLC_BITS
Definition: msmpeg4dec.c:36
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
int per_mb_rl_table
Definition: mpegvideo.h:422
#define INTER_MCBPC_VLC_BITS
Definition: h263.h:40
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
GetBitContext gb
Definition: mpegvideo.h:431
#define CLOSE_READER(name, gb)
Definition: get_bits.h:129
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:64
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4dec.c:37
Definition: vlc.h:26
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:164
int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:53
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:98
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:373
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:832
const uint8_t ff_v2_mb_type[8][2]
Definition: msmpeg4data.c:1786
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:195
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2670
const uint8_t * table_mvx
Definition: msmpeg4data.h:43
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:448
int32_t
const uint8_t * table_mv_bits
Definition: msmpeg4data.h:42
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:250
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Definition: msmpeg4dec.c:566
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:170
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:493
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:81
const uint32_t ff_table1_dc_chroma[120][2]
Definition: msmpeg4data.c:201
int(* decode_mb)(struct MpegEncContext *s, int16_t block[6][64])
Definition: mpegvideo.h:478
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:49
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:176
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:538
static const float pred[4]
Definition: siprdata.h:259
static const int8_t mv[256][2]
Definition: 4xm.c:75
AVCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:848
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:260
NULL
Definition: eval.c:55
Libavcodec external API header.
#define ff_dlog(ctx,...)
Definition: internal.h:60
BlockDSPContext bdsp
Definition: mpegvideo.h:218
int debug
debug
Definition: avcodec.h:2626
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1956
AVCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:864
main external API structure.
Definition: avcodec.h:1409
static VLC v2_intra_cbpc_vlc
Definition: msmpeg4dec.c:66
ScanTable intra_scantable
Definition: mpegvideo.h:86
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:95
#define OPEN_READER(name, gb)
Definition: get_bits.h:118
const uint16_t * table_mv_code
Definition: msmpeg4data.h:41
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:38
#define DC_MAX
Definition: msmpeg4.h:40
const uint32_t ff_table1_dc_lum[120][2]
Definition: msmpeg4data.c:168
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4dec.c:38
ScanTable intra_h_scantable
Definition: mpegvideo.h:87
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:259
#define GET_CACHE(name, gb)
Definition: get_bits.h:180
#define MB_INTRA_VLC_BITS
Definition: msmpeg4.h:35
int slice_height
in macroblocks
Definition: mpegvideo.h:418
#define MB_TYPE_16x16
Definition: avcodec.h:1085
int use_skip_mb_code
Definition: mpegvideo.h:417
AVCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:896
MVTable ff_mv_tables[2]
Definition: msmpeg4data.c:1773
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:153
VLC vlc
Definition: msmpeg4data.h:46
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:300
#define MV_DIR_FORWARD
Definition: mpegvideo.h:256
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:206
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:257
int bit_rate
wanted bit rate
Definition: mpegvideo.h:98
#define II_BITRATE
Definition: msmpeg4.h:37
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:601
static VLC v2_mb_type_vlc
Definition: msmpeg4dec.c:67
uint8_t level
Definition: svq3.c:204
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:270
MpegEncContext.
Definition: mpegvideo.h:76
struct AVCodecContext * avctx
Definition: mpegvideo.h:93
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:177
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:59
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:125
AVCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:880
#define MV_VLC_BITS
Definition: msmpeg4dec.c:39
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:136
void * priv_data
Definition: avcodec.h:1451
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:476
static int decode012(GetBitContext *gb)
Definition: get_bits.h:508
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:810
#define CONFIG_WMV2_DECODER
Definition: config.h:712
int rl_table_index
Definition: mpegvideo.h:414
int chroma_qscale
chroma QP
Definition: mpegvideo.h:200
#define av_uninit(x)
Definition: attributes.h:109
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4.h:33
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
const uint8_t * table_mvy
Definition: msmpeg4data.h:44
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4data.c:38
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
Definition: mpegvideo.h:85
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:155
int mv_table_index
Definition: mpegvideo.h:413
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
Definition: mpegvideo.h:363
int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: wmv2dec.c:348
AVPixelFormat
Pixel format.
Definition: pixfmt.h:57
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1844
int dc_table_index
Definition: mpegvideo.h:416
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4data.c:39
#define MB_TYPE_L0
Definition: avcodec.h:1098
Predicted.
Definition: avutil.h:261
#define INTRA_MCBPC_VLC_BITS
Definition: h263.h:39
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:282
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4data.c:40
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:90