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 "libavutil/thread.h"
26 
27 #include "avcodec.h"
28 #include "codec_internal.h"
29 #include "mpegutils.h"
30 #include "mpegvideo.h"
31 #include "msmpeg4.h"
32 #include "msmpeg4dec.h"
33 #include "libavutil/imgutils.h"
34 #include "h263.h"
35 #include "h263data.h"
36 #include "h263dec.h"
37 #include "mpeg4videodec.h"
38 #include "msmpeg4data.h"
39 #include "msmpeg4_vc1_data.h"
40 
41 #define V2_INTRA_CBPC_VLC_BITS 3
42 #define V2_MB_TYPE_VLC_BITS 7
43 #define MV_VLC_BITS 9
44 #define TEX_VLC_BITS 9
45 
46 #define DEFAULT_INTER_INDEX 3
47 
48 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
49  int32_t **dc_val_ptr)
50 {
51  int i;
52 
53  if (n < 4) {
54  i= 0;
55  } else {
56  i= n-3;
57  }
58 
59  *dc_val_ptr= &s->last_dc[i];
60  return s->last_dc[i];
61 }
62 
63 /****************************************/
64 /* decoding stuff */
65 
72 
73 /* This is identical to H.263 except that its range is multiplied by 2. */
74 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
75 {
76  int code, val, sign, shift;
77 
79  ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
80  if (code < 0)
81  return 0xffff;
82 
83  if (code == 0)
84  return pred;
85  sign = get_bits1(&s->gb);
86  shift = f_code - 1;
87  val = code;
88  if (shift) {
89  val = (val - 1) << shift;
90  val |= get_bits(&s->gb, shift);
91  val++;
92  }
93  if (sign)
94  val = -val;
95 
96  val += pred;
97  if (val <= -64)
98  val += 64;
99  else if (val >= 64)
100  val -= 64;
101 
102  return val;
103 }
104 
105 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
106 {
107  int cbp, code, i;
108  uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
109 
110  if (s->pict_type == AV_PICTURE_TYPE_P) {
111  if (s->use_skip_mb_code) {
112  if (get_bits1(&s->gb)) {
113  /* skip mb */
114  s->mb_intra = 0;
115  for(i=0;i<6;i++)
116  s->block_last_index[i] = -1;
117  s->mv_dir = MV_DIR_FORWARD;
118  s->mv_type = MV_TYPE_16X16;
119  s->mv[0][0][0] = 0;
120  s->mv[0][0][1] = 0;
121  s->mb_skipped = 1;
122  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
123  return 0;
124  }
125  }
126 
127  if(s->msmpeg4_version==2)
129  else
131  if(code<0 || code>7){
132  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
133  return -1;
134  }
135 
136  s->mb_intra = code >>2;
137 
138  cbp = code & 0x3;
139  } else {
140  s->mb_intra = 1;
141  if(s->msmpeg4_version==2)
143  else
145  if(cbp<0 || cbp>3){
146  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
147  return -1;
148  }
149  }
150 
151  if (!s->mb_intra) {
152  int mx, my, cbpy;
153 
154  cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
155  if(cbpy<0){
156  av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
157  return -1;
158  }
159 
160  cbp|= cbpy<<2;
161  if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
162 
163  ff_h263_pred_motion(s, 0, 0, &mx, &my);
164  mx= msmpeg4v2_decode_motion(s, mx, 1);
165  my= msmpeg4v2_decode_motion(s, my, 1);
166 
167  s->mv_dir = MV_DIR_FORWARD;
168  s->mv_type = MV_TYPE_16X16;
169  s->mv[0][0][0] = mx;
170  s->mv[0][0][1] = my;
171  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
172  } else {
173  int v;
174  if(s->msmpeg4_version==2){
175  s->ac_pred = get_bits1(&s->gb);
177  if (v < 0) {
178  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
179  return -1;
180  }
181  cbp|= v<<2;
182  } else{
183  s->ac_pred = 0;
185  if (v < 0) {
186  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
187  return -1;
188  }
189  cbp|= v<<2;
190  if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
191  }
192  *mb_type_ptr = MB_TYPE_INTRA;
193  }
194 
195  s->bdsp.clear_blocks(s->block[0]);
196  for (i = 0; i < 6; i++) {
197  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
198  {
199  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
200  return -1;
201  }
202  }
203  return 0;
204 }
205 
206 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
207 {
208  int cbp, code, i;
209  uint8_t *coded_val;
210  uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
211 
212  if (get_bits_left(&s->gb) <= 0)
213  return AVERROR_INVALIDDATA;
214 
215  if (s->pict_type == AV_PICTURE_TYPE_P) {
216  if (s->use_skip_mb_code) {
217  if (get_bits1(&s->gb)) {
218  /* skip mb */
219  s->mb_intra = 0;
220  for(i=0;i<6;i++)
221  s->block_last_index[i] = -1;
222  s->mv_dir = MV_DIR_FORWARD;
223  s->mv_type = MV_TYPE_16X16;
224  s->mv[0][0][0] = 0;
225  s->mv[0][0][1] = 0;
226  s->mb_skipped = 1;
227  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
228 
229  return 0;
230  }
231  }
232 
234  //s->mb_intra = (code & 0x40) ? 0 : 1;
235  s->mb_intra = (~code & 0x40) >> 6;
236 
237  cbp = code & 0x3f;
238  } else {
239  s->mb_intra = 1;
241  /* predict coded block pattern */
242  cbp = 0;
243  for(i=0;i<6;i++) {
244  int val = ((code >> (5 - i)) & 1);
245  if (i < 4) {
246  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
247  val = val ^ pred;
248  *coded_val = val;
249  }
250  cbp |= val << (5 - i);
251  }
252  }
253 
254  if (!s->mb_intra) {
255  int mx, my;
256  if(s->per_mb_rl_table && cbp){
257  s->rl_table_index = decode012(&s->gb);
258  s->rl_chroma_table_index = s->rl_table_index;
259  }
260  ff_h263_pred_motion(s, 0, 0, &mx, &my);
261  ff_msmpeg4_decode_motion(s, &mx, &my);
262  s->mv_dir = MV_DIR_FORWARD;
263  s->mv_type = MV_TYPE_16X16;
264  s->mv[0][0][0] = mx;
265  s->mv[0][0][1] = my;
266  *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
267  } else {
268  ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
269  ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
270  show_bits(&s->gb, 24));
271  s->ac_pred = get_bits1(&s->gb);
272  *mb_type_ptr = MB_TYPE_INTRA;
273  if(s->inter_intra_pred){
274  s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
275  ff_dlog(s, "%d%d %d %d/",
276  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
277  }
278  if(s->per_mb_rl_table && cbp){
279  s->rl_table_index = decode012(&s->gb);
280  s->rl_chroma_table_index = s->rl_table_index;
281  }
282  }
283 
284  s->bdsp.clear_blocks(s->block[0]);
285  for (i = 0; i < 6; i++) {
286  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
287  {
288  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
289  return -1;
290  }
291  }
292 
293  return 0;
294 }
295 
296 /* init all vlc decoding tables */
298 {
299  MVTable *mv;
300 
302  INIT_FIRST_VLC_RL(ff_rl_table[1], 1104);
304  INIT_VLC_RL(ff_rl_table[3], 940);
305  INIT_VLC_RL(ff_rl_table[4], 962);
306  /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been
307  * initialized in ff_h263_decode_init() earlier. So just copy the VLCs. */
310 
311  mv = &ff_mv_tables[0];
313  mv->table_mv_bits, 1, 1,
314  mv->table_mv_code, 2, 2, 3714);
315  mv = &ff_mv_tables[1];
317  mv->table_mv_bits, 1, 1,
318  mv->table_mv_code, 2, 2, 2694);
319 
321  &ff_v2_dc_lum_table[0][1], 8, 4,
322  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
324  &ff_v2_dc_chroma_table[0][1], 8, 4,
325  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
326 
328  &ff_v2_intra_cbpc[0][1], 2, 1,
329  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
331  &ff_v2_mb_type[0][1], 2, 1,
332  &ff_v2_mb_type[0][0], 2, 1, 128);
333 
334  for (unsigned i = 0, offset = 0; i < 4; i++) {
335  static VLCElem vlc_buf[1636 + 2648 + 1532 + 2488];
339  &ff_wmv2_inter_table[i][0][1], 8, 4,
340  &ff_wmv2_inter_table[i][0][0], 8, 4,
343  }
344 
346  &ff_table_inter_intra[0][1], 2, 1,
347  &ff_table_inter_intra[0][0], 2, 1, 8);
349 }
350 
352 {
353  static AVOnce init_static_once = AV_ONCE_INIT;
354  MpegEncContext *s = avctx->priv_data;
355  int ret;
356 
357  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
358  return ret;
359 
360  if (ff_h263_decode_init(avctx) < 0)
361  return -1;
362 
364 
365  switch(s->msmpeg4_version){
366  case 1:
367  case 2:
368  s->decode_mb= msmpeg4v12_decode_mb;
369  break;
370  case 3:
371  case 4:
372  s->decode_mb= msmpeg4v34_decode_mb;
373  break;
374  case 5:
375  break;
376  }
377 
378  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
379 
380  ff_thread_once(&init_static_once, msmpeg4_decode_init_static);
381 
382  return 0;
383 }
384 
386 {
387  int code;
388 
389  // at minimum one bit per macroblock is required at least in a valid frame,
390  // we discard frames much smaller than this. Frames smaller than 1/8 of the
391  // smallest "black/skip" frame generally contain not much recoverable content
392  // while at the same time they have the highest computational requirements
393  // per byte
394  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
395  return AVERROR_INVALIDDATA;
396 
397  if(s->msmpeg4_version==1){
398  int start_code = get_bits_long(&s->gb, 32);
399  if(start_code!=0x00000100){
400  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
401  return -1;
402  }
403 
404  skip_bits(&s->gb, 5); // frame number */
405  }
406 
407  s->pict_type = get_bits(&s->gb, 2) + 1;
408  if (s->pict_type != AV_PICTURE_TYPE_I &&
409  s->pict_type != AV_PICTURE_TYPE_P){
410  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
411  return -1;
412  }
413  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
414  if(s->qscale==0){
415  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
416  return -1;
417  }
418 
419  if (s->pict_type == AV_PICTURE_TYPE_I) {
420  code = get_bits(&s->gb, 5);
421  if(s->msmpeg4_version==1){
422  if(code==0 || code>s->mb_height){
423  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
424  return -1;
425  }
426 
427  s->slice_height = code;
428  }else{
429  /* 0x17: one slice, 0x18: two slices, ... */
430  if (code < 0x17){
431  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
432  return -1;
433  }
434 
435  s->slice_height = s->mb_height / (code - 0x16);
436  }
437 
438  switch(s->msmpeg4_version){
439  case 1:
440  case 2:
441  s->rl_chroma_table_index = 2;
442  s->rl_table_index = 2;
443 
444  s->dc_table_index = 0; //not used
445  break;
446  case 3:
447  s->rl_chroma_table_index = decode012(&s->gb);
448  s->rl_table_index = decode012(&s->gb);
449 
450  s->dc_table_index = get_bits1(&s->gb);
451  break;
452  case 4:
453  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
454 
455  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
456  else s->per_mb_rl_table= 0;
457 
458  if(!s->per_mb_rl_table){
459  s->rl_chroma_table_index = decode012(&s->gb);
460  s->rl_table_index = decode012(&s->gb);
461  }
462 
463  s->dc_table_index = get_bits1(&s->gb);
464  s->inter_intra_pred= 0;
465  break;
466  }
467  s->no_rounding = 1;
468  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
469  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
470  s->qscale,
471  s->rl_chroma_table_index,
472  s->rl_table_index,
473  s->dc_table_index,
474  s->per_mb_rl_table,
475  s->slice_height);
476  } else {
477  switch(s->msmpeg4_version){
478  case 1:
479  case 2:
480  if(s->msmpeg4_version==1)
481  s->use_skip_mb_code = 1;
482  else
483  s->use_skip_mb_code = get_bits1(&s->gb);
484  s->rl_table_index = 2;
485  s->rl_chroma_table_index = s->rl_table_index;
486  s->dc_table_index = 0; //not used
487  s->mv_table_index = 0;
488  break;
489  case 3:
490  s->use_skip_mb_code = get_bits1(&s->gb);
491  s->rl_table_index = decode012(&s->gb);
492  s->rl_chroma_table_index = s->rl_table_index;
493 
494  s->dc_table_index = get_bits1(&s->gb);
495 
496  s->mv_table_index = get_bits1(&s->gb);
497  break;
498  case 4:
499  s->use_skip_mb_code = get_bits1(&s->gb);
500 
501  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
502  else s->per_mb_rl_table= 0;
503 
504  if(!s->per_mb_rl_table){
505  s->rl_table_index = decode012(&s->gb);
506  s->rl_chroma_table_index = s->rl_table_index;
507  }
508 
509  s->dc_table_index = get_bits1(&s->gb);
510 
511  s->mv_table_index = get_bits1(&s->gb);
512  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
513  break;
514  }
515 
516  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
517  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
518  s->use_skip_mb_code,
519  s->rl_table_index,
520  s->rl_chroma_table_index,
521  s->dc_table_index,
522  s->mv_table_index,
523  s->per_mb_rl_table,
524  s->qscale);
525 
526  if(s->flipflop_rounding){
527  s->no_rounding ^= 1;
528  }else{
529  s->no_rounding = 0;
530  }
531  }
532  ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
533  s->inter_intra_pred, s->width, s->height);
534 
535  s->esc3_level_length= 0;
536  s->esc3_run_length= 0;
537 
538  return 0;
539 }
540 
542 {
543  int left= buf_size*8 - get_bits_count(&s->gb);
544  int length= s->msmpeg4_version>=3 ? 17 : 16;
545  /* the alt_bitstream reader could read over the end so we need to check it */
546  if(left>=length && left<length+8)
547  {
548  skip_bits(&s->gb, 5); /* fps */
549  s->bit_rate= get_bits(&s->gb, 11)*1024;
550  if(s->msmpeg4_version>=3)
551  s->flipflop_rounding= get_bits1(&s->gb);
552  else
553  s->flipflop_rounding= 0;
554  }
555  else if(left<length+8)
556  {
557  s->flipflop_rounding= 0;
558  if(s->msmpeg4_version != 2)
559  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
560  }
561  else
562  {
563  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
564  }
565 
566  return 0;
567 }
568 
569 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
570 {
571  int level, pred;
572 
573  if(s->msmpeg4_version<=2){
574  if (n < 4) {
576  } else {
578  }
579  if (level < 0) {
580  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
581  *dir_ptr = 0;
582  return -1;
583  }
584  level-=256;
585  }else{ //FIXME optimize use unified tables & index
586  if (n < 4) {
587  level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table,
588  MSMP4_DC_VLC_BITS, 3);
589  } else {
590  level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table,
591  MSMP4_DC_VLC_BITS, 3);
592  }
593 
594  if (level == DC_MAX) {
595  level = get_bits(&s->gb, 8);
596  if (get_bits1(&s->gb))
597  level = -level;
598  } else if (level != 0) {
599  if (get_bits1(&s->gb))
600  level = -level;
601  }
602  }
603 
604  if(s->msmpeg4_version==1){
605  int32_t *dc_val;
606  pred = msmpeg4v1_pred_dc(s, n, &dc_val);
607  level += pred;
608 
609  /* update predictor */
610  *dc_val= level;
611  }else{
612  int16_t *dc_val;
613  pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
614  level += pred;
615 
616  /* update predictor */
617  if (n < 4) {
618  *dc_val = level * s->y_dc_scale;
619  } else {
620  *dc_val = level * s->c_dc_scale;
621  }
622  }
623 
624  return level;
625 }
626 
628  int n, int coded, const uint8_t *scan_table)
629 {
630  int level, i, last, run, run_diff;
631  int av_uninit(dc_pred_dir);
632  RLTable *rl;
634  int qmul, qadd;
635 
636  if (s->mb_intra) {
637  qmul=1;
638  qadd=0;
639 
640  /* DC coef */
641  level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
642 
643  if (level < 0){
644  av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
645  if(s->inter_intra_pred) level=0;
646  }
647  if (n < 4) {
648  rl = &ff_rl_table[s->rl_table_index];
649  if(level > 256*s->y_dc_scale){
650  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
651  if(!s->inter_intra_pred) return -1;
652  }
653  } else {
654  rl = &ff_rl_table[3 + s->rl_chroma_table_index];
655  if(level > 256*s->c_dc_scale){
656  av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
657  if(!s->inter_intra_pred) return -1;
658  }
659  }
660  block[0] = level;
661 
662  run_diff = s->msmpeg4_version >= 4;
663  i = 0;
664  if (!coded) {
665  goto not_coded;
666  }
667  if (s->ac_pred) {
668  if (dc_pred_dir == 0)
669  scan_table = s->permutated_intra_v_scantable; /* left */
670  else
671  scan_table = s->permutated_intra_h_scantable; /* top */
672  } else {
673  scan_table = s->intra_scantable.permutated;
674  }
675  rl_vlc= rl->rl_vlc[0];
676  } else {
677  qmul = s->qscale << 1;
678  qadd = (s->qscale - 1) | 1;
679  i = -1;
680  rl = &ff_rl_table[3 + s->rl_table_index];
681 
682  if(s->msmpeg4_version==2)
683  run_diff = 0;
684  else
685  run_diff = 1;
686 
687  if (!coded) {
688  s->block_last_index[n] = i;
689  return 0;
690  }
691  if(!scan_table)
692  scan_table = s->inter_scantable.permutated;
693  rl_vlc= rl->rl_vlc[s->qscale];
694  }
695  {
696  OPEN_READER(re, &s->gb);
697  for(;;) {
698  UPDATE_CACHE(re, &s->gb);
699  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
700  if (level==0) {
701  int cache;
702  cache= GET_CACHE(re, &s->gb);
703  /* escape */
704  if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
705  if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
706  /* third escape */
707  if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
708  UPDATE_CACHE(re, &s->gb);
709  if(s->msmpeg4_version<=3){
710  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
711  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
712  level= SHOW_SBITS(re, &s->gb, 8);
713  SKIP_COUNTER(re, &s->gb, 1+6+8);
714  }else{
715  int sign;
716  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
717  if(!s->esc3_level_length){
718  int ll;
719  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
720  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
721  if(s->qscale<8){
722  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
723  if(ll==0){
724  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
725  }
726  }else{
727  ll=2;
728  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
729  ll++;
730  SKIP_BITS(re, &s->gb, 1);
731  }
732  if(ll<8) SKIP_BITS(re, &s->gb, 1);
733  }
734 
735  s->esc3_level_length= ll;
736  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
737  UPDATE_CACHE(re, &s->gb);
738  }
739  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
740  SKIP_BITS(re, &s->gb, s->esc3_run_length);
741 
742  sign= SHOW_UBITS(re, &s->gb, 1);
743  SKIP_BITS(re, &s->gb, 1);
744 
745  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
746  SKIP_BITS(re, &s->gb, s->esc3_level_length);
747  if(sign) level= -level;
748  }
749 
750  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
751  if (level>0) level= level * qmul + qadd;
752  else level= level * qmul - qadd;
753  i+= run + 1;
754  if(last) i+=192;
755  } else {
756  /* second escape */
757  SKIP_BITS(re, &s->gb, 2);
758  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
759  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
760  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
761  LAST_SKIP_BITS(re, &s->gb, 1);
762  }
763  } else {
764  /* first escape */
765  SKIP_BITS(re, &s->gb, 1);
766  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
767  i+= run;
768  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
769  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
770  LAST_SKIP_BITS(re, &s->gb, 1);
771  }
772  } else {
773  i+= run;
774  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
775  LAST_SKIP_BITS(re, &s->gb, 1);
776  }
777  if (i > 62){
778  i-= 192;
779  if(i&(~63)){
780  const int left= get_bits_left(&s->gb);
781  if (((i + 192 == 64 && level / qmul == -1) ||
782  !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
783  left >= 0) {
784  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
785  i = 63;
786  break;
787  }else{
788  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
789  return -1;
790  }
791  }
792 
793  block[scan_table[i]] = level;
794  break;
795  }
796 
797  block[scan_table[i]] = level;
798  }
799  CLOSE_READER(re, &s->gb);
800  }
801  not_coded:
802  if (s->mb_intra) {
803  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
804  if (s->ac_pred) {
805  i = 63; /* XXX: not optimal */
806  }
807  }
808  if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
809  s->block_last_index[n] = i;
810 
811  return 0;
812 }
813 
814 void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
815 {
816  MVTable *mv;
817  int code, mx, my;
818 
819  mv = &ff_mv_tables[s->mv_table_index];
820 
821  code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
823  mx = get_bits(&s->gb, 6);
824  my = get_bits(&s->gb, 6);
825  } else {
826  mx = mv->table_mvx[code];
827  my = mv->table_mvy[code];
828  }
829 
830  mx += *mx_ptr - 32;
831  my += *my_ptr - 32;
832  /* WARNING : they do not do exactly modulo encoding */
833  if (mx <= -64)
834  mx += 64;
835  else if (mx >= 64)
836  mx -= 64;
837 
838  if (my <= -64)
839  my += 64;
840  else if (my >= 64)
841  my -= 64;
842  *mx_ptr = mx;
843  *my_ptr = my;
844 }
845 
847  .p.name = "msmpeg4v1",
848  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 1"),
849  .p.type = AVMEDIA_TYPE_VIDEO,
850  .p.id = AV_CODEC_ID_MSMPEG4V1,
851  .priv_data_size = sizeof(MpegEncContext),
853  .close = ff_h263_decode_end,
856  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
857  .p.max_lowres = 3,
858  .p.pix_fmts = (const enum AVPixelFormat[]) {
861  },
862 };
863 
865  .p.name = "msmpeg4v2",
866  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 2"),
867  .p.type = AVMEDIA_TYPE_VIDEO,
868  .p.id = AV_CODEC_ID_MSMPEG4V2,
869  .priv_data_size = sizeof(MpegEncContext),
871  .close = ff_h263_decode_end,
874  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
875  .p.max_lowres = 3,
876  .p.pix_fmts = (const enum AVPixelFormat[]) {
879  },
880 };
881 
883  .p.name = "msmpeg4",
884  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 3"),
885  .p.type = AVMEDIA_TYPE_VIDEO,
886  .p.id = AV_CODEC_ID_MSMPEG4V3,
887  .priv_data_size = sizeof(MpegEncContext),
889  .close = ff_h263_decode_end,
892  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
893  .p.max_lowres = 3,
894  .p.pix_fmts = (const enum AVPixelFormat[]) {
897  },
898 };
899 
901  .p.name = "wmv1",
902  CODEC_LONG_NAME("Windows Media Video 7"),
903  .p.type = AVMEDIA_TYPE_VIDEO,
904  .p.id = AV_CODEC_ID_WMV1,
905  .priv_data_size = sizeof(MpegEncContext),
907  .close = ff_h263_decode_end,
910  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
911  .p.max_lowres = 3,
912  .p.pix_fmts = (const enum AVPixelFormat[]) {
915  },
916 };
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:60
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:263
h263data.h
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
thread.h
msmpeg4v1_pred_dc
static int msmpeg4v1_pred_dc(MpegEncContext *s, int n, int32_t **dc_val_ptr)
Definition: msmpeg4dec.c:48
mpeg4videodec.h
msmpeg4v2_decode_motion
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4dec.c:74
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:125
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:80
msmpeg4_decode_init_static
static av_cold void msmpeg4_decode_init_static(void)
Definition: msmpeg4dec.c:297
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
MBAC_BITRATE
#define MBAC_BITRATE
Definition: msmpeg4.h:30
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:198
ff_msmp4_dc_luma_vlc
VLC ff_msmp4_dc_luma_vlc[2]
Definition: msmpeg4_vc1_data.c:36
ff_msmp4_mb_i_vlc
VLC ff_msmp4_mb_i_vlc
Definition: msmpeg4_vc1_data.c:35
ff_msmpeg4_common_init
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:114
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
MSMP4_MB_INTRA_VLC_BITS
#define MSMP4_MB_INTRA_VLC_BITS
Definition: msmpeg4_vc1_data.h:36
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:541
FFCodec
Definition: codec_internal.h:119
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
ff_rl_table
RLTable ff_rl_table[NB_RL_TABLES]
Definition: msmpeg4data.c:441
mpegutils.h
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1328
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
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
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
ff_wmv2_inter_table
const uint32_t(*const [WMV2_INTER_CBP_TABLE_COUNT] ff_wmv2_inter_table)[2]
Definition: msmpeg4data.c:1760
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
ff_mpeg4_pred_ac
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:314
RLTable
RLTable.
Definition: rl.h:39
ff_mb_non_intra_vlc
VLC ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:66
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: defs.h:49
ff_msmpeg4_decode_motion
void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
Definition: msmpeg4dec.c:814
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_CODEC_ID_MSMPEG4V2
@ AV_CODEC_ID_MSMPEG4V2
Definition: codec_id.h:67
MV_VLC_BITS
#define MV_VLC_BITS
Definition: msmpeg4dec.c:43
V2_INTRA_CBPC_VLC_BITS
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4dec.c:41
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:184
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:93
h263dec.h
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_msmp4_dc_chroma_vlc
VLC ff_msmp4_dc_chroma_vlc[2]
Definition: msmpeg4_vc1_data.c:37
ff_msmp4_vc1_vlcs_init_once
av_cold void ff_msmp4_vc1_vlcs_init_once(void)
Definition: msmpeg4_vc1_data.c:59
ff_msmpeg4_decode_picture_header
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:385
msmpeg4data.h
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
RLTable::max_level
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
s
#define s(width, name)
Definition: cbs_vp9.c:256
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
ff_h263_inter_MCBPC_vlc
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:103
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
vlc_buf
static VLCElem vlc_buf[16716]
Definition: clearvideo.c:80
ff_msmpeg4v1_decoder
const FFCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:846
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:66
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
decode012
static int decode012(GetBitContext *gb)
Definition: get_bits.h:821
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
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
DEFAULT_INTER_INDEX
#define DEFAULT_INTER_INDEX
Definition: msmpeg4dec.c:46
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
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:1624
ff_v2_dc_lum_table
uint32_t ff_v2_dc_lum_table[512][2]
Definition: msmpeg4data.c:35
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
INTER_INTRA_VLC_BITS
#define INTER_INTRA_VLC_BITS
Definition: msmpeg4dec.h:28
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:416
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
ff_h263_mv_vlc
VLC ff_h263_mv_vlc
Definition: ituh263dec.c:105
ff_v2_dc_chroma_table
uint32_t ff_v2_dc_chroma_table[512][2]
Definition: msmpeg4data.c:36
DC_MAX
#define DC_MAX
Definition: msmpeg4.h:32
AV_CODEC_ID_WMV1
@ AV_CODEC_ID_WMV1
Definition: codec_id.h:69
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
V2_MB_TYPE_VLC_BITS
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4dec.c:42
AVOnce
#define AVOnce
Definition: thread.h:181
v2_dc_lum_vlc
static VLC v2_dc_lum_vlc
Definition: msmpeg4dec.c:67
ff_h263_decode_end
av_cold int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:147
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
VLC::table_allocated
int table_allocated
Definition: vlc.h:34
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
MB_NON_INTRA_VLC_BITS
#define MB_NON_INTRA_VLC_BITS
Definition: msmpeg4dec.h:29
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
RL_VLC_ELEM
Definition: vlc.h:37
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:253
MSMP4_DC_VLC_BITS
#define MSMP4_DC_VLC_BITS
Definition: msmpeg4_vc1_data.h:38
VLCElem
Definition: vlc.h:27
ff_inter_intra_vlc
VLC ff_inter_intra_vlc
Definition: msmpeg4dec.c:71
msmpeg4v12_decode_mb
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:105
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263dec.h:33
msmpeg4v34_decode_mb
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:206
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: codec_internal.h:54
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
II_BITRATE
#define II_BITRATE
Definition: msmpeg4.h:29
ff_msmpeg4v3_decoder
const FFCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:882
v2_intra_cbpc_vlc
static VLC v2_intra_cbpc_vlc
Definition: msmpeg4dec.c:69
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
ff_msmpeg4_pred_dc
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:194
ff_v2_intra_cbpc
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1629
msmpeg4dec.h
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
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:185
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:1613
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:627
ff_h263_intra_MCBPC_vlc
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:102
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:31
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:211
ff_h263_decode_init
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:74
AVCodecContext::height
int height
Definition: avcodec.h:571
avcodec.h
msmpeg4.h
ff_wmv1_decoder
const FFCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:900
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:728
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:101
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
AVCodecContext
main external API structure.
Definition: avcodec.h:398
v2_dc_chroma_vlc
static VLC v2_dc_chroma_vlc
Definition: msmpeg4dec.c:68
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
ff_table_inter_intra
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1648
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:31
v2_mb_type_vlc
static VLC v2_mb_type_vlc
Definition: msmpeg4dec.c:70
VLC::table
VLCElem * table
Definition: vlc.h:33
MVTable
Definition: msmpeg4data.h:41
VLC::table_size
int table_size
Definition: vlc.h:34
INIT_VLC_RL
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
msmpeg4_vc1_data.h
msmpeg4_decode_dc
static int msmpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Definition: msmpeg4dec.c:569
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:259
ff_h263_cbpy_vlc
VLC ff_h263_cbpy_vlc
Definition: ituh263dec.c:104
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
ff_msmpeg4v2_decoder
const FFCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:864
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
MSMPEG4_MV_TABLES_NB_ELEMS
#define MSMPEG4_MV_TABLES_NB_ELEMS
Definition: msmpeg4data.h:62
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:27
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:68
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
H263_MV_VLC_BITS
#define H263_MV_VLC_BITS
Definition: h263dec.h:30
ff_msmpeg4_decode_init
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:351
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:70
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:154
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:44
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:66
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263dec.h:32
re
float re
Definition: fft.c:79
h263.h
rl_vlc
static VLC rl_vlc[2]
Definition: mobiclip.c:277