FFmpeg
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-2013 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "libavutil/imgutils.h"
31 #include "h263.h"
32 #include "mpeg4video.h"
33 #include "msmpeg4data.h"
34 #include "vc1data.h"
35 #include "wmv2.h"
36 
37 #define DC_VLC_BITS 9
38 #define V2_INTRA_CBPC_VLC_BITS 3
39 #define V2_MB_TYPE_VLC_BITS 7
40 #define 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 
69 
70 /* This is identical to H.263 except that its range is multiplied by 2. */
71 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
72 {
73  int code, val, sign, shift;
74 
76  ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
77  if (code < 0)
78  return 0xffff;
79 
80  if (code == 0)
81  return pred;
82  sign = get_bits1(&s->gb);
83  shift = f_code - 1;
84  val = code;
85  if (shift) {
86  val = (val - 1) << shift;
87  val |= get_bits(&s->gb, shift);
88  val++;
89  }
90  if (sign)
91  val = -val;
92 
93  val += pred;
94  if (val <= -64)
95  val += 64;
96  else if (val >= 64)
97  val -= 64;
98 
99  return val;
100 }
101 
102 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
103 {
104  int cbp, code, i;
105  uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
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  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
120  return 0;
121  }
122  }
123 
124  if(s->msmpeg4_version==2)
125  code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
126  else
128  if(code<0 || code>7){
129  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
130  return -1;
131  }
132 
133  s->mb_intra = code >>2;
134 
135  cbp = code & 0x3;
136  } else {
137  s->mb_intra = 1;
138  if(s->msmpeg4_version==2)
139  cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
140  else
142  if(cbp<0 || cbp>3){
143  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
144  return -1;
145  }
146  }
147 
148  if (!s->mb_intra) {
149  int mx, my, cbpy;
150 
152  if(cbpy<0){
153  av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
154  return -1;
155  }
156 
157  cbp|= cbpy<<2;
158  if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
159 
160  ff_h263_pred_motion(s, 0, 0, &mx, &my);
161  mx= msmpeg4v2_decode_motion(s, mx, 1);
162  my= msmpeg4v2_decode_motion(s, my, 1);
163 
164  s->mv_dir = MV_DIR_FORWARD;
165  s->mv_type = MV_TYPE_16X16;
166  s->mv[0][0][0] = mx;
167  s->mv[0][0][1] = my;
168  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
169  } else {
170  int v;
171  if(s->msmpeg4_version==2){
172  s->ac_pred = get_bits1(&s->gb);
174  if (v < 0) {
175  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
176  return -1;
177  }
178  cbp|= v<<2;
179  } else{
180  s->ac_pred = 0;
182  if (v < 0) {
183  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
184  return -1;
185  }
186  cbp|= v<<2;
187  if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
188  }
189  *mb_type_ptr = MB_TYPE_INTRA;
190  }
191 
192  s->bdsp.clear_blocks(s->block[0]);
193  for (i = 0; i < 6; i++) {
194  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
195  {
196  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
197  return -1;
198  }
199  }
200  return 0;
201 }
202 
203 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
204 {
205  int cbp, code, i;
206  uint8_t *coded_val;
207  uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
208 
209  if (get_bits_left(&s->gb) <= 0)
210  return AVERROR_INVALIDDATA;
211 
212  if (s->pict_type == AV_PICTURE_TYPE_P) {
213  if (s->use_skip_mb_code) {
214  if (get_bits1(&s->gb)) {
215  /* skip mb */
216  s->mb_intra = 0;
217  for(i=0;i<6;i++)
218  s->block_last_index[i] = -1;
219  s->mv_dir = MV_DIR_FORWARD;
220  s->mv_type = MV_TYPE_16X16;
221  s->mv[0][0][0] = 0;
222  s->mv[0][0][1] = 0;
223  s->mb_skipped = 1;
224  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
225 
226  return 0;
227  }
228  }
229 
230  code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
231  //s->mb_intra = (code & 0x40) ? 0 : 1;
232  s->mb_intra = (~code & 0x40) >> 6;
233 
234  cbp = code & 0x3f;
235  } else {
236  s->mb_intra = 1;
238  /* predict coded block pattern */
239  cbp = 0;
240  for(i=0;i<6;i++) {
241  int val = ((code >> (5 - i)) & 1);
242  if (i < 4) {
243  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
244  val = val ^ pred;
245  *coded_val = val;
246  }
247  cbp |= val << (5 - i);
248  }
249  }
250 
251  if (!s->mb_intra) {
252  int mx, my;
253  if(s->per_mb_rl_table && cbp){
254  s->rl_table_index = decode012(&s->gb);
256  }
257  ff_h263_pred_motion(s, 0, 0, &mx, &my);
258  ff_msmpeg4_decode_motion(s, &mx, &my);
259  s->mv_dir = MV_DIR_FORWARD;
260  s->mv_type = MV_TYPE_16X16;
261  s->mv[0][0][0] = mx;
262  s->mv[0][0][1] = my;
263  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
264  } else {
265  ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
266  ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
267  show_bits(&s->gb, 24));
268  s->ac_pred = get_bits1(&s->gb);
269  *mb_type_ptr = MB_TYPE_INTRA;
270  if(s->inter_intra_pred){
271  s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
272  ff_dlog(s, "%d%d %d %d/",
273  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
274  }
275  if(s->per_mb_rl_table && cbp){
276  s->rl_table_index = decode012(&s->gb);
278  }
279  }
280 
281  s->bdsp.clear_blocks(s->block[0]);
282  for (i = 0; i < 6; i++) {
283  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
284  {
285  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
286  return -1;
287  }
288  }
289 
290  return 0;
291 }
292 
293 /* init all vlc decoding tables */
295 {
296  MpegEncContext *s = avctx->priv_data;
297  static volatile int done = 0;
298  int i, ret;
299  MVTable *mv;
300 
301  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
302  return ret;
303 
304  if (ff_h263_decode_init(avctx) < 0)
305  return -1;
306 
308 
309  if (!done) {
310  for(i=0;i<NB_RL_TABLES;i++) {
312  }
314  INIT_FIRST_VLC_RL(ff_rl_table[1], 1104);
316  INIT_VLC_RL(ff_rl_table[3], 940);
317  INIT_VLC_RL(ff_rl_table[4], 962);
318  /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been
319  * initialized in ff_h263_decode_init() above. So just copy the VLCs. */
322 
323  mv = &ff_mv_tables[0];
325  mv->table_mv_bits, 1, 1,
326  mv->table_mv_code, 2, 2, 3714);
327  mv = &ff_mv_tables[1];
329  mv->table_mv_bits, 1, 1,
330  mv->table_mv_code, 2, 2, 2694);
331 
333  &ff_table0_dc_lum[0][1], 8, 4,
334  &ff_table0_dc_lum[0][0], 8, 4, 1158);
336  &ff_table0_dc_chroma[0][1], 8, 4,
337  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
339  &ff_table1_dc_lum[0][1], 8, 4,
340  &ff_table1_dc_lum[0][0], 8, 4, 1476);
342  &ff_table1_dc_chroma[0][1], 8, 4,
343  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
344 
345  INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
346  &ff_v2_dc_lum_table[0][1], 8, 4,
347  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
348  INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
349  &ff_v2_dc_chroma_table[0][1], 8, 4,
350  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
351 
352  INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
353  &ff_v2_intra_cbpc[0][1], 2, 1,
354  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
355  INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
356  &ff_v2_mb_type[0][1], 2, 1,
357  &ff_v2_mb_type[0][0], 2, 1, 128);
358 
359  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
360  &ff_wmv2_inter_table[0][0][1], 8, 4,
361  &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
362  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
363  &ff_wmv2_inter_table[1][0][1], 8, 4,
364  &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
365  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
366  &ff_wmv2_inter_table[2][0][1], 8, 4,
367  &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
368  INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
369  &ff_wmv2_inter_table[3][0][1], 8, 4,
370  &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
371 
373  &ff_msmp4_mb_i_table[0][1], 4, 2,
374  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
375 
376  INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
377  &ff_table_inter_intra[0][1], 2, 1,
378  &ff_table_inter_intra[0][0], 2, 1, 8);
379  done = 1;
380  }
381 
382  switch(s->msmpeg4_version){
383  case 1:
384  case 2:
386  break;
387  case 3:
388  case 4:
390  break;
391  case 5:
392  if (CONFIG_WMV2_DECODER)
394  case 6:
395  //FIXME + TODO VC1 decode mb
396  break;
397  }
398 
399  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
400 
401  return 0;
402 }
403 
405 {
406  int code;
407 
408  // at minimum one bit per macroblock is required at least in a valid frame,
409  // we discard frames much smaller than this. Frames smaller than 1/8 of the
410  // smallest "black/skip" frame generally contain not much recoverable content
411  // while at the same time they have the highest computational requirements
412  // per byte
413  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
414  return AVERROR_INVALIDDATA;
415 
416  if(s->msmpeg4_version==1){
417  int start_code = get_bits_long(&s->gb, 32);
418  if(start_code!=0x00000100){
419  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
420  return -1;
421  }
422 
423  skip_bits(&s->gb, 5); // frame number */
424  }
425 
426  s->pict_type = get_bits(&s->gb, 2) + 1;
427  if (s->pict_type != AV_PICTURE_TYPE_I &&
429  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
430  return -1;
431  }
432  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
433  if(s->qscale==0){
434  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
435  return -1;
436  }
437 
438  if (s->pict_type == AV_PICTURE_TYPE_I) {
439  code = get_bits(&s->gb, 5);
440  if(s->msmpeg4_version==1){
441  if(code==0 || code>s->mb_height){
442  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
443  return -1;
444  }
445 
446  s->slice_height = code;
447  }else{
448  /* 0x17: one slice, 0x18: two slices, ... */
449  if (code < 0x17){
450  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
451  return -1;
452  }
453 
454  s->slice_height = s->mb_height / (code - 0x16);
455  }
456 
457  switch(s->msmpeg4_version){
458  case 1:
459  case 2:
460  s->rl_chroma_table_index = 2;
461  s->rl_table_index = 2;
462 
463  s->dc_table_index = 0; //not used
464  break;
465  case 3:
467  s->rl_table_index = decode012(&s->gb);
468 
469  s->dc_table_index = get_bits1(&s->gb);
470  break;
471  case 4:
472  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
473 
475  else s->per_mb_rl_table= 0;
476 
477  if(!s->per_mb_rl_table){
479  s->rl_table_index = decode012(&s->gb);
480  }
481 
482  s->dc_table_index = get_bits1(&s->gb);
483  s->inter_intra_pred= 0;
484  break;
485  }
486  s->no_rounding = 1;
488  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
489  s->qscale,
491  s->rl_table_index,
492  s->dc_table_index,
493  s->per_mb_rl_table,
494  s->slice_height);
495  } else {
496  switch(s->msmpeg4_version){
497  case 1:
498  case 2:
499  if(s->msmpeg4_version==1)
500  s->use_skip_mb_code = 1;
501  else
502  s->use_skip_mb_code = get_bits1(&s->gb);
503  s->rl_table_index = 2;
505  s->dc_table_index = 0; //not used
506  s->mv_table_index = 0;
507  break;
508  case 3:
509  s->use_skip_mb_code = get_bits1(&s->gb);
510  s->rl_table_index = decode012(&s->gb);
512 
513  s->dc_table_index = get_bits1(&s->gb);
514 
515  s->mv_table_index = get_bits1(&s->gb);
516  break;
517  case 4:
518  s->use_skip_mb_code = get_bits1(&s->gb);
519 
521  else s->per_mb_rl_table= 0;
522 
523  if(!s->per_mb_rl_table){
524  s->rl_table_index = decode012(&s->gb);
526  }
527 
528  s->dc_table_index = get_bits1(&s->gb);
529 
530  s->mv_table_index = get_bits1(&s->gb);
531  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
532  break;
533  }
534 
536  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
537  s->use_skip_mb_code,
538  s->rl_table_index,
540  s->dc_table_index,
541  s->mv_table_index,
542  s->per_mb_rl_table,
543  s->qscale);
544 
545  if(s->flipflop_rounding){
546  s->no_rounding ^= 1;
547  }else{
548  s->no_rounding = 0;
549  }
550  }
551  ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
552  s->inter_intra_pred, s->width, s->height);
553 
554  s->esc3_level_length= 0;
555  s->esc3_run_length= 0;
556 
557  return 0;
558 }
559 
561 {
562  int left= buf_size*8 - get_bits_count(&s->gb);
563  int length= s->msmpeg4_version>=3 ? 17 : 16;
564  /* the alt_bitstream reader could read over the end so we need to check it */
565  if(left>=length && left<length+8)
566  {
567  skip_bits(&s->gb, 5); /* fps */
568  s->bit_rate= get_bits(&s->gb, 11)*1024;
569  if(s->msmpeg4_version>=3)
570  s->flipflop_rounding= get_bits1(&s->gb);
571  else
572  s->flipflop_rounding= 0;
573  }
574  else if(left<length+8)
575  {
576  s->flipflop_rounding= 0;
577  if(s->msmpeg4_version != 2)
578  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
579  }
580  else
581  {
582  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
583  }
584 
585  return 0;
586 }
587 
588 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
589 {
590  int level, pred;
591 
592  if(s->msmpeg4_version<=2){
593  if (n < 4) {
594  level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
595  } else {
596  level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
597  }
598  if (level < 0) {
599  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
600  *dir_ptr = 0;
601  return -1;
602  }
603  level-=256;
604  }else{ //FIXME optimize use unified tables & index
605  if (n < 4) {
607  } else {
609  }
610 
611  if (level == DC_MAX) {
612  level = get_bits(&s->gb, 8);
613  if (get_bits1(&s->gb))
614  level = -level;
615  } else if (level != 0) {
616  if (get_bits1(&s->gb))
617  level = -level;
618  }
619  }
620 
621  if(s->msmpeg4_version==1){
622  int32_t *dc_val;
623  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
624  level += pred;
625 
626  /* update predictor */
627  *dc_val= level;
628  }else{
629  int16_t *dc_val;
630  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
631  level += pred;
632 
633  /* update predictor */
634  if (n < 4) {
635  *dc_val = level * s->y_dc_scale;
636  } else {
637  *dc_val = level * s->c_dc_scale;
638  }
639  }
640 
641  return level;
642 }
643 
645  int n, int coded, const uint8_t *scan_table)
646 {
647  int level, i, last, run, run_diff;
648  int av_uninit(dc_pred_dir);
649  RLTable *rl;
651  int qmul, qadd;
652 
653  if (s->mb_intra) {
654  qmul=1;
655  qadd=0;
656 
657  /* DC coef */
658  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
659 
660  if (level < 0){
661  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
662  if(s->inter_intra_pred) level=0;
663  }
664  if (n < 4) {
665  rl = &ff_rl_table[s->rl_table_index];
666  if(level > 256*s->y_dc_scale){
667  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
668  if(!s->inter_intra_pred) return -1;
669  }
670  } else {
671  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
672  if(level > 256*s->c_dc_scale){
673  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
674  if(!s->inter_intra_pred) return -1;
675  }
676  }
677  block[0] = level;
678 
679  run_diff = s->msmpeg4_version >= 4;
680  i = 0;
681  if (!coded) {
682  goto not_coded;
683  }
684  if (s->ac_pred) {
685  if (dc_pred_dir == 0)
686  scan_table = s->intra_v_scantable.permutated; /* left */
687  else
688  scan_table = s->intra_h_scantable.permutated; /* top */
689  } else {
690  scan_table = s->intra_scantable.permutated;
691  }
692  rl_vlc= rl->rl_vlc[0];
693  } else {
694  qmul = s->qscale << 1;
695  qadd = (s->qscale - 1) | 1;
696  i = -1;
697  rl = &ff_rl_table[3 + s->rl_table_index];
698 
699  if(s->msmpeg4_version==2)
700  run_diff = 0;
701  else
702  run_diff = 1;
703 
704  if (!coded) {
705  s->block_last_index[n] = i;
706  return 0;
707  }
708  if(!scan_table)
709  scan_table = s->inter_scantable.permutated;
710  rl_vlc= rl->rl_vlc[s->qscale];
711  }
712  {
713  OPEN_READER(re, &s->gb);
714  for(;;) {
715  UPDATE_CACHE(re, &s->gb);
716  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
717  if (level==0) {
718  int cache;
719  cache= GET_CACHE(re, &s->gb);
720  /* escape */
721  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
722  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
723  /* third escape */
724  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
725  UPDATE_CACHE(re, &s->gb);
726  if(s->msmpeg4_version<=3){
727  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
728  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
729  level= SHOW_SBITS(re, &s->gb, 8);
730  SKIP_COUNTER(re, &s->gb, 1+6+8);
731  }else{
732  int sign;
733  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
734  if(!s->esc3_level_length){
735  int ll;
736  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
737  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
738  if(s->qscale<8){
739  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
740  if(ll==0){
741  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
742  }
743  }else{
744  ll=2;
745  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
746  ll++;
747  SKIP_BITS(re, &s->gb, 1);
748  }
749  if(ll<8) SKIP_BITS(re, &s->gb, 1);
750  }
751 
752  s->esc3_level_length= ll;
753  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
754  UPDATE_CACHE(re, &s->gb);
755  }
756  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
757  SKIP_BITS(re, &s->gb, s->esc3_run_length);
758 
759  sign= SHOW_UBITS(re, &s->gb, 1);
760  SKIP_BITS(re, &s->gb, 1);
761 
762  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
763  SKIP_BITS(re, &s->gb, s->esc3_level_length);
764  if(sign) level= -level;
765  }
766 
767  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
768  if (level>0) level= level * qmul + qadd;
769  else level= level * qmul - qadd;
770  i+= run + 1;
771  if(last) i+=192;
772  } else {
773  /* second escape */
774  SKIP_BITS(re, &s->gb, 2);
775  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
776  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
777  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
778  LAST_SKIP_BITS(re, &s->gb, 1);
779  }
780  } else {
781  /* first escape */
782  SKIP_BITS(re, &s->gb, 1);
783  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
784  i+= run;
785  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
786  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
787  LAST_SKIP_BITS(re, &s->gb, 1);
788  }
789  } else {
790  i+= run;
791  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
792  LAST_SKIP_BITS(re, &s->gb, 1);
793  }
794  if (i > 62){
795  i-= 192;
796  if(i&(~63)){
797  const int left= get_bits_left(&s->gb);
798  if (((i + 192 == 64 && level / qmul == -1) ||
800  left >= 0) {
801  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
802  i = 63;
803  break;
804  }else{
805  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
806  return -1;
807  }
808  }
809 
810  block[scan_table[i]] = level;
811  break;
812  }
813 
814  block[scan_table[i]] = level;
815  }
816  CLOSE_READER(re, &s->gb);
817  }
818  not_coded:
819  if (s->mb_intra) {
820  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
821  if (s->ac_pred) {
822  i = 63; /* XXX: not optimal */
823  }
824  }
825  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
826  s->block_last_index[n] = i;
827 
828  return 0;
829 }
830 
831 void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
832 {
833  MVTable *mv;
834  int code, mx, my;
835 
836  mv = &ff_mv_tables[s->mv_table_index];
837 
838  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
839  if (code == MSMPEG4_MV_TABLES_NB_ELEMS) {
840  mx = get_bits(&s->gb, 6);
841  my = get_bits(&s->gb, 6);
842  } else {
843  mx = mv->table_mvx[code];
844  my = mv->table_mvy[code];
845  }
846 
847  mx += *mx_ptr - 32;
848  my += *my_ptr - 32;
849  /* WARNING : they do not do exactly modulo encoding */
850  if (mx <= -64)
851  mx += 64;
852  else if (mx >= 64)
853  mx -= 64;
854 
855  if (my <= -64)
856  my += 64;
857  else if (my >= 64)
858  my -= 64;
859  *mx_ptr = mx;
860  *my_ptr = my;
861 }
862 
864  .name = "msmpeg4v1",
865  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
866  .type = AVMEDIA_TYPE_VIDEO,
867  .id = AV_CODEC_ID_MSMPEG4V1,
868  .priv_data_size = sizeof(MpegEncContext),
870  .close = ff_h263_decode_end,
874  .max_lowres = 3,
875  .pix_fmts = (const enum AVPixelFormat[]) {
878  },
879 };
880 
882  .name = "msmpeg4v2",
883  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
884  .type = AVMEDIA_TYPE_VIDEO,
885  .id = AV_CODEC_ID_MSMPEG4V2,
886  .priv_data_size = sizeof(MpegEncContext),
888  .close = ff_h263_decode_end,
892  .max_lowres = 3,
893  .pix_fmts = (const enum AVPixelFormat[]) {
896  },
897 };
898 
900  .name = "msmpeg4",
901  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
902  .type = AVMEDIA_TYPE_VIDEO,
903  .id = AV_CODEC_ID_MSMPEG4V3,
904  .priv_data_size = sizeof(MpegEncContext),
906  .close = ff_h263_decode_end,
910  .max_lowres = 3,
911  .pix_fmts = (const enum AVPixelFormat[]) {
914  },
915 };
916 
918  .name = "wmv1",
919  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
920  .type = AVMEDIA_TYPE_VIDEO,
921  .id = AV_CODEC_ID_WMV1,
922  .priv_data_size = sizeof(MpegEncContext),
924  .close = ff_h263_decode_end,
928  .max_lowres = 3,
929  .pix_fmts = (const enum AVPixelFormat[]) {
932  },
933 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
VLC ff_h263_mv_vlc
Definition: ituh263dec.c:101
#define DEFAULT_INTER_INDEX
Definition: msmpeg4dec.c:43
int inter_intra_pred
Definition: mpegvideo.h:444
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ScanTable intra_v_scantable
Definition: mpegvideo.h:93
static int shift(int a, int b)
Definition: sonic.c:82
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4dec.c:71
int esc3_level_length
Definition: mpegvideo.h:440
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:63
VLC ff_inter_intra_vlc
Definition: msmpeg4dec.c:68
#define CBPY_VLC_BITS
Definition: h263.h:40
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:34
float re
Definition: fft.c:82
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
const uint32_t ff_table0_dc_lum[120][2]
Definition: msmpeg4data.c:100
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:98
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
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:100
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:185
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:438
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1655
#define MB_TYPE_INTRA
Definition: mpegutils.h:73
static VLC v2_dc_chroma_vlc
Definition: msmpeg4dec.c:65
#define TEX_VLC_BITS
Definition: msmpeg4dec.c:41
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:1649
mpegvideo header.
#define NB_RL_TABLES
Definition: msmpeg4data.h:59
uint8_t permutated[64]
Definition: idctdsp.h:33
uint8_t run
Definition: svq3.c:205
AVCodec.
Definition: codec.h:190
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4.h:34
RLTable.
Definition: rl.h:39
int qscale
QP.
Definition: mpegvideo.h:204
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:109
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:307
int esc3_run_length
Definition: mpegvideo.h:441
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
VC-1 tables.
static VLC rl_vlc[2]
Definition: mobiclip.c:275
The exact code depends on how similar the blocks are and how related they are to the block
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1789
uint8_t
#define av_cold
Definition: attributes.h:88
int ff_msmpeg4_decode_block(MpegEncContext *s, int16_t *block, int n, int coded, const uint8_t *scan_table)
Definition: msmpeg4dec.c:644
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:1619
#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:284
#define MB_TYPE_16x16
Definition: mpegutils.h:54
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:102
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
MSMPEG4 data tables.
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
#define ff_dlog(a,...)
const uint32_t ff_table0_dc_chroma[120][2]
Definition: msmpeg4data.c:133
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
Definition: msmpeg4dec.c:45
int flipflop_rounding
Definition: mpegvideo.h:437
#define av_log(a,...)
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
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:194
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:203
int rl_chroma_table_index
Definition: mpegvideo.h:432
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:404
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:195
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:71
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:37
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
#define DC_VLC_BITS
Definition: msmpeg4dec.c:37
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int per_mb_rl_table
Definition: mpegvideo.h:439
#define INTER_MCBPC_VLC_BITS
Definition: h263.h:39
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int(* decode_mb)(struct MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.h:513
const char * name
Name of the codec implementation.
Definition: codec.h:197
GetBitContext gb
Definition: mpegvideo.h:451
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:58
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4dec.c:38
#define GET_RL_VLC(level, run, name, gb, table, bits,max_depth, need_update)
Definition: get_bits.h:738
Definition: vlc.h:26
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:71
int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:70
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:99
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:422
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
const uint8_t ff_v2_mb_type[8][2]
Definition: msmpeg4data.c:1784
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:193
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1640
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
const uint8_t * table_mvx
Definition: msmpeg4data.h:42
int width
picture width / height.
Definition: avcodec.h:704
#define MSMPEG4_MV_TABLES_NB_ELEMS
Definition: msmpeg4data.h:71
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:446
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Definition: msmpeg4dec.c:588
#define s(width, name)
Definition: cbs_vp9.c:257
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
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:797
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
const uint32_t ff_table1_dc_chroma[120][2]
Definition: msmpeg4data.c:201
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:560
static const float pred[4]
Definition: siprdata.h:259
static const int8_t mv[256][2]
Definition: 4xm.c:78
AVCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:863
#define H263_MV_VLC_BITS
Definition: h263.h:37
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
Libavcodec external API header.
BlockDSPContext bdsp
Definition: mpegvideo.h:226
int debug
debug
Definition: avcodec.h:1618
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1954
AVCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:881
main external API structure.
Definition: avcodec.h:531
static VLC v2_intra_cbpc_vlc
Definition: msmpeg4dec.c:66
ScanTable intra_scantable
Definition: mpegvideo.h:91
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
const uint16_t * table_mv_code
Definition: msmpeg4data.h:40
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
#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:498
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4dec.c:39
ScanTable intra_h_scantable
Definition: mpegvideo.h:92
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:831
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
#define MB_INTRA_VLC_BITS
Definition: msmpeg4.h:35
int slice_height
in macroblocks
Definition: mpegvideo.h:435
RLTable ff_h263_rl_inter
Definition: h263data.c:161
int use_skip_mb_code
Definition: mpegvideo.h:434
AVCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:917
MVTable ff_mv_tables[2]
Definition: msmpeg4data.c:1773
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:180
VLC vlc
Definition: msmpeg4data.h:45
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
#define II_BITRATE
Definition: msmpeg4.h:37
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:601
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static VLC v2_mb_type_vlc
Definition: msmpeg4dec.c:67
uint8_t level
Definition: svq3.c:206
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
MpegEncContext.
Definition: mpegvideo.h:81
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
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:130
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: internal.h:60
AVCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:899
#define MV_VLC_BITS
Definition: msmpeg4dec.c:40
int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:156
void * priv_data
Definition: avcodec.h:558
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:511
static int decode012(GetBitContext *gb)
Definition: get_bits.h:831
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:103
int rl_table_index
Definition: mpegvideo.h:431
int chroma_qscale
chroma QP
Definition: mpegvideo.h:205
#define av_uninit(x)
Definition: attributes.h:154
#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:43
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:90
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:153
static const uint8_t start_code[]
int mv_table_index
Definition: mpegvideo.h:430
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
Definition: mpegvideo.h:376
int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: wmv2dec.c:378
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1842
int dc_table_index
Definition: mpegvideo.h:433
#define MB_TYPE_L0
Definition: mpegutils.h:67
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4data.c:39
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define INTRA_MCBPC_VLC_BITS
Definition: h263.h:38
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:294
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4data.c:40