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)
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)
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 
151  cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
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 
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);
255  s->rl_chroma_table_index = s->rl_table_index;
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);
277  s->rl_chroma_table_index = s->rl_table_index;
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 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) {
311  INIT_FIRST_VLC_RL(ff_rl_table[1], 1104);
313  INIT_VLC_RL(ff_rl_table[3], 940);
314  INIT_VLC_RL(ff_rl_table[4], 962);
315  /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been
316  * initialized in ff_h263_decode_init() above. So just copy the VLCs. */
319 
320  mv = &ff_mv_tables[0];
322  mv->table_mv_bits, 1, 1,
323  mv->table_mv_code, 2, 2, 3714);
324  mv = &ff_mv_tables[1];
326  mv->table_mv_bits, 1, 1,
327  mv->table_mv_code, 2, 2, 2694);
328 
330  &ff_table0_dc_lum[0][1], 8, 4,
331  &ff_table0_dc_lum[0][0], 8, 4, 1158);
333  &ff_table0_dc_chroma[0][1], 8, 4,
334  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
336  &ff_table1_dc_lum[0][1], 8, 4,
337  &ff_table1_dc_lum[0][0], 8, 4, 1476);
339  &ff_table1_dc_chroma[0][1], 8, 4,
340  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
341 
343  &ff_v2_dc_lum_table[0][1], 8, 4,
344  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
346  &ff_v2_dc_chroma_table[0][1], 8, 4,
347  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
348 
350  &ff_v2_intra_cbpc[0][1], 2, 1,
351  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
353  &ff_v2_mb_type[0][1], 2, 1,
354  &ff_v2_mb_type[0][0], 2, 1, 128);
355 
356  for (unsigned i = 0, offset = 0; i < 4; i++) {
357  static VLC_TYPE vlc_buf[1636 + 2648 + 1532 + 2488][2];
361  &ff_wmv2_inter_table[i][0][1], 8, 4,
362  &ff_wmv2_inter_table[i][0][0], 8, 4,
365  }
366 
368  &ff_msmp4_mb_i_table[0][1], 4, 2,
369  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
370 
372  &ff_table_inter_intra[0][1], 2, 1,
373  &ff_table_inter_intra[0][0], 2, 1, 8);
374  done = 1;
375  }
376 
377  switch(s->msmpeg4_version){
378  case 1:
379  case 2:
380  s->decode_mb= msmpeg4v12_decode_mb;
381  break;
382  case 3:
383  case 4:
384  s->decode_mb= msmpeg4v34_decode_mb;
385  break;
386  case 5:
387  if (CONFIG_WMV2_DECODER)
388  s->decode_mb= ff_wmv2_decode_mb;
389  case 6:
390  //FIXME + TODO VC1 decode mb
391  break;
392  }
393 
394  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
395 
396  return 0;
397 }
398 
400 {
401  int code;
402 
403  // at minimum one bit per macroblock is required at least in a valid frame,
404  // we discard frames much smaller than this. Frames smaller than 1/8 of the
405  // smallest "black/skip" frame generally contain not much recoverable content
406  // while at the same time they have the highest computational requirements
407  // per byte
408  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
409  return AVERROR_INVALIDDATA;
410 
411  if(s->msmpeg4_version==1){
412  int start_code = get_bits_long(&s->gb, 32);
413  if(start_code!=0x00000100){
414  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
415  return -1;
416  }
417 
418  skip_bits(&s->gb, 5); // frame number */
419  }
420 
421  s->pict_type = get_bits(&s->gb, 2) + 1;
422  if (s->pict_type != AV_PICTURE_TYPE_I &&
423  s->pict_type != AV_PICTURE_TYPE_P){
424  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
425  return -1;
426  }
427  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
428  if(s->qscale==0){
429  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
430  return -1;
431  }
432 
433  if (s->pict_type == AV_PICTURE_TYPE_I) {
434  code = get_bits(&s->gb, 5);
435  if(s->msmpeg4_version==1){
436  if(code==0 || code>s->mb_height){
437  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
438  return -1;
439  }
440 
441  s->slice_height = code;
442  }else{
443  /* 0x17: one slice, 0x18: two slices, ... */
444  if (code < 0x17){
445  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
446  return -1;
447  }
448 
449  s->slice_height = s->mb_height / (code - 0x16);
450  }
451 
452  switch(s->msmpeg4_version){
453  case 1:
454  case 2:
455  s->rl_chroma_table_index = 2;
456  s->rl_table_index = 2;
457 
458  s->dc_table_index = 0; //not used
459  break;
460  case 3:
461  s->rl_chroma_table_index = decode012(&s->gb);
462  s->rl_table_index = decode012(&s->gb);
463 
464  s->dc_table_index = get_bits1(&s->gb);
465  break;
466  case 4:
467  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
468 
469  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
470  else s->per_mb_rl_table= 0;
471 
472  if(!s->per_mb_rl_table){
473  s->rl_chroma_table_index = decode012(&s->gb);
474  s->rl_table_index = decode012(&s->gb);
475  }
476 
477  s->dc_table_index = get_bits1(&s->gb);
478  s->inter_intra_pred= 0;
479  break;
480  }
481  s->no_rounding = 1;
482  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
483  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
484  s->qscale,
485  s->rl_chroma_table_index,
486  s->rl_table_index,
487  s->dc_table_index,
488  s->per_mb_rl_table,
489  s->slice_height);
490  } else {
491  switch(s->msmpeg4_version){
492  case 1:
493  case 2:
494  if(s->msmpeg4_version==1)
495  s->use_skip_mb_code = 1;
496  else
497  s->use_skip_mb_code = get_bits1(&s->gb);
498  s->rl_table_index = 2;
499  s->rl_chroma_table_index = s->rl_table_index;
500  s->dc_table_index = 0; //not used
501  s->mv_table_index = 0;
502  break;
503  case 3:
504  s->use_skip_mb_code = get_bits1(&s->gb);
505  s->rl_table_index = decode012(&s->gb);
506  s->rl_chroma_table_index = s->rl_table_index;
507 
508  s->dc_table_index = get_bits1(&s->gb);
509 
510  s->mv_table_index = get_bits1(&s->gb);
511  break;
512  case 4:
513  s->use_skip_mb_code = get_bits1(&s->gb);
514 
515  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
516  else s->per_mb_rl_table= 0;
517 
518  if(!s->per_mb_rl_table){
519  s->rl_table_index = decode012(&s->gb);
520  s->rl_chroma_table_index = s->rl_table_index;
521  }
522 
523  s->dc_table_index = get_bits1(&s->gb);
524 
525  s->mv_table_index = get_bits1(&s->gb);
526  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
527  break;
528  }
529 
530  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
531  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
532  s->use_skip_mb_code,
533  s->rl_table_index,
534  s->rl_chroma_table_index,
535  s->dc_table_index,
536  s->mv_table_index,
537  s->per_mb_rl_table,
538  s->qscale);
539 
540  if(s->flipflop_rounding){
541  s->no_rounding ^= 1;
542  }else{
543  s->no_rounding = 0;
544  }
545  }
546  ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
547  s->inter_intra_pred, s->width, s->height);
548 
549  s->esc3_level_length= 0;
550  s->esc3_run_length= 0;
551 
552  return 0;
553 }
554 
556 {
557  int left= buf_size*8 - get_bits_count(&s->gb);
558  int length= s->msmpeg4_version>=3 ? 17 : 16;
559  /* the alt_bitstream reader could read over the end so we need to check it */
560  if(left>=length && left<length+8)
561  {
562  skip_bits(&s->gb, 5); /* fps */
563  s->bit_rate= get_bits(&s->gb, 11)*1024;
564  if(s->msmpeg4_version>=3)
565  s->flipflop_rounding= get_bits1(&s->gb);
566  else
567  s->flipflop_rounding= 0;
568  }
569  else if(left<length+8)
570  {
571  s->flipflop_rounding= 0;
572  if(s->msmpeg4_version != 2)
573  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
574  }
575  else
576  {
577  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
578  }
579 
580  return 0;
581 }
582 
583 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
584 {
585  int level, pred;
586 
587  if(s->msmpeg4_version<=2){
588  if (n < 4) {
590  } else {
592  }
593  if (level < 0) {
594  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
595  *dir_ptr = 0;
596  return -1;
597  }
598  level-=256;
599  }else{ //FIXME optimize use unified tables & index
600  if (n < 4) {
601  level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
602  } else {
603  level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
604  }
605 
606  if (level == DC_MAX) {
607  level = get_bits(&s->gb, 8);
608  if (get_bits1(&s->gb))
609  level = -level;
610  } else if (level != 0) {
611  if (get_bits1(&s->gb))
612  level = -level;
613  }
614  }
615 
616  if(s->msmpeg4_version==1){
617  int32_t *dc_val;
618  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
619  level += pred;
620 
621  /* update predictor */
622  *dc_val= level;
623  }else{
624  int16_t *dc_val;
625  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
626  level += pred;
627 
628  /* update predictor */
629  if (n < 4) {
630  *dc_val = level * s->y_dc_scale;
631  } else {
632  *dc_val = level * s->c_dc_scale;
633  }
634  }
635 
636  return level;
637 }
638 
640  int n, int coded, const uint8_t *scan_table)
641 {
642  int level, i, last, run, run_diff;
643  int av_uninit(dc_pred_dir);
644  RLTable *rl;
646  int qmul, qadd;
647 
648  if (s->mb_intra) {
649  qmul=1;
650  qadd=0;
651 
652  /* DC coef */
653  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
654 
655  if (level < 0){
656  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
657  if(s->inter_intra_pred) level=0;
658  }
659  if (n < 4) {
660  rl = &ff_rl_table[s->rl_table_index];
661  if(level > 256*s->y_dc_scale){
662  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
663  if(!s->inter_intra_pred) return -1;
664  }
665  } else {
666  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
667  if(level > 256*s->c_dc_scale){
668  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
669  if(!s->inter_intra_pred) return -1;
670  }
671  }
672  block[0] = level;
673 
674  run_diff = s->msmpeg4_version >= 4;
675  i = 0;
676  if (!coded) {
677  goto not_coded;
678  }
679  if (s->ac_pred) {
680  if (dc_pred_dir == 0)
681  scan_table = s->intra_v_scantable.permutated; /* left */
682  else
683  scan_table = s->intra_h_scantable.permutated; /* top */
684  } else {
685  scan_table = s->intra_scantable.permutated;
686  }
687  rl_vlc= rl->rl_vlc[0];
688  } else {
689  qmul = s->qscale << 1;
690  qadd = (s->qscale - 1) | 1;
691  i = -1;
692  rl = &ff_rl_table[3 + s->rl_table_index];
693 
694  if(s->msmpeg4_version==2)
695  run_diff = 0;
696  else
697  run_diff = 1;
698 
699  if (!coded) {
700  s->block_last_index[n] = i;
701  return 0;
702  }
703  if(!scan_table)
704  scan_table = s->inter_scantable.permutated;
705  rl_vlc= rl->rl_vlc[s->qscale];
706  }
707  {
708  OPEN_READER(re, &s->gb);
709  for(;;) {
710  UPDATE_CACHE(re, &s->gb);
711  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
712  if (level==0) {
713  int cache;
714  cache= GET_CACHE(re, &s->gb);
715  /* escape */
716  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
717  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
718  /* third escape */
719  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
720  UPDATE_CACHE(re, &s->gb);
721  if(s->msmpeg4_version<=3){
722  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
723  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
724  level= SHOW_SBITS(re, &s->gb, 8);
725  SKIP_COUNTER(re, &s->gb, 1+6+8);
726  }else{
727  int sign;
728  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
729  if(!s->esc3_level_length){
730  int ll;
731  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
732  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
733  if(s->qscale<8){
734  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
735  if(ll==0){
736  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
737  }
738  }else{
739  ll=2;
740  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
741  ll++;
742  SKIP_BITS(re, &s->gb, 1);
743  }
744  if(ll<8) SKIP_BITS(re, &s->gb, 1);
745  }
746 
747  s->esc3_level_length= ll;
748  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
749  UPDATE_CACHE(re, &s->gb);
750  }
751  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
752  SKIP_BITS(re, &s->gb, s->esc3_run_length);
753 
754  sign= SHOW_UBITS(re, &s->gb, 1);
755  SKIP_BITS(re, &s->gb, 1);
756 
757  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
758  SKIP_BITS(re, &s->gb, s->esc3_level_length);
759  if(sign) level= -level;
760  }
761 
762  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
763  if (level>0) level= level * qmul + qadd;
764  else level= level * qmul - qadd;
765  i+= run + 1;
766  if(last) i+=192;
767  } else {
768  /* second escape */
769  SKIP_BITS(re, &s->gb, 2);
770  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
771  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
772  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
773  LAST_SKIP_BITS(re, &s->gb, 1);
774  }
775  } else {
776  /* first escape */
777  SKIP_BITS(re, &s->gb, 1);
778  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
779  i+= run;
780  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
781  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
782  LAST_SKIP_BITS(re, &s->gb, 1);
783  }
784  } else {
785  i+= run;
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  if (i > 62){
790  i-= 192;
791  if(i&(~63)){
792  const int left= get_bits_left(&s->gb);
793  if (((i + 192 == 64 && level / qmul == -1) ||
794  !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
795  left >= 0) {
796  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
797  i = 63;
798  break;
799  }else{
800  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
801  return -1;
802  }
803  }
804 
805  block[scan_table[i]] = level;
806  break;
807  }
808 
809  block[scan_table[i]] = level;
810  }
811  CLOSE_READER(re, &s->gb);
812  }
813  not_coded:
814  if (s->mb_intra) {
815  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
816  if (s->ac_pred) {
817  i = 63; /* XXX: not optimal */
818  }
819  }
820  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
821  s->block_last_index[n] = i;
822 
823  return 0;
824 }
825 
826 void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
827 {
828  MVTable *mv;
829  int code, mx, my;
830 
831  mv = &ff_mv_tables[s->mv_table_index];
832 
833  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
835  mx = get_bits(&s->gb, 6);
836  my = get_bits(&s->gb, 6);
837  } else {
838  mx = mv->table_mvx[code];
839  my = mv->table_mvy[code];
840  }
841 
842  mx += *mx_ptr - 32;
843  my += *my_ptr - 32;
844  /* WARNING : they do not do exactly modulo encoding */
845  if (mx <= -64)
846  mx += 64;
847  else if (mx >= 64)
848  mx -= 64;
849 
850  if (my <= -64)
851  my += 64;
852  else if (my >= 64)
853  my -= 64;
854  *mx_ptr = mx;
855  *my_ptr = my;
856 }
857 
859  .name = "msmpeg4v1",
860  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
861  .type = AVMEDIA_TYPE_VIDEO,
862  .id = AV_CODEC_ID_MSMPEG4V1,
863  .priv_data_size = sizeof(MpegEncContext),
865  .close = ff_h263_decode_end,
868  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
869  .max_lowres = 3,
870  .pix_fmts = (const enum AVPixelFormat[]) {
873  },
874 };
875 
877  .name = "msmpeg4v2",
878  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
879  .type = AVMEDIA_TYPE_VIDEO,
880  .id = AV_CODEC_ID_MSMPEG4V2,
881  .priv_data_size = sizeof(MpegEncContext),
883  .close = ff_h263_decode_end,
886  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
887  .max_lowres = 3,
888  .pix_fmts = (const enum AVPixelFormat[]) {
891  },
892 };
893 
895  .name = "msmpeg4",
896  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
897  .type = AVMEDIA_TYPE_VIDEO,
898  .id = AV_CODEC_ID_MSMPEG4V3,
899  .priv_data_size = sizeof(MpegEncContext),
901  .close = ff_h263_decode_end,
904  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
905  .max_lowres = 3,
906  .pix_fmts = (const enum AVPixelFormat[]) {
909  },
910 };
911 
913  .name = "wmv1",
914  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
915  .type = AVMEDIA_TYPE_VIDEO,
916  .id = AV_CODEC_ID_WMV1,
917  .priv_data_size = sizeof(MpegEncContext),
919  .close = ff_h263_decode_end,
922  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
923  .max_lowres = 3,
924  .pix_fmts = (const enum AVPixelFormat[]) {
927  },
928 };
AVCodec
AVCodec.
Definition: codec.h:197
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:66
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
msmpeg4v1_pred_dc
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
Definition: msmpeg4dec.c:45
msmpeg4v2_decode_motion
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4dec.c:71
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
mv
static const int8_t mv[256][2]
Definition: 4xm.c:79
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
ff_wmv1_decoder
const AVCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:912
MBAC_BITRATE
#define MBAC_BITRATE
Definition: msmpeg4.h:38
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:191
ff_wmv2_decode_mb
int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: wmv2dec.c:378
internal.h
ff_msmpeg4_common_init
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:116
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:53
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:555
get_vlc2
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:798
mpegvideo.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1335
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:179
ff_rl_table
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:600
mpegutils.h
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1299
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:216
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
ff_msmp4_mb_i_table
const uint16_t ff_msmp4_mb_i_table[64][2]
Definition: msmpeg4data.c:42
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:181
ff_wmv2_inter_table
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1953
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263.h:38
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:318
ff_h263_intra_MCBPC_vlc
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:98
RLTable
RLTable.
Definition: rl.h:39
ff_mb_non_intra_vlc
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:63
H263_MV_VLC_BITS
#define H263_MV_VLC_BITS
Definition: h263.h:37
ff_msmpeg4_decode_motion
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:826
val
static double val(void *priv, double ch)
Definition: aeval.c:75
ff_msmpeg4v2_decoder
const AVCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:876
AV_CODEC_ID_MSMPEG4V2
@ AV_CODEC_ID_MSMPEG4V2
Definition: codec_id.h:65
MV_VLC_BITS
#define MV_VLC_BITS
Definition: msmpeg4dec.c:40
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263.h:40
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#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:62
ff_msmpeg4v3_decoder
const AVCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:894
V2_INTRA_CBPC_VLC_BITS
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4dec.c:38
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:1329
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:86
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MB_NON_INTRA_VLC_BITS
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4.h:34
ff_msmpeg4_decode_picture_header
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:399
msmpeg4data.h
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:150
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
RLTable::max_level
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_table0_dc_chroma
const uint32_t ff_table0_dc_chroma[120][2]
Definition: msmpeg4data.c:132
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:213
ff_msmp4_dc_luma_vlc
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4data.c:38
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_CODEC_ID_MSMPEG4V1
@ AV_CODEC_ID_MSMPEG4V1
Definition: codec_id.h:64
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:832
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
ff_msmp4_dc_chroma_vlc
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4data.c:39
ff_table1_dc_chroma
const uint32_t ff_table1_dc_chroma[120][2]
Definition: msmpeg4data.c:200
DEFAULT_INTER_INDEX
#define DEFAULT_INTER_INDEX
Definition: msmpeg4dec.c:43
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
ff_v2_mb_type
const uint8_t ff_v2_mb_type[8][2]
Definition: msmpeg4data.c:1783
ff_v2_dc_lum_table
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:34
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:200
ff_table0_dc_lum
const uint32_t ff_table0_dc_lum[120][2]
Definition: msmpeg4data.c:99
ff_v2_dc_chroma_table
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:35
DC_MAX
#define DC_MAX
Definition: msmpeg4.h:40
AV_CODEC_ID_WMV1
@ AV_CODEC_ID_WMV1
Definition: codec_id.h:67
V2_MB_TYPE_VLC_BITS
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4dec.c:39
wmv2.h
v2_dc_lum_vlc
static VLC v2_dc_lum_vlc
Definition: msmpeg4dec.c:64
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
RL_VLC_ELEM
Definition: vlc.h:32
DC_VLC_BITS
#define DC_VLC_BITS
Definition: msmpeg4dec.c:37
ff_inter_intra_vlc
VLC ff_inter_intra_vlc
Definition: msmpeg4dec.c:68
msmpeg4v12_decode_mb
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:102
msmpeg4v34_decode_mb
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:203
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:61
II_BITRATE
#define II_BITRATE
Definition: msmpeg4.h:37
v2_intra_cbpc_vlc
static VLC v2_intra_cbpc_vlc
Definition: msmpeg4dec.c:66
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:139
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263.h:39
vc1data.h
ff_mpeg4_pred_ac
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:71
ff_msmpeg4_pred_dc
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:202
ff_v2_intra_cbpc
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1788
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ff_h263_mv_vlc
VLC ff_h263_mv_vlc
Definition: ituh263dec.c:101
ff_h263_decode_init
int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:69
i
int i
Definition: input.c:406
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:186
code
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
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
ff_mv_tables
MVTable ff_mv_tables[2]
Definition: msmpeg4data.c:1772
RLTable::max_run
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
ff_msmpeg4_decode_block
int ff_msmpeg4_decode_block(MpegEncContext *s, int16_t *block, int n, int coded, const uint8_t *scan_table)
Definition: msmpeg4dec.c:639
ff_h263_decode_end
int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:154
ff_h263_cbpy_vlc
VLC ff_h263_cbpy_vlc
Definition: ituh263dec.c:100
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:552
avcodec.h
msmpeg4.h
ff_msmpeg4v1_decoder
const AVCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:858
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:739
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
pred
static const float pred[4]
Definition: siprdata.h:259
left
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:386
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
AVCodecContext
main external API structure.
Definition: avcodec.h:379
v2_dc_chroma_vlc
static VLC v2_dc_chroma_vlc
Definition: msmpeg4dec.c:65
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:212
mpeg4video.h
ff_table_inter_intra
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1841
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:26
v2_mb_type_vlc
static VLC v2_mb_type_vlc
Definition: msmpeg4dec.c:67
ff_table1_dc_lum
const uint32_t ff_table1_dc_lum[120][2]
Definition: msmpeg4data.c:167
MVTable
Definition: msmpeg4data.h:39
VLC::table_size
int table_size
Definition: vlc.h:29
shift
static int shift(int a, int b)
Definition: sonic.c:83
INIT_VLC_RL
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:73
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
MB_INTRA_VLC_BITS
#define MB_INTRA_VLC_BITS
Definition: msmpeg4.h:35
msmpeg4_decode_dc
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Definition: msmpeg4dec.c:583
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:420
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
MSMPEG4_MV_TABLES_NB_ELEMS
#define MSMPEG4_MV_TABLES_NB_ELEMS
Definition: msmpeg4data.h:70
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_MSMPEG4V3
@ AV_CODEC_ID_MSMPEG4V3
Definition: codec_id.h:66
av_image_check_size
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:318
ff_msmpeg4_decode_init
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:294
ff_msmp4_mb_i_vlc
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4data.c:37
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:162
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: msmpeg4dec.c:41
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:72
INTER_INTRA_VLC_BITS
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4.h:33
re
float re
Definition: fft.c:82
h263.h
ff_h263_inter_MCBPC_vlc
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:99
rl_vlc
static VLC rl_vlc[2]
Definition: mobiclip.c:276