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 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 
346  &ff_v2_dc_lum_table[0][1], 8, 4,
347  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
349  &ff_v2_dc_chroma_table[0][1], 8, 4,
350  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
351 
353  &ff_v2_intra_cbpc[0][1], 2, 1,
354  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
356  &ff_v2_mb_type[0][1], 2, 1,
357  &ff_v2_mb_type[0][0], 2, 1, 128);
358 
359  for (unsigned i = 0, offset = 0; i < 4; i++) {
360  static VLC_TYPE vlc_buf[1636 + 2648 + 1532 + 2488][2];
364  &ff_wmv2_inter_table[i][0][1], 8, 4,
365  &ff_wmv2_inter_table[i][0][0], 8, 4,
368  }
369 
371  &ff_msmp4_mb_i_table[0][1], 4, 2,
372  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
373 
375  &ff_table_inter_intra[0][1], 2, 1,
376  &ff_table_inter_intra[0][0], 2, 1, 8);
377  done = 1;
378  }
379 
380  switch(s->msmpeg4_version){
381  case 1:
382  case 2:
383  s->decode_mb= msmpeg4v12_decode_mb;
384  break;
385  case 3:
386  case 4:
387  s->decode_mb= msmpeg4v34_decode_mb;
388  break;
389  case 5:
390  if (CONFIG_WMV2_DECODER)
391  s->decode_mb= ff_wmv2_decode_mb;
392  case 6:
393  //FIXME + TODO VC1 decode mb
394  break;
395  }
396 
397  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
398 
399  return 0;
400 }
401 
403 {
404  int code;
405 
406  // at minimum one bit per macroblock is required at least in a valid frame,
407  // we discard frames much smaller than this. Frames smaller than 1/8 of the
408  // smallest "black/skip" frame generally contain not much recoverable content
409  // while at the same time they have the highest computational requirements
410  // per byte
411  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
412  return AVERROR_INVALIDDATA;
413 
414  if(s->msmpeg4_version==1){
415  int start_code = get_bits_long(&s->gb, 32);
416  if(start_code!=0x00000100){
417  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
418  return -1;
419  }
420 
421  skip_bits(&s->gb, 5); // frame number */
422  }
423 
424  s->pict_type = get_bits(&s->gb, 2) + 1;
425  if (s->pict_type != AV_PICTURE_TYPE_I &&
426  s->pict_type != AV_PICTURE_TYPE_P){
427  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
428  return -1;
429  }
430  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
431  if(s->qscale==0){
432  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
433  return -1;
434  }
435 
436  if (s->pict_type == AV_PICTURE_TYPE_I) {
437  code = get_bits(&s->gb, 5);
438  if(s->msmpeg4_version==1){
439  if(code==0 || code>s->mb_height){
440  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
441  return -1;
442  }
443 
444  s->slice_height = code;
445  }else{
446  /* 0x17: one slice, 0x18: two slices, ... */
447  if (code < 0x17){
448  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
449  return -1;
450  }
451 
452  s->slice_height = s->mb_height / (code - 0x16);
453  }
454 
455  switch(s->msmpeg4_version){
456  case 1:
457  case 2:
458  s->rl_chroma_table_index = 2;
459  s->rl_table_index = 2;
460 
461  s->dc_table_index = 0; //not used
462  break;
463  case 3:
464  s->rl_chroma_table_index = decode012(&s->gb);
465  s->rl_table_index = decode012(&s->gb);
466 
467  s->dc_table_index = get_bits1(&s->gb);
468  break;
469  case 4:
470  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
471 
472  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
473  else s->per_mb_rl_table= 0;
474 
475  if(!s->per_mb_rl_table){
476  s->rl_chroma_table_index = decode012(&s->gb);
477  s->rl_table_index = decode012(&s->gb);
478  }
479 
480  s->dc_table_index = get_bits1(&s->gb);
481  s->inter_intra_pred= 0;
482  break;
483  }
484  s->no_rounding = 1;
485  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
486  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
487  s->qscale,
488  s->rl_chroma_table_index,
489  s->rl_table_index,
490  s->dc_table_index,
491  s->per_mb_rl_table,
492  s->slice_height);
493  } else {
494  switch(s->msmpeg4_version){
495  case 1:
496  case 2:
497  if(s->msmpeg4_version==1)
498  s->use_skip_mb_code = 1;
499  else
500  s->use_skip_mb_code = get_bits1(&s->gb);
501  s->rl_table_index = 2;
502  s->rl_chroma_table_index = s->rl_table_index;
503  s->dc_table_index = 0; //not used
504  s->mv_table_index = 0;
505  break;
506  case 3:
507  s->use_skip_mb_code = get_bits1(&s->gb);
508  s->rl_table_index = decode012(&s->gb);
509  s->rl_chroma_table_index = s->rl_table_index;
510 
511  s->dc_table_index = get_bits1(&s->gb);
512 
513  s->mv_table_index = get_bits1(&s->gb);
514  break;
515  case 4:
516  s->use_skip_mb_code = get_bits1(&s->gb);
517 
518  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
519  else s->per_mb_rl_table= 0;
520 
521  if(!s->per_mb_rl_table){
522  s->rl_table_index = decode012(&s->gb);
523  s->rl_chroma_table_index = s->rl_table_index;
524  }
525 
526  s->dc_table_index = get_bits1(&s->gb);
527 
528  s->mv_table_index = get_bits1(&s->gb);
529  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
530  break;
531  }
532 
533  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
534  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
535  s->use_skip_mb_code,
536  s->rl_table_index,
537  s->rl_chroma_table_index,
538  s->dc_table_index,
539  s->mv_table_index,
540  s->per_mb_rl_table,
541  s->qscale);
542 
543  if(s->flipflop_rounding){
544  s->no_rounding ^= 1;
545  }else{
546  s->no_rounding = 0;
547  }
548  }
549  ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
550  s->inter_intra_pred, s->width, s->height);
551 
552  s->esc3_level_length= 0;
553  s->esc3_run_length= 0;
554 
555  return 0;
556 }
557 
559 {
560  int left= buf_size*8 - get_bits_count(&s->gb);
561  int length= s->msmpeg4_version>=3 ? 17 : 16;
562  /* the alt_bitstream reader could read over the end so we need to check it */
563  if(left>=length && left<length+8)
564  {
565  skip_bits(&s->gb, 5); /* fps */
566  s->bit_rate= get_bits(&s->gb, 11)*1024;
567  if(s->msmpeg4_version>=3)
568  s->flipflop_rounding= get_bits1(&s->gb);
569  else
570  s->flipflop_rounding= 0;
571  }
572  else if(left<length+8)
573  {
574  s->flipflop_rounding= 0;
575  if(s->msmpeg4_version != 2)
576  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
577  }
578  else
579  {
580  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
581  }
582 
583  return 0;
584 }
585 
586 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
587 {
588  int level, pred;
589 
590  if(s->msmpeg4_version<=2){
591  if (n < 4) {
593  } else {
595  }
596  if (level < 0) {
597  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
598  *dir_ptr = 0;
599  return -1;
600  }
601  level-=256;
602  }else{ //FIXME optimize use unified tables & index
603  if (n < 4) {
604  level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
605  } else {
606  level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
607  }
608 
609  if (level == DC_MAX) {
610  level = get_bits(&s->gb, 8);
611  if (get_bits1(&s->gb))
612  level = -level;
613  } else if (level != 0) {
614  if (get_bits1(&s->gb))
615  level = -level;
616  }
617  }
618 
619  if(s->msmpeg4_version==1){
620  int32_t *dc_val;
621  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
622  level += pred;
623 
624  /* update predictor */
625  *dc_val= level;
626  }else{
627  int16_t *dc_val;
628  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
629  level += pred;
630 
631  /* update predictor */
632  if (n < 4) {
633  *dc_val = level * s->y_dc_scale;
634  } else {
635  *dc_val = level * s->c_dc_scale;
636  }
637  }
638 
639  return level;
640 }
641 
643  int n, int coded, const uint8_t *scan_table)
644 {
645  int level, i, last, run, run_diff;
646  int av_uninit(dc_pred_dir);
647  RLTable *rl;
649  int qmul, qadd;
650 
651  if (s->mb_intra) {
652  qmul=1;
653  qadd=0;
654 
655  /* DC coef */
656  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
657 
658  if (level < 0){
659  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
660  if(s->inter_intra_pred) level=0;
661  }
662  if (n < 4) {
663  rl = &ff_rl_table[s->rl_table_index];
664  if(level > 256*s->y_dc_scale){
665  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
666  if(!s->inter_intra_pred) return -1;
667  }
668  } else {
669  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
670  if(level > 256*s->c_dc_scale){
671  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
672  if(!s->inter_intra_pred) return -1;
673  }
674  }
675  block[0] = level;
676 
677  run_diff = s->msmpeg4_version >= 4;
678  i = 0;
679  if (!coded) {
680  goto not_coded;
681  }
682  if (s->ac_pred) {
683  if (dc_pred_dir == 0)
684  scan_table = s->intra_v_scantable.permutated; /* left */
685  else
686  scan_table = s->intra_h_scantable.permutated; /* top */
687  } else {
688  scan_table = s->intra_scantable.permutated;
689  }
690  rl_vlc= rl->rl_vlc[0];
691  } else {
692  qmul = s->qscale << 1;
693  qadd = (s->qscale - 1) | 1;
694  i = -1;
695  rl = &ff_rl_table[3 + s->rl_table_index];
696 
697  if(s->msmpeg4_version==2)
698  run_diff = 0;
699  else
700  run_diff = 1;
701 
702  if (!coded) {
703  s->block_last_index[n] = i;
704  return 0;
705  }
706  if(!scan_table)
707  scan_table = s->inter_scantable.permutated;
708  rl_vlc= rl->rl_vlc[s->qscale];
709  }
710  {
711  OPEN_READER(re, &s->gb);
712  for(;;) {
713  UPDATE_CACHE(re, &s->gb);
714  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
715  if (level==0) {
716  int cache;
717  cache= GET_CACHE(re, &s->gb);
718  /* escape */
719  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
720  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
721  /* third escape */
722  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
723  UPDATE_CACHE(re, &s->gb);
724  if(s->msmpeg4_version<=3){
725  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
726  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
727  level= SHOW_SBITS(re, &s->gb, 8);
728  SKIP_COUNTER(re, &s->gb, 1+6+8);
729  }else{
730  int sign;
731  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
732  if(!s->esc3_level_length){
733  int ll;
734  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
735  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
736  if(s->qscale<8){
737  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
738  if(ll==0){
739  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
740  }
741  }else{
742  ll=2;
743  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
744  ll++;
745  SKIP_BITS(re, &s->gb, 1);
746  }
747  if(ll<8) SKIP_BITS(re, &s->gb, 1);
748  }
749 
750  s->esc3_level_length= ll;
751  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
752  UPDATE_CACHE(re, &s->gb);
753  }
754  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
755  SKIP_BITS(re, &s->gb, s->esc3_run_length);
756 
757  sign= SHOW_UBITS(re, &s->gb, 1);
758  SKIP_BITS(re, &s->gb, 1);
759 
760  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
761  SKIP_BITS(re, &s->gb, s->esc3_level_length);
762  if(sign) level= -level;
763  }
764 
765  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
766  if (level>0) level= level * qmul + qadd;
767  else level= level * qmul - qadd;
768  i+= run + 1;
769  if(last) i+=192;
770  } else {
771  /* second escape */
772  SKIP_BITS(re, &s->gb, 2);
773  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
774  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
775  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
776  LAST_SKIP_BITS(re, &s->gb, 1);
777  }
778  } else {
779  /* first escape */
780  SKIP_BITS(re, &s->gb, 1);
781  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
782  i+= run;
783  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
784  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
785  LAST_SKIP_BITS(re, &s->gb, 1);
786  }
787  } else {
788  i+= run;
789  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
790  LAST_SKIP_BITS(re, &s->gb, 1);
791  }
792  if (i > 62){
793  i-= 192;
794  if(i&(~63)){
795  const int left= get_bits_left(&s->gb);
796  if (((i + 192 == 64 && level / qmul == -1) ||
797  !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
798  left >= 0) {
799  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
800  i = 63;
801  break;
802  }else{
803  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
804  return -1;
805  }
806  }
807 
808  block[scan_table[i]] = level;
809  break;
810  }
811 
812  block[scan_table[i]] = level;
813  }
814  CLOSE_READER(re, &s->gb);
815  }
816  not_coded:
817  if (s->mb_intra) {
818  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
819  if (s->ac_pred) {
820  i = 63; /* XXX: not optimal */
821  }
822  }
823  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
824  s->block_last_index[n] = i;
825 
826  return 0;
827 }
828 
829 void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
830 {
831  MVTable *mv;
832  int code, mx, my;
833 
834  mv = &ff_mv_tables[s->mv_table_index];
835 
836  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
838  mx = get_bits(&s->gb, 6);
839  my = get_bits(&s->gb, 6);
840  } else {
841  mx = mv->table_mvx[code];
842  my = mv->table_mvy[code];
843  }
844 
845  mx += *mx_ptr - 32;
846  my += *my_ptr - 32;
847  /* WARNING : they do not do exactly modulo encoding */
848  if (mx <= -64)
849  mx += 64;
850  else if (mx >= 64)
851  mx -= 64;
852 
853  if (my <= -64)
854  my += 64;
855  else if (my >= 64)
856  my -= 64;
857  *mx_ptr = mx;
858  *my_ptr = my;
859 }
860 
862  .name = "msmpeg4v1",
863  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
864  .type = AVMEDIA_TYPE_VIDEO,
865  .id = AV_CODEC_ID_MSMPEG4V1,
866  .priv_data_size = sizeof(MpegEncContext),
868  .close = ff_h263_decode_end,
871  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
872  .max_lowres = 3,
873  .pix_fmts = (const enum AVPixelFormat[]) {
876  },
877 };
878 
880  .name = "msmpeg4v2",
881  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
882  .type = AVMEDIA_TYPE_VIDEO,
883  .id = AV_CODEC_ID_MSMPEG4V2,
884  .priv_data_size = sizeof(MpegEncContext),
886  .close = ff_h263_decode_end,
889  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
890  .max_lowres = 3,
891  .pix_fmts = (const enum AVPixelFormat[]) {
894  },
895 };
896 
898  .name = "msmpeg4",
899  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
900  .type = AVMEDIA_TYPE_VIDEO,
901  .id = AV_CODEC_ID_MSMPEG4V3,
902  .priv_data_size = sizeof(MpegEncContext),
904  .close = ff_h263_decode_end,
907  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
908  .max_lowres = 3,
909  .pix_fmts = (const enum AVPixelFormat[]) {
912  },
913 };
914 
916  .name = "wmv1",
917  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
918  .type = AVMEDIA_TYPE_VIDEO,
919  .id = AV_CODEC_ID_WMV1,
920  .priv_data_size = sizeof(MpegEncContext),
922  .close = ff_h263_decode_end,
925  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
926  .max_lowres = 3,
927  .pix_fmts = (const enum AVPixelFormat[]) {
930  },
931 };
AVCodec
AVCodec.
Definition: codec.h:197
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:67
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:849
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
ff_msmpeg4v1_decoder
AVCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:861
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:546
mv
static const int8_t mv[256][2]
Definition: 4xm.c:78
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
MBAC_BITRATE
#define MBAC_BITRATE
Definition: msmpeg4.h:38
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:186
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:109
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:54
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:558
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:797
mpegvideo.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1660
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
ff_msmpeg4v3_decoder
AVCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:897
ff_rl_table
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:601
mpegutils.h
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1624
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
ff_msmp4_mb_i_table
const uint16_t ff_msmp4_mb_i_table[64][2]
Definition: msmpeg4data.c:43
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:180
ff_wmv2_inter_table
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1954
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:307
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_msmpeg4v2_decoder
AVCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:879
ff_msmpeg4_decode_motion
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:829
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_CODEC_ID_MSMPEG4V2
@ AV_CODEC_ID_MSMPEG4V2
Definition: codec_id.h:64
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:61
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:1654
NB_RL_TABLES
#define NB_RL_TABLES
Definition: msmpeg4data.h:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:71
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:402
msmpeg4data.h
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
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:133
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
ff_msmp4_dc_luma_vlc
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4data.c:39
ff_wmv1_decoder
AVCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:915
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AV_CODEC_ID_MSMPEG4V1
@ AV_CODEC_ID_MSMPEG4V1
Definition: codec_id.h:63
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:831
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:40
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
ff_table1_dc_chroma
const uint32_t ff_table1_dc_chroma[120][2]
Definition: msmpeg4data.c:201
int32_t
int32_t
Definition: audio_convert.c:194
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:1784
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:498
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
ff_table0_dc_lum
const uint32_t ff_table0_dc_lum[120][2]
Definition: msmpeg4data.c:100
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:66
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:161
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:117
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:62
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:138
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:193
ff_v2_intra_cbpc
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1789
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:70
i
int i
Definition: input.c:407
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:185
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:446
ff_mv_tables
MVTable ff_mv_tables[2]
Definition: msmpeg4data.c:1773
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:642
ff_h263_decode_end
int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:155
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
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:709
avcodec.h
msmpeg4.h
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:738
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:536
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:211
mpeg4video.h
ff_table_inter_intra
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1842
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:168
ff_static_rl_table_store
uint8_t ff_static_rl_table_store[NB_RL_TABLES][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: msmpeg4data.c:36
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:82
INIT_VLC_RL
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:58
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:586
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:421
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
imgutils.h
MSMPEG4_MV_TABLES_NB_ELEMS
#define MSMPEG4_MV_TABLES_NB_ELEMS
Definition: msmpeg4data.h:71
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:59
AV_CODEC_ID_MSMPEG4V3
@ AV_CODEC_ID_MSMPEG4V3
Definition: codec_id.h:65
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:317
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:38
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:153
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:73
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