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 };