msmpeg4.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 
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "msmpeg4.h"
34 #include "libavutil/x86/asm.h"
35 #include "h263.h"
36 #include "mpeg4video.h"
37 #include "msmpeg4data.h"
38 #include "vc1data.h"
39 
40 /*
41  * You can also call this codec : MPEG4 with a twist !
42  *
43  * TODO:
44  * - (encoding) select best mv table (two choices)
45  * - (encoding) select best vlc/dc table
46  */
47 //#define DEBUG
48 
49 #define DC_VLC_BITS 9
50 #define V2_INTRA_CBPC_VLC_BITS 3
51 #define V2_MB_TYPE_VLC_BITS 7
52 #define MV_VLC_BITS 9
53 #define V2_MV_VLC_BITS 9
54 #define TEX_VLC_BITS 9
55 
56 #define DEFAULT_INTER_INDEX 3
57 
58 /* This table is practically identical to the one from h263
59  * except that it is inverted. */
61 {
62  int level, uni_code, uni_len;
63 
64  for(level=-256; level<256; level++){
65  int size, v, l;
66  /* find number of bits */
67  size = 0;
68  v = abs(level);
69  while (v) {
70  v >>= 1;
71  size++;
72  }
73 
74  if (level < 0)
75  l= (-level) ^ ((1 << size) - 1);
76  else
77  l= level;
78 
79  /* luminance h263 */
80  uni_code= ff_mpeg4_DCtab_lum[size][0];
81  uni_len = ff_mpeg4_DCtab_lum[size][1];
82  uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
83 
84  if (size > 0) {
85  uni_code<<=size; uni_code|=l;
86  uni_len+=size;
87  if (size > 8){
88  uni_code<<=1; uni_code|=1;
89  uni_len++;
90  }
91  }
92  ff_v2_dc_lum_table[level + 256][0] = uni_code;
93  ff_v2_dc_lum_table[level + 256][1] = uni_len;
94 
95  /* chrominance h263 */
96  uni_code= ff_mpeg4_DCtab_chrom[size][0];
97  uni_len = ff_mpeg4_DCtab_chrom[size][1];
98  uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
99 
100  if (size > 0) {
101  uni_code<<=size; uni_code|=l;
102  uni_len+=size;
103  if (size > 8){
104  uni_code<<=1; uni_code|=1;
105  uni_len++;
106  }
107  }
108  ff_v2_dc_chroma_table[level + 256][0] = uni_code;
109  ff_v2_dc_chroma_table[level + 256][1] = uni_len;
110 
111  }
112 }
113 
115 {
116  static int initialized=0;
117 
118  switch(s->msmpeg4_version){
119  case 1:
120  case 2:
121  s->y_dc_scale_table=
123  break;
124  case 3:
125  if(s->workaround_bugs){
128  } else{
131  }
132  break;
133  case 4:
134  case 5:
137  break;
138 #if CONFIG_VC1_DECODER
139  case 6:
142  break;
143 #endif
144 
145  }
146 
147 
148  if(s->msmpeg4_version>=4){
153  }
154  //Note the default tables are set in common_init in mpegvideo.c
155 
156  if(!initialized){
157  initialized=1;
158 
160  }
161 }
162 
163 /* predict coded block */
164 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
165 {
166  int xy, wrap, pred, a, b, c;
167 
168  xy = s->block_index[n];
169  wrap = s->b8_stride;
170 
171  /* B C
172  * A X
173  */
174  a = s->coded_block[xy - 1 ];
175  b = s->coded_block[xy - 1 - wrap];
176  c = s->coded_block[xy - wrap];
177 
178  if (b == c) {
179  pred = a;
180  } else {
181  pred = c;
182  }
183 
184  /* store value */
185  *coded_block_ptr = &s->coded_block[xy];
186 
187  return pred;
188 }
189 
190 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
191  int32_t **dc_val_ptr)
192 {
193  int i;
194 
195  if (n < 4) {
196  i= 0;
197  } else {
198  i= n-3;
199  }
200 
201  *dc_val_ptr= &s->last_dc[i];
202  return s->last_dc[i];
203 }
204 
205 static int get_dc(uint8_t *src, int stride, int scale)
206 {
207  int y;
208  int sum=0;
209  for(y=0; y<8; y++){
210  int x;
211  for(x=0; x<8; x++){
212  sum+=src[x + y*stride];
213  }
214  }
215  return FASTDIV((sum + (scale>>1)), scale);
216 }
217 
218 /* dir = 0: left, dir = 1: top prediction */
220  int16_t **dc_val_ptr, int *dir_ptr)
221 {
222  int a, b, c, wrap, pred, scale;
223  int16_t *dc_val;
224 
225  /* find prediction */
226  if (n < 4) {
227  scale = s->y_dc_scale;
228  } else {
229  scale = s->c_dc_scale;
230  }
231 
232  wrap = s->block_wrap[n];
233  dc_val= s->dc_val[0] + s->block_index[n];
234 
235  /* B C
236  * A X
237  */
238  a = dc_val[ - 1];
239  b = dc_val[ - 1 - wrap];
240  c = dc_val[ - wrap];
241 
242  if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
243  b=c=1024;
244  }
245 
246  /* XXX: the following solution consumes divisions, but it does not
247  necessitate to modify mpegvideo.c. The problem comes from the
248  fact they decided to store the quantized DC (which would lead
249  to problems if Q could vary !) */
250 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
251  __asm__ volatile(
252  "movl %3, %%eax \n\t"
253  "shrl $1, %%eax \n\t"
254  "addl %%eax, %2 \n\t"
255  "addl %%eax, %1 \n\t"
256  "addl %0, %%eax \n\t"
257  "mull %4 \n\t"
258  "movl %%edx, %0 \n\t"
259  "movl %1, %%eax \n\t"
260  "mull %4 \n\t"
261  "movl %%edx, %1 \n\t"
262  "movl %2, %%eax \n\t"
263  "mull %4 \n\t"
264  "movl %%edx, %2 \n\t"
265  : "+b" (a), "+c" (b), "+D" (c)
266  : "g" (scale), "S" (ff_inverse[scale])
267  : "%eax", "%edx"
268  );
269 #else
270  /* #elif ARCH_ALPHA */
271  /* Divisions are extremely costly on Alpha; optimize the most
272  common case. But they are costly everywhere...
273  */
274  if (scale == 8) {
275  a = (a + (8 >> 1)) / 8;
276  b = (b + (8 >> 1)) / 8;
277  c = (c + (8 >> 1)) / 8;
278  } else {
279  a = FASTDIV((a + (scale >> 1)), scale);
280  b = FASTDIV((b + (scale >> 1)), scale);
281  c = FASTDIV((c + (scale >> 1)), scale);
282  }
283 #endif
284  /* XXX: WARNING: they did not choose the same test as MPEG4. This
285  is very important ! */
286  if(s->msmpeg4_version>3){
287  if(s->inter_intra_pred){
288  uint8_t *dest;
289  int wrap;
290 
291  if(n==1){
292  pred=a;
293  *dir_ptr = 0;
294  }else if(n==2){
295  pred=c;
296  *dir_ptr = 1;
297  }else if(n==3){
298  if (abs(a - b) < abs(b - c)) {
299  pred = c;
300  *dir_ptr = 1;
301  } else {
302  pred = a;
303  *dir_ptr = 0;
304  }
305  }else{
306  if(n<4){
307  wrap= s->linesize;
308  dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8* wrap ) + ((n & 1) + 2*s->mb_x) * 8;
309  }else{
310  wrap= s->uvlinesize;
311  dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
312  }
313  if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
314  else a= get_dc(dest-8, wrap, scale*8);
315  if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
316  else c= get_dc(dest-8*wrap, wrap, scale*8);
317 
318  if (s->h263_aic_dir==0) {
319  pred= a;
320  *dir_ptr = 0;
321  }else if (s->h263_aic_dir==1) {
322  if(n==0){
323  pred= c;
324  *dir_ptr = 1;
325  }else{
326  pred= a;
327  *dir_ptr = 0;
328  }
329  }else if (s->h263_aic_dir==2) {
330  if(n==0){
331  pred= a;
332  *dir_ptr = 0;
333  }else{
334  pred= c;
335  *dir_ptr = 1;
336  }
337  } else {
338  pred= c;
339  *dir_ptr = 1;
340  }
341  }
342  }else{
343  if (abs(a - b) < abs(b - c)) {
344  pred = c;
345  *dir_ptr = 1;
346  } else {
347  pred = a;
348  *dir_ptr = 0;
349  }
350  }
351  }else{
352  if (abs(a - b) <= abs(b - c)) {
353  pred = c;
354  *dir_ptr = 1;
355  } else {
356  pred = a;
357  *dir_ptr = 0;
358  }
359  }
360 
361  /* update predictor */
362  *dc_val_ptr = &dc_val[0];
363  return pred;
364 }
365 
366 /****************************************/
367 /* decoding stuff */
368 
374 static VLC v2_mv_vlc;
376 
377 /* This is identical to h263 except that its range is multiplied by 2. */
378 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
379 {
380  int code, val, sign, shift;
381 
382  code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
383  av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
384  if (code < 0)
385  return 0xffff;
386 
387  if (code == 0)
388  return pred;
389  sign = get_bits1(&s->gb);
390  shift = f_code - 1;
391  val = code;
392  if (shift) {
393  val = (val - 1) << shift;
394  val |= get_bits(&s->gb, shift);
395  val++;
396  }
397  if (sign)
398  val = -val;
399 
400  val += pred;
401  if (val <= -64)
402  val += 64;
403  else if (val >= 64)
404  val -= 64;
405 
406  return val;
407 }
408 
410 {
411  int cbp, code, i;
412 
413  if (s->pict_type == AV_PICTURE_TYPE_P) {
414  if (s->use_skip_mb_code) {
415  if (get_bits1(&s->gb)) {
416  /* skip mb */
417  s->mb_intra = 0;
418  for(i=0;i<6;i++)
419  s->block_last_index[i] = -1;
420  s->mv_dir = MV_DIR_FORWARD;
421  s->mv_type = MV_TYPE_16X16;
422  s->mv[0][0][0] = 0;
423  s->mv[0][0][1] = 0;
424  s->mb_skipped = 1;
425  return 0;
426  }
427  }
428 
429  if(s->msmpeg4_version==2)
430  code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
431  else
433  if(code<0 || code>7){
434  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
435  return -1;
436  }
437 
438  s->mb_intra = code >>2;
439 
440  cbp = code & 0x3;
441  } else {
442  s->mb_intra = 1;
443  if(s->msmpeg4_version==2)
444  cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
445  else
447  if(cbp<0 || cbp>3){
448  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
449  return -1;
450  }
451  }
452 
453  if (!s->mb_intra) {
454  int mx, my, cbpy;
455 
457  if(cbpy<0){
458  av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
459  return -1;
460  }
461 
462  cbp|= cbpy<<2;
463  if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
464 
465  ff_h263_pred_motion(s, 0, 0, &mx, &my);
466  mx= msmpeg4v2_decode_motion(s, mx, 1);
467  my= msmpeg4v2_decode_motion(s, my, 1);
468 
469  s->mv_dir = MV_DIR_FORWARD;
470  s->mv_type = MV_TYPE_16X16;
471  s->mv[0][0][0] = mx;
472  s->mv[0][0][1] = my;
473  } else {
474  if(s->msmpeg4_version==2){
475  s->ac_pred = get_bits1(&s->gb);
476  cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
477  } else{
478  s->ac_pred = 0;
479  cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
480  if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
481  }
482  }
483 
484  s->dsp.clear_blocks(s->block[0]);
485  for (i = 0; i < 6; i++) {
486  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
487  {
488  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
489  return -1;
490  }
491  }
492  return 0;
493 }
494 
496 {
497  int cbp, code, i;
498  uint8_t *coded_val;
499  uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
500 
501  if (s->pict_type == AV_PICTURE_TYPE_P) {
502  if (s->use_skip_mb_code) {
503  if (get_bits1(&s->gb)) {
504  /* skip mb */
505  s->mb_intra = 0;
506  for(i=0;i<6;i++)
507  s->block_last_index[i] = -1;
508  s->mv_dir = MV_DIR_FORWARD;
509  s->mv_type = MV_TYPE_16X16;
510  s->mv[0][0][0] = 0;
511  s->mv[0][0][1] = 0;
512  s->mb_skipped = 1;
513  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
514 
515  return 0;
516  }
517  }
518 
519  code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
520  if (code < 0)
521  return -1;
522  //s->mb_intra = (code & 0x40) ? 0 : 1;
523  s->mb_intra = (~code & 0x40) >> 6;
524 
525  cbp = code & 0x3f;
526  } else {
527  s->mb_intra = 1;
529  if (code < 0)
530  return -1;
531  /* predict coded block pattern */
532  cbp = 0;
533  for(i=0;i<6;i++) {
534  int val = ((code >> (5 - i)) & 1);
535  if (i < 4) {
536  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
537  val = val ^ pred;
538  *coded_val = val;
539  }
540  cbp |= val << (5 - i);
541  }
542  }
543 
544  if (!s->mb_intra) {
545  int mx, my;
546  if(s->per_mb_rl_table && cbp){
547  s->rl_table_index = decode012(&s->gb);
549  }
550  ff_h263_pred_motion(s, 0, 0, &mx, &my);
551  if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
552  return -1;
553  s->mv_dir = MV_DIR_FORWARD;
554  s->mv_type = MV_TYPE_16X16;
555  s->mv[0][0][0] = mx;
556  s->mv[0][0][1] = my;
557  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
558  } else {
559  av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
560  ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
561  show_bits(&s->gb, 24));
562  s->ac_pred = get_bits1(&s->gb);
563  *mb_type_ptr = MB_TYPE_INTRA;
564  if(s->inter_intra_pred){
565  s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
566  av_dlog(s, "%d%d %d %d/",
567  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
568  }
569  if(s->per_mb_rl_table && cbp){
570  s->rl_table_index = decode012(&s->gb);
572  }
573  }
574 
575  s->dsp.clear_blocks(s->block[0]);
576  for (i = 0; i < 6; i++) {
577  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
578  {
579  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
580  return -1;
581  }
582  }
583 
584  return 0;
585 }
586 
587 /* init all vlc decoding tables */
589 {
590  MpegEncContext *s = avctx->priv_data;
591  static int done = 0;
592  int i;
593  MVTable *mv;
594 
595  if (ff_h263_decode_init(avctx) < 0)
596  return -1;
597 
599 
600  if (!done) {
601  done = 1;
602 
603  for(i=0;i<NB_RL_TABLES;i++) {
605  }
606  INIT_VLC_RL(ff_rl_table[0], 642);
607  INIT_VLC_RL(ff_rl_table[1], 1104);
608  INIT_VLC_RL(ff_rl_table[2], 554);
609  INIT_VLC_RL(ff_rl_table[3], 940);
610  INIT_VLC_RL(ff_rl_table[4], 962);
611  INIT_VLC_RL(ff_rl_table[5], 554);
612 
613  mv = &ff_mv_tables[0];
614  INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
615  mv->table_mv_bits, 1, 1,
616  mv->table_mv_code, 2, 2, 3714);
617  mv = &ff_mv_tables[1];
618  INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
619  mv->table_mv_bits, 1, 1,
620  mv->table_mv_code, 2, 2, 2694);
621 
623  &ff_table0_dc_lum[0][1], 8, 4,
624  &ff_table0_dc_lum[0][0], 8, 4, 1158);
626  &ff_table0_dc_chroma[0][1], 8, 4,
627  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
629  &ff_table1_dc_lum[0][1], 8, 4,
630  &ff_table1_dc_lum[0][0], 8, 4, 1476);
632  &ff_table1_dc_chroma[0][1], 8, 4,
633  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
634 
635  INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
636  &ff_v2_dc_lum_table[0][1], 8, 4,
637  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
638  INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
639  &ff_v2_dc_chroma_table[0][1], 8, 4,
640  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
641 
642  INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
643  &ff_v2_intra_cbpc[0][1], 2, 1,
644  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
645  INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
646  &ff_v2_mb_type[0][1], 2, 1,
647  &ff_v2_mb_type[0][0], 2, 1, 128);
648  INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
649  &ff_mvtab[0][1], 2, 1,
650  &ff_mvtab[0][0], 2, 1, 538);
651 
652  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
653  &ff_wmv2_inter_table[0][0][1], 8, 4,
654  &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
655  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
656  &ff_wmv2_inter_table[1][0][1], 8, 4,
657  &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
658  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
659  &ff_wmv2_inter_table[2][0][1], 8, 4,
660  &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
661  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
662  &ff_wmv2_inter_table[3][0][1], 8, 4,
663  &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
664 
666  &ff_msmp4_mb_i_table[0][1], 4, 2,
667  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
668 
669  INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
670  &ff_table_inter_intra[0][1], 2, 1,
671  &ff_table_inter_intra[0][0], 2, 1, 8);
672  }
673 
674  switch(s->msmpeg4_version){
675  case 1:
676  case 2:
678  break;
679  case 3:
680  case 4:
682  break;
683  case 5:
686  case 6:
687  //FIXME + TODO VC1 decode mb
688  break;
689  }
690 
691  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
692 
693  return 0;
694 }
695 
697 {
698  int code;
699 
700  if(s->msmpeg4_version==1){
701  int start_code = get_bits_long(&s->gb, 32);
702  if(start_code!=0x00000100){
703  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
704  return -1;
705  }
706 
707  skip_bits(&s->gb, 5); // frame number */
708  }
709 
710  s->pict_type = get_bits(&s->gb, 2) + 1;
711  if (s->pict_type != AV_PICTURE_TYPE_I &&
713  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
714  return -1;
715  }
716 #if 0
717 {
718  static int had_i=0;
719  if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
720  if(!had_i) return -1;
721 }
722 #endif
723  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
724  if(s->qscale==0){
725  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
726  return -1;
727  }
728 
729  if (s->pict_type == AV_PICTURE_TYPE_I) {
730  code = get_bits(&s->gb, 5);
731  if(s->msmpeg4_version==1){
732  if(code==0 || code>s->mb_height){
733  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
734  return -1;
735  }
736 
737  s->slice_height = code;
738  }else{
739  /* 0x17: one slice, 0x18: two slices, ... */
740  if (code < 0x17){
741  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
742  return -1;
743  }
744 
745  s->slice_height = s->mb_height / (code - 0x16);
746  }
747 
748  switch(s->msmpeg4_version){
749  case 1:
750  case 2:
751  s->rl_chroma_table_index = 2;
752  s->rl_table_index = 2;
753 
754  s->dc_table_index = 0; //not used
755  break;
756  case 3:
758  s->rl_table_index = decode012(&s->gb);
759 
760  s->dc_table_index = get_bits1(&s->gb);
761  break;
762  case 4:
763  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
764 
766  else s->per_mb_rl_table= 0;
767 
768  if(!s->per_mb_rl_table){
770  s->rl_table_index = decode012(&s->gb);
771  }
772 
773  s->dc_table_index = get_bits1(&s->gb);
774  s->inter_intra_pred= 0;
775  break;
776  }
777  s->no_rounding = 1;
779  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
780  s->qscale,
782  s->rl_table_index,
783  s->dc_table_index,
784  s->per_mb_rl_table,
785  s->slice_height);
786  } else {
787  switch(s->msmpeg4_version){
788  case 1:
789  case 2:
790  if(s->msmpeg4_version==1)
791  s->use_skip_mb_code = 1;
792  else
793  s->use_skip_mb_code = get_bits1(&s->gb);
794  s->rl_table_index = 2;
796  s->dc_table_index = 0; //not used
797  s->mv_table_index = 0;
798  break;
799  case 3:
800  s->use_skip_mb_code = get_bits1(&s->gb);
801  s->rl_table_index = decode012(&s->gb);
803 
804  s->dc_table_index = get_bits1(&s->gb);
805 
806  s->mv_table_index = get_bits1(&s->gb);
807  break;
808  case 4:
809  s->use_skip_mb_code = get_bits1(&s->gb);
810 
812  else s->per_mb_rl_table= 0;
813 
814  if(!s->per_mb_rl_table){
815  s->rl_table_index = decode012(&s->gb);
817  }
818 
819  s->dc_table_index = get_bits1(&s->gb);
820 
821  s->mv_table_index = get_bits1(&s->gb);
822  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
823  break;
824  }
825 
827  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
828  s->use_skip_mb_code,
829  s->rl_table_index,
831  s->dc_table_index,
832  s->mv_table_index,
833  s->per_mb_rl_table,
834  s->qscale);
835 
836  if(s->flipflop_rounding){
837  s->no_rounding ^= 1;
838  }else{
839  s->no_rounding = 0;
840  }
841  }
842  av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
843  s->inter_intra_pred, s->width, s->height);
844 
845  s->esc3_level_length= 0;
846  s->esc3_run_length= 0;
847 
848  return 0;
849 }
850 
852 {
853  int left= buf_size*8 - get_bits_count(&s->gb);
854  int length= s->msmpeg4_version>=3 ? 17 : 16;
855  /* the alt_bitstream reader could read over the end so we need to check it */
856  if(left>=length && left<length+8)
857  {
858  skip_bits(&s->gb, 5); /* fps */
859  s->bit_rate= get_bits(&s->gb, 11)*1024;
860  if(s->msmpeg4_version>=3)
861  s->flipflop_rounding= get_bits1(&s->gb);
862  else
863  s->flipflop_rounding= 0;
864  }
865  else if(left<length+8)
866  {
867  s->flipflop_rounding= 0;
868  if(s->msmpeg4_version != 2)
869  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
870  }
871  else
872  {
873  av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
874  }
875 
876  return 0;
877 }
878 
879 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
880 {
881  int level, pred;
882 
883  if(s->msmpeg4_version<=2){
884  if (n < 4) {
885  level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
886  } else {
887  level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
888  }
889  if (level < 0)
890  return -1;
891  level-=256;
892  }else{ //FIXME optimize use unified tables & index
893  if (n < 4) {
895  } else {
897  }
898  if (level < 0){
899  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
900  return -1;
901  }
902 
903  if (level == DC_MAX) {
904  level = get_bits(&s->gb, 8);
905  if (get_bits1(&s->gb))
906  level = -level;
907  } else if (level != 0) {
908  if (get_bits1(&s->gb))
909  level = -level;
910  }
911  }
912 
913  if(s->msmpeg4_version==1){
914  int32_t *dc_val;
915  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
916  level += pred;
917 
918  /* update predictor */
919  *dc_val= level;
920  }else{
921  int16_t *dc_val;
922  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
923  level += pred;
924 
925  /* update predictor */
926  if (n < 4) {
927  *dc_val = level * s->y_dc_scale;
928  } else {
929  *dc_val = level * s->c_dc_scale;
930  }
931  }
932 
933  return level;
934 }
935 
936 //#define ERROR_DETAILS
938  int n, int coded, const uint8_t *scan_table)
939 {
940  int level, i, last, run, run_diff;
941  int av_uninit(dc_pred_dir);
942  RLTable *rl;
943  RL_VLC_ELEM *rl_vlc;
944  int qmul, qadd;
945 
946  if (s->mb_intra) {
947  qmul=1;
948  qadd=0;
949 
950  /* DC coef */
951  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
952 
953  if (level < 0){
954  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
955  if(s->inter_intra_pred) level=0;
956  else return -1;
957  }
958  if (n < 4) {
959  rl = &ff_rl_table[s->rl_table_index];
960  if(level > 256*s->y_dc_scale){
961  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
962  if(!s->inter_intra_pred) return -1;
963  }
964  } else {
965  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
966  if(level > 256*s->c_dc_scale){
967  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
968  if(!s->inter_intra_pred) return -1;
969  }
970  }
971  block[0] = level;
972 
973  run_diff = s->msmpeg4_version >= 4;
974  i = 0;
975  if (!coded) {
976  goto not_coded;
977  }
978  if (s->ac_pred) {
979  if (dc_pred_dir == 0)
980  scan_table = s->intra_v_scantable.permutated; /* left */
981  else
982  scan_table = s->intra_h_scantable.permutated; /* top */
983  } else {
984  scan_table = s->intra_scantable.permutated;
985  }
986  rl_vlc= rl->rl_vlc[0];
987  } else {
988  qmul = s->qscale << 1;
989  qadd = (s->qscale - 1) | 1;
990  i = -1;
991  rl = &ff_rl_table[3 + s->rl_table_index];
992 
993  if(s->msmpeg4_version==2)
994  run_diff = 0;
995  else
996  run_diff = 1;
997 
998  if (!coded) {
999  s->block_last_index[n] = i;
1000  return 0;
1001  }
1002  if(!scan_table)
1003  scan_table = s->inter_scantable.permutated;
1004  rl_vlc= rl->rl_vlc[s->qscale];
1005  }
1006  {
1007  OPEN_READER(re, &s->gb);
1008  for(;;) {
1009  UPDATE_CACHE(re, &s->gb);
1010  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1011  if (level==0) {
1012  int cache;
1013  cache= GET_CACHE(re, &s->gb);
1014  /* escape */
1015  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1016  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1017  /* third escape */
1018  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1019  UPDATE_CACHE(re, &s->gb);
1020  if(s->msmpeg4_version<=3){
1021  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1022  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1023  level= SHOW_SBITS(re, &s->gb, 8);
1024  SKIP_COUNTER(re, &s->gb, 1+6+8);
1025  }else{
1026  int sign;
1027  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1028  if(!s->esc3_level_length){
1029  int ll;
1030  av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1031  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1032  if(s->qscale<8){
1033  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1034  if(ll==0){
1035  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1036  }
1037  }else{
1038  ll=2;
1039  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1040  ll++;
1041  SKIP_BITS(re, &s->gb, 1);
1042  }
1043  if(ll<8) SKIP_BITS(re, &s->gb, 1);
1044  }
1045 
1046  s->esc3_level_length= ll;
1047  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1048  UPDATE_CACHE(re, &s->gb);
1049  }
1050  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1051  SKIP_BITS(re, &s->gb, s->esc3_run_length);
1052 
1053  sign= SHOW_UBITS(re, &s->gb, 1);
1054  SKIP_BITS(re, &s->gb, 1);
1055 
1056  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1057  SKIP_BITS(re, &s->gb, s->esc3_level_length);
1058  if(sign) level= -level;
1059  }
1060 
1061 #if 0 // waste of time / this will detect very few errors
1062  {
1063  const int abs_level= FFABS(level);
1064  const int run1= run - rl->max_run[last][abs_level] - run_diff;
1065  if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1066  if(abs_level <= rl->max_level[last][run]){
1067  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1068  return DECODING_AC_LOST;
1069  }
1070  if(abs_level <= rl->max_level[last][run]*2){
1071  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1072  return DECODING_AC_LOST;
1073  }
1074  if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1075  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1076  return DECODING_AC_LOST;
1077  }
1078  }
1079  }
1080 #endif
1081  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1082  if (level>0) level= level * qmul + qadd;
1083  else level= level * qmul - qadd;
1084 #if 0 // waste of time too :(
1085  if(level>2048 || level<-2048){
1086  av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1087  return DECODING_AC_LOST;
1088  }
1089 #endif
1090  i+= run + 1;
1091  if(last) i+=192;
1092 #ifdef ERROR_DETAILS
1093  if(run==66)
1094  av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1095  else if((i>62 && i<192) || i>192+63)
1096  av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1097 #endif
1098  } else {
1099  /* second escape */
1100  SKIP_BITS(re, &s->gb, 2);
1101  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1102  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1103  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1104  LAST_SKIP_BITS(re, &s->gb, 1);
1105 #ifdef ERROR_DETAILS
1106  if(run==66)
1107  av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1108  else if((i>62 && i<192) || i>192+63)
1109  av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1110 #endif
1111  }
1112  } else {
1113  /* first escape */
1114  SKIP_BITS(re, &s->gb, 1);
1115  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1116  i+= run;
1117  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1118  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1119  LAST_SKIP_BITS(re, &s->gb, 1);
1120 #ifdef ERROR_DETAILS
1121  if(run==66)
1122  av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1123  else if((i>62 && i<192) || i>192+63)
1124  av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1125 #endif
1126  }
1127  } else {
1128  i+= run;
1129  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1130  LAST_SKIP_BITS(re, &s->gb, 1);
1131 #ifdef ERROR_DETAILS
1132  if(run==66)
1133  av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1134  else if((i>62 && i<192) || i>192+63)
1135  av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1136 #endif
1137  }
1138  if (i > 62){
1139  i-= 192;
1140  if(i&(~63)){
1141  const int left= get_bits_left(&s->gb);
1142  if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&AV_EF_BITSTREAM)) && left>=0){
1143  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1144  break;
1145  }else{
1146  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1147  return -1;
1148  }
1149  }
1150 
1151  block[scan_table[i]] = level;
1152  break;
1153  }
1154 
1155  block[scan_table[i]] = level;
1156  }
1157  CLOSE_READER(re, &s->gb);
1158  }
1159  not_coded:
1160  if (s->mb_intra) {
1161  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1162  if (s->ac_pred) {
1163  i = 63; /* XXX: not optimal */
1164  }
1165  }
1166  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1167  s->block_last_index[n] = i;
1168 
1169  return 0;
1170 }
1171 
1173  int *mx_ptr, int *my_ptr)
1174 {
1175  MVTable *mv;
1176  int code, mx, my;
1177 
1178  mv = &ff_mv_tables[s->mv_table_index];
1179 
1180  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1181  if (code < 0){
1182  av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1183  return -1;
1184  }
1185  if (code == mv->n) {
1186  mx = get_bits(&s->gb, 6);
1187  my = get_bits(&s->gb, 6);
1188  } else {
1189  mx = mv->table_mvx[code];
1190  my = mv->table_mvy[code];
1191  }
1192 
1193  mx += *mx_ptr - 32;
1194  my += *my_ptr - 32;
1195  /* WARNING : they do not do exactly modulo encoding */
1196  if (mx <= -64)
1197  mx += 64;
1198  else if (mx >= 64)
1199  mx -= 64;
1200 
1201  if (my <= -64)
1202  my += 64;
1203  else if (my >= 64)
1204  my -= 64;
1205  *mx_ptr = mx;
1206  *my_ptr = my;
1207  return 0;
1208 }
1209 
1211  .name = "msmpeg4v1",
1212  .type = AVMEDIA_TYPE_VIDEO,
1213  .id = AV_CODEC_ID_MSMPEG4V1,
1214  .priv_data_size = sizeof(MpegEncContext),
1218  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1219  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1220  .pix_fmts = ff_pixfmt_list_420,
1221 };
1222 
1224  .name = "msmpeg4v2",
1225  .type = AVMEDIA_TYPE_VIDEO,
1226  .id = AV_CODEC_ID_MSMPEG4V2,
1227  .priv_data_size = sizeof(MpegEncContext),
1231  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1232  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1233  .pix_fmts = ff_pixfmt_list_420,
1234 };
1235 
1237  .name = "msmpeg4",
1238  .type = AVMEDIA_TYPE_VIDEO,
1239  .id = AV_CODEC_ID_MSMPEG4V3,
1240  .priv_data_size = sizeof(MpegEncContext),
1244  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1245  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1246  .pix_fmts = ff_pixfmt_list_420,
1247 };
1248 
1250  .name = "wmv1",
1251  .type = AVMEDIA_TYPE_VIDEO,
1252  .id = AV_CODEC_ID_WMV1,
1253  .priv_data_size = sizeof(MpegEncContext),
1257  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1258  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1259  .pix_fmts = ff_pixfmt_list_420,
1260 };
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4.c:588
int inter_intra_pred
Definition: mpegvideo.h:610
void ff_mpeg4_pred_ac(MpegEncContext *s, DCTELEM *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:80
ScanTable intra_v_scantable
Definition: mpegvideo.h:269
int size
const uint8_t ff_mpeg4_c_dc_scale_table[32]
Definition: mpeg4data.h:363
int esc3_level_length
Definition: mpegvideo.h:606
struct MpegEncContext MpegEncContext
MpegEncContext.
#define CBPY_VLC_BITS
Definition: h263.h:35
#define DC_VLC_BITS
Definition: msmpeg4.c:49
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:325
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:32
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
VLC ff_inter_intra_vlc
Definition: msmpeg4.c:375
const uint32_t ff_table0_dc_lum[120][2]
Definition: msmpeg4data.c:98
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:94
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:33
VLC ff_h263_cbpy_vlc
Definition: ituh263dec.c:96
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:169
static VLC v2_mv_vlc
Definition: msmpeg4.c:374
#define TEX_VLC_BITS
Definition: msmpeg4.c:54
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:604
void ff_init_rl(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: mpegvideo.c:1250
AVCodec ff_msmpeg4v2_decoder
Definition: msmpeg4.c:1223
int ff_msmpeg4_decode_block(MpegEncContext *s, DCTELEM *block, int n, int coded, const uint8_t *scan_table)
Definition: msmpeg4.c:937
#define wrap(func)
Definition: w64xmmtest.h:70
mpegvideo header.
#define DEFAULT_INTER_INDEX
Definition: msmpeg4.c:56
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", 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 NB_RL_TABLES
Definition: msmpeg4data.h:59
uint8_t permutated[64]
Definition: dsputil.h:183
uint8_t run
Definition: svq3.c:132
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2960
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4.h:35
RLTable.
Definition: rl.h:38
int qscale
QP.
Definition: mpegvideo.h:343
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:114
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:316
int block_wrap[6]
Definition: mpegvideo.h:435
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: msmpeg4.c:495
#define CONFIG_WMV2_DECODER
Definition: config.h:525
int esc3_run_length
Definition: mpegvideo.h:607
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:46
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4.c:369
VC-1 tables.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
#define MB_TYPE_INTRA
Definition: mpegvideo.h:105
const uint32_t ff_inverse[257]
Definition: mathtables.c:23
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1813
uint8_t
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:436
uint8_t ff_static_rl_table_store[NB_RL_TABLES][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: msmpeg4data.c:34
const uint8_t ff_mvtab[33][2]
Definition: h263data.h:91
static VLC v2_dc_lum_vlc
Definition: msmpeg4.c:370
#define b
Definition: input.c:52
const uint8_t ff_wmv3_dc_scale_table[32]
Definition: vc1data.c:648
#define MBAC_BITRATE
Definition: msmpeg4.h:39
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:408
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:314
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
Definition: mpeg4data.h:41
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Definition: msmpeg4.c:879
int ff_wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: wmv2dec.c:334
MSMPEG4 data tables.
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:45
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:425
const uint32_t ff_table0_dc_chroma[120][2]
Definition: msmpeg4data.c:131
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:248
enum AVPixelFormat ff_pixfmt_list_420[]
Definition: mpegvideo.c:128
const uint8_t ff_wmv1_c_dc_scale_table[32]
Definition: msmpeg4data.c:1821
#define MAX_LEVEL
Definition: rl.h:35
int flipflop_rounding
Definition: mpegvideo.h:603
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:547
int16_t * dc_val[3]
used for mpeg4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:324
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:160
const uint16_t ff_msmp4_mb_i_table[64][2]
Definition: msmpeg4data.c:41
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:322
int rl_chroma_table_index
Definition: mpegvideo.h:598
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:332
AVCodec ff_wmv1_decoder
Definition: msmpeg4.c:1249
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
int per_mb_rl_table
Definition: mpegvideo.h:605
#define INTER_MCBPC_VLC_BITS
Definition: h263.h:34
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
GetBitContext gb
Definition: mpegvideo.h:614
#define CLOSE_READER(name, gb)
Definition: get_bits.h:140
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
Definition: msmpeg4.c:190
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:59
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4.c:51
Definition: get_bits.h:63
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:175
int(* decode_mb)(struct MpegEncContext *s, DCTELEM block[6][64])
Definition: mpegvideo.h:664
int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:45
const uint8_t ff_mpeg4_DCtab_lum[13][2]
Definition: mpeg4data.h:35
const uint8_t ff_wmv1_scantable[WMV1_SCANTABLE_COUNT][64]
Definition: msmpeg4data.c:1831
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:95
int err_recognition
Definition: mpegvideo.h:498
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:342
const uint8_t ff_v2_mb_type[8][2]
Definition: msmpeg4data.c:1808
static DCTELEM block[64]
Definition: dct-test.c:169
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:219
const uint8_t * table_mvx
Definition: msmpeg4data.h:42
const uint8_t ff_mpeg4_y_dc_scale_table[32]
Definition: mpeg4data.h:359
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4.c:50
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:481
int32_t
const uint8_t * table_mv_bits
Definition: msmpeg4data.h:41
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4.c:851
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:180
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:515
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:262
const uint32_t ff_table1_dc_chroma[120][2]
Definition: msmpeg4data.c:199
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:186
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:434
static const float pred[4]
Definition: siprdata.h:259
static const int8_t mv[256][2]
Definition: 4xm.c:73
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
Definition: avcodec.h:1180
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:390
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:602
AVCodec ff_msmpeg4v1_decoder
Definition: msmpeg4.c:1210
NULL
Definition: eval.c:52
external API header
int debug
debug
Definition: avcodec.h:2568
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
#define FASTDIV(a, b)
Definition: mathops.h:195
ScanTable intra_scantable
Definition: mpegvideo.h:267
uint8_t * coded_block
used for coded block pattern prediction (msmpeg4v3, wmv1)
Definition: mpegvideo.h:329
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:216
#define V2_MV_VLC_BITS
Definition: msmpeg4.c:53
#define OPEN_READER(name, gb)
Definition: get_bits.h:124
const uint16_t * table_mv_code
Definition: msmpeg4data.h:40
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:73
#define DC_MAX
Definition: msmpeg4.h:41
const uint32_t ff_table1_dc_lum[120][2]
Definition: msmpeg4data.c:166
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
ScanTable intra_h_scantable
Definition: mpegvideo.h:268
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
int ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4.c:1172
#define GET_CACHE(name, gb)
Definition: get_bits.h:190
#define MB_INTRA_VLC_BITS
Definition: msmpeg4.h:36
int slice_height
in macroblocks
Definition: mpegvideo.h:601
int use_skip_mb_code
Definition: mpegvideo.h:600
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:362
MVTable ff_mv_tables[2]
Definition: msmpeg4data.c:1791
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:164
VLC vlc
Definition: msmpeg4data.h:45
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4.c:378
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:301
short DCTELEM
Definition: dsputil.h:39
#define MV_DIR_FORWARD
Definition: mpegvideo.h:386
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:350
int bit_rate
wanted bit rate
Definition: mpegvideo.h:219
DCTELEM(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:662
#define II_BITRATE
Definition: msmpeg4.h:38
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:607
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4.c:696
static const uint16_t scale[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:326
uint8_t level
Definition: svq3.c:133
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:400
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:250
void(* clear_blocks)(DCTELEM *blocks)
Definition: dsputil.h:219
MpegEncContext.
Definition: mpegvideo.h:212
#define MAX_RUN
Definition: rl.h:34
struct AVCodecContext * avctx
Definition: mpegvideo.h:214
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:187
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:249
DSP utils.
const uint8_t ff_wmv1_y_dc_scale_table[32]
Definition: msmpeg4data.c:1817
int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:125
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1986
void * priv_data
Definition: avcodec.h:1382
float re
Definition: fft-test.c:64
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: dsputil.c:122
#define MV_VLC_BITS
Definition: msmpeg4.c:52
static int decode012(GetBitContext *gb)
Definition: get_bits.h:529
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
static VLC v2_intra_cbpc_vlc
Definition: msmpeg4.c:372
int linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:254
int rl_table_index
Definition: mpegvideo.h:597
int chroma_qscale
chroma QP
Definition: mpegvideo.h:344
struct AVFrame f
Definition: mpegvideo.h:96
const uint8_t ff_old_ff_y_dc_scale_table[32]
Definition: msmpeg4data.c:1826
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4.h:34
const uint8_t * table_mvy
Definition: msmpeg4data.h:43
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4data.c:36
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:237
ScanTable inter_scantable
if inter == intra then intra should be used to reduce tha cache usage
Definition: mpegvideo.h:266
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:164
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: msmpeg4.c:409
int mv_table_index
Definition: mpegvideo.h:596
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
Definition: mpegvideo.h:513
int uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:255
static av_cold void init_h263_dc_for_msmpeg4(void)
Definition: msmpeg4.c:60
AVCodec ff_msmpeg4v3_decoder
Definition: msmpeg4.c:1236
static VLC v2_dc_chroma_vlc
Definition: msmpeg4.c:371
static VLC v2_mb_type_vlc
Definition: msmpeg4.c:373
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1874
int dc_table_index
Definition: mpegvideo.h:599
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4data.c:37
Predicted.
Definition: avutil.h:246
#define INTRA_MCBPC_VLC_BITS
Definition: h263.h:33
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4data.c:38
static int get_dc(uint8_t *src, int stride, int scale)
Definition: msmpeg4.c:205