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 "mpegvideodec.h"
32 #include "msmpeg4.h"
33 #include "msmpeg4dec.h"
34 #include "libavutil/imgutils.h"
35 #include "h263.h"
36 #include "h263data.h"
37 #include "h263dec.h"
38 #include "mpeg4videodec.h"
39 #include "msmpeg4data.h"
40 #include "msmpeg4_vc1_data.h"
41 
42 #define V2_INTRA_CBPC_VLC_BITS 3
43 #define V2_MB_TYPE_VLC_BITS 7
44 #define MV_VLC_BITS 9
45 #define TEX_VLC_BITS 9
46 
47 #define DEFAULT_INTER_INDEX 3
48 
49 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
50  int32_t **dc_val_ptr)
51 {
52  int i;
53 
54  if (n < 4) {
55  i= 0;
56  } else {
57  i= n-3;
58  }
59 
60  *dc_val_ptr= &s->last_dc[i];
61  return s->last_dc[i];
62 }
63 
64 /****************************************/
65 /* decoding stuff */
66 
68 static VLCElem v2_dc_lum_vlc[1472];
71 static VLCElem v2_mb_type_vlc[128];
73 
74 /* This is identical to H.263 except that its range is multiplied by 2. */
75 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
76 {
77  int code, val, sign, shift;
78 
80  ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
81  if (code < 0)
82  return 0xffff;
83 
84  if (code == 0)
85  return pred;
86  sign = get_bits1(&s->gb);
87  shift = f_code - 1;
88  val = code;
89  if (shift) {
90  val = (val - 1) << shift;
91  val |= get_bits(&s->gb, shift);
92  val++;
93  }
94  if (sign)
95  val = -val;
96 
97  val += pred;
98  if (val <= -64)
99  val += 64;
100  else if (val >= 64)
101  val -= 64;
102 
103  return val;
104 }
105 
106 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
107 {
108  int cbp, code, i;
109  uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->mb_stride];
110 
111  if (s->pict_type == AV_PICTURE_TYPE_P) {
112  if (s->use_skip_mb_code) {
113  if (get_bits1(&s->gb)) {
114  /* skip mb */
115  s->mb_intra = 0;
116  for(i=0;i<6;i++)
117  s->block_last_index[i] = -1;
118  s->mv_dir = MV_DIR_FORWARD;
119  s->mv_type = MV_TYPE_16X16;
120  s->mv[0][0][0] = 0;
121  s->mv[0][0][1] = 0;
122  s->mb_skipped = 1;
123  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
124  return 0;
125  }
126  }
127 
128  if (s->msmpeg4_version == MSMP4_V2)
130  else
132  if(code<0 || code>7){
133  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
134  return -1;
135  }
136 
137  s->mb_intra = code >>2;
138 
139  cbp = code & 0x3;
140  } else {
141  s->mb_intra = 1;
142  if (s->msmpeg4_version == MSMP4_V2)
144  else
146  if(cbp<0 || cbp>3){
147  av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
148  return -1;
149  }
150  }
151 
152  if (!s->mb_intra) {
153  int mx, my, cbpy;
154 
155  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
156  if(cbpy<0){
157  av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
158  return -1;
159  }
160 
161  cbp|= cbpy<<2;
162  if (s->msmpeg4_version == MSMP4_V1 || (cbp&3) != 3)
163  cbp ^= 0x3C;
164 
165  ff_h263_pred_motion(s, 0, 0, &mx, &my);
168 
169  s->mv_dir = MV_DIR_FORWARD;
170  s->mv_type = MV_TYPE_16X16;
171  s->mv[0][0][0] = mx;
172  s->mv[0][0][1] = my;
173  *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
174  } else {
175  int v;
176  if (s->msmpeg4_version == MSMP4_V2) {
177  s->ac_pred = get_bits1(&s->gb);
178  v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
179  if (v < 0) {
180  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
181  return -1;
182  }
183  cbp|= v<<2;
184  } else{
185  s->ac_pred = 0;
186  v = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
187  if (v < 0) {
188  av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
189  return -1;
190  }
191  cbp|= v<<2;
192  if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
193  }
194  *mb_type_ptr = MB_TYPE_INTRA;
195  }
196 
197  s->bdsp.clear_blocks(s->block[0]);
198  for (i = 0; i < 6; i++) {
199  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
200  {
201  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
202  return -1;
203  }
204  }
205  return 0;
206 }
207 
208 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
209 {
210  int cbp, code, i;
211  uint8_t *coded_val;
212  uint32_t * const mb_type_ptr = &s->cur_pic.mb_type[s->mb_x + s->mb_y*s->mb_stride];
213 
214  if (get_bits_left(&s->gb) <= 0)
215  return AVERROR_INVALIDDATA;
216 
217  if (s->pict_type == AV_PICTURE_TYPE_P) {
218  if (s->use_skip_mb_code) {
219  if (get_bits1(&s->gb)) {
220  /* skip mb */
221  s->mb_intra = 0;
222  for(i=0;i<6;i++)
223  s->block_last_index[i] = -1;
224  s->mv_dir = MV_DIR_FORWARD;
225  s->mv_type = MV_TYPE_16X16;
226  s->mv[0][0][0] = 0;
227  s->mv[0][0][1] = 0;
228  s->mb_skipped = 1;
229  *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
230 
231  return 0;
232  }
233  }
234 
236  //s->mb_intra = (code & 0x40) ? 0 : 1;
237  s->mb_intra = (~code & 0x40) >> 6;
238 
239  cbp = code & 0x3f;
240  } else {
241  s->mb_intra = 1;
243  /* predict coded block pattern */
244  cbp = 0;
245  for(i=0;i<6;i++) {
246  int val = ((code >> (5 - i)) & 1);
247  if (i < 4) {
248  int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
249  val = val ^ pred;
250  *coded_val = val;
251  }
252  cbp |= val << (5 - i);
253  }
254  }
255 
256  if (!s->mb_intra) {
257  int mx, my;
258  if(s->per_mb_rl_table && cbp){
259  s->rl_table_index = decode012(&s->gb);
260  s->rl_chroma_table_index = s->rl_table_index;
261  }
262  ff_h263_pred_motion(s, 0, 0, &mx, &my);
264  s->mv_dir = MV_DIR_FORWARD;
265  s->mv_type = MV_TYPE_16X16;
266  s->mv[0][0][0] = mx;
267  s->mv[0][0][1] = my;
268  *mb_type_ptr = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
269  } else {
270  ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
271  ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
272  show_bits(&s->gb, 24));
273  s->ac_pred = get_bits1(&s->gb);
274  *mb_type_ptr = MB_TYPE_INTRA;
275  if(s->inter_intra_pred){
276  s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 1);
277  ff_dlog(s, "%d%d %d %d/",
278  s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
279  }
280  if(s->per_mb_rl_table && cbp){
281  s->rl_table_index = decode012(&s->gb);
282  s->rl_chroma_table_index = s->rl_table_index;
283  }
284  }
285 
286  s->bdsp.clear_blocks(s->block[0]);
287  for (i = 0; i < 6; i++) {
288  if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
289  {
290  av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
291  return -1;
292  }
293  }
294 
295  return 0;
296 }
297 
298 /* init all vlc decoding tables */
300 {
301  static VLCElem vlc_buf[3714 + 2694 + 1636 + 2648 + 1532 + 2488];
302  VLCInitState state = VLC_INIT_STATE(vlc_buf);
303  MVTable *mv;
304 
306  INIT_FIRST_VLC_RL(ff_rl_table[1], 1104);
308  VLC_INIT_RL(ff_rl_table[3], 940);
309  VLC_INIT_RL(ff_rl_table[4], 962);
310  /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been
311  * initialized in ff_h263_decode_init() earlier. So just copy the VLCs. */
314 
316  &ff_v2_dc_lum_table[0][1], 8, 4,
317  &ff_v2_dc_lum_table[0][0], 8, 4, 0);
319  &ff_v2_dc_chroma_table[0][1], 8, 4,
320  &ff_v2_dc_chroma_table[0][0], 8, 4, 0);
321 
323  &ff_v2_intra_cbpc[0][1], 2, 1,
324  &ff_v2_intra_cbpc[0][0], 2, 1, 0);
326  &ff_v2_mb_type[0][1], 2, 1,
327  &ff_v2_mb_type[0][0], 2, 1, 0);
328 
329  mv = &ff_mv_tables[0];
332  mv->table_mv_bits, 1, 1,
333  mv->table_mv_code, 2, 2,
334  NULL, 0, 0, 0);
335  mv = &ff_mv_tables[1];
338  mv->table_mv_bits, 1, 1,
339  mv->table_mv_code, 2, 2,
340  NULL, 0, 0, 0);
341 
342  for (unsigned i = 0; i < 4; i++) {
345  &ff_wmv2_inter_table[i][0][1], 8, 4,
346  &ff_wmv2_inter_table[i][0][0], 8, 4,
347  NULL, 0, 0, 0);
348  }
349 
351  &ff_table_inter_intra[0][1], 2, 1,
352  &ff_table_inter_intra[0][0], 2, 1, 0);
354 }
355 
357 {
358  static AVOnce init_static_once = AV_ONCE_INIT;
359  MpegEncContext *s = avctx->priv_data;
360  int ret;
361 
362  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
363  return ret;
364 
365  if (ff_h263_decode_init(avctx) < 0)
366  return -1;
367 
369 
370  switch (s->msmpeg4_version) {
371  case MSMP4_V1:
372  case MSMP4_V2:
373  s->decode_mb= msmpeg4v12_decode_mb;
374  break;
375  case MSMP4_V3:
376  case MSMP4_WMV1:
377  s->decode_mb= msmpeg4v34_decode_mb;
378  break;
379  case MSMP4_WMV2:
380  break;
381  }
382 
383  s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
384 
385  ff_thread_once(&init_static_once, msmpeg4_decode_init_static);
386 
387  return 0;
388 }
389 
391 {
392  int code;
393 
394  // at minimum one bit per macroblock is required at least in a valid frame,
395  // we discard frames much smaller than this. Frames smaller than 1/8 of the
396  // smallest "black/skip" frame generally contain not much recoverable content
397  // while at the same time they have the highest computational requirements
398  // per byte
399  if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16))
400  return AVERROR_INVALIDDATA;
401 
402  if (s->msmpeg4_version == MSMP4_V1) {
403  int start_code = get_bits_long(&s->gb, 32);
404  if(start_code!=0x00000100){
405  av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
406  return -1;
407  }
408 
409  skip_bits(&s->gb, 5); // frame number */
410  }
411 
412  s->pict_type = get_bits(&s->gb, 2) + 1;
413  if (s->pict_type != AV_PICTURE_TYPE_I &&
414  s->pict_type != AV_PICTURE_TYPE_P){
415  av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
416  return -1;
417  }
418  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
419  if(s->qscale==0){
420  av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
421  return -1;
422  }
423 
424  if (s->pict_type == AV_PICTURE_TYPE_I) {
425  code = get_bits(&s->gb, 5);
426  if (s->msmpeg4_version == MSMP4_V1) {
427  if(code==0 || code>s->mb_height){
428  av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
429  return -1;
430  }
431 
432  s->slice_height = code;
433  }else{
434  /* 0x17: one slice, 0x18: two slices, ... */
435  if (code < 0x17){
436  av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
437  return -1;
438  }
439 
440  s->slice_height = s->mb_height / (code - 0x16);
441  }
442 
443  switch(s->msmpeg4_version){
444  case MSMP4_V1:
445  case MSMP4_V2:
446  s->rl_chroma_table_index = 2;
447  s->rl_table_index = 2;
448 
449  s->dc_table_index = 0; //not used
450  break;
451  case MSMP4_V3:
452  s->rl_chroma_table_index = decode012(&s->gb);
453  s->rl_table_index = decode012(&s->gb);
454 
455  s->dc_table_index = get_bits1(&s->gb);
456  break;
457  case MSMP4_WMV1:
458  ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
459 
460  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
461  else s->per_mb_rl_table= 0;
462 
463  if(!s->per_mb_rl_table){
464  s->rl_chroma_table_index = decode012(&s->gb);
465  s->rl_table_index = decode012(&s->gb);
466  }
467 
468  s->dc_table_index = get_bits1(&s->gb);
469  s->inter_intra_pred= 0;
470  break;
471  }
472  s->no_rounding = 1;
473  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
474  av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",
475  s->qscale,
476  s->rl_chroma_table_index,
477  s->rl_table_index,
478  s->dc_table_index,
479  s->per_mb_rl_table,
480  s->slice_height);
481  } else {
482  switch(s->msmpeg4_version){
483  case MSMP4_V1:
484  case MSMP4_V2:
485  if (s->msmpeg4_version == MSMP4_V1)
486  s->use_skip_mb_code = 1;
487  else
488  s->use_skip_mb_code = get_bits1(&s->gb);
489  s->rl_table_index = 2;
490  s->rl_chroma_table_index = s->rl_table_index;
491  s->dc_table_index = 0; //not used
492  s->mv_table_index = 0;
493  break;
494  case MSMP4_V3:
495  s->use_skip_mb_code = get_bits1(&s->gb);
496  s->rl_table_index = decode012(&s->gb);
497  s->rl_chroma_table_index = s->rl_table_index;
498 
499  s->dc_table_index = get_bits1(&s->gb);
500 
501  s->mv_table_index = get_bits1(&s->gb);
502  break;
503  case MSMP4_WMV1:
504  s->use_skip_mb_code = get_bits1(&s->gb);
505 
506  if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
507  else s->per_mb_rl_table= 0;
508 
509  if(!s->per_mb_rl_table){
510  s->rl_table_index = decode012(&s->gb);
511  s->rl_chroma_table_index = s->rl_table_index;
512  }
513 
514  s->dc_table_index = get_bits1(&s->gb);
515 
516  s->mv_table_index = get_bits1(&s->gb);
517  s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
518  break;
519  }
520 
521  if(s->avctx->debug&FF_DEBUG_PICT_INFO)
522  av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",
523  s->use_skip_mb_code,
524  s->rl_table_index,
525  s->rl_chroma_table_index,
526  s->dc_table_index,
527  s->mv_table_index,
528  s->per_mb_rl_table,
529  s->qscale);
530 
531  if(s->flipflop_rounding){
532  s->no_rounding ^= 1;
533  }else{
534  s->no_rounding = 0;
535  }
536  }
537  ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
538  s->inter_intra_pred, s->width, s->height);
539 
540  s->esc3_level_length= 0;
541  s->esc3_run_length= 0;
542 
543  return 0;
544 }
545 
547 {
548  int left= buf_size*8 - get_bits_count(&s->gb);
549  int length = s->msmpeg4_version >= MSMP4_V3 ? 17 : 16;
550  /* the alt_bitstream reader could read over the end so we need to check it */
551  if(left>=length && left<length+8)
552  {
553  skip_bits(&s->gb, 5); /* fps */
554  s->bit_rate= get_bits(&s->gb, 11)*1024;
555  if (s->msmpeg4_version >= MSMP4_V3)
556  s->flipflop_rounding= get_bits1(&s->gb);
557  else
558  s->flipflop_rounding= 0;
559  }
560  else if(left<length+8)
561  {
562  s->flipflop_rounding= 0;
563  if (s->msmpeg4_version != MSMP4_V2)
564  av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
565  }
566  else
567  {
568  av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n");
569  }
570 
571  return 0;
572 }
573 
574 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
575 {
576  int level, pred;
577 
578  if (s->msmpeg4_version <= MSMP4_V2) {
579  if (n < 4) {
581  } else {
583  }
584  if (level < 0) {
585  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
586  *dir_ptr = 0;
587  return -1;
588  }
589  level-=256;
590  } else {
591  level = get_vlc2(&s->gb, ff_msmp4_dc_vlc[s->dc_table_index][n >= 4],
592  MSMP4_DC_VLC_BITS, 3);
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 == MSMP4_V1) {
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 dc_pred_dir = -1; //unused but its passed around, so it needs to be initialized
632  const RLTable *rl;
633  const RL_VLC_ELEM *rl_vlc;
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 >= MSMP4_WMV1;
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 == MSMP4_V2)
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 == MSMP4_V1 || (cache&0x80000000)==0) {
705  if (s->msmpeg4_version == MSMP4_V1 || (cache&0x40000000)==0) {
706  /* third escape */
707  if (s->msmpeg4_version != MSMP4_V1)
708  LAST_SKIP_BITS(re, &s->gb, 2);
709  UPDATE_CACHE(re, &s->gb);
710  if (s->msmpeg4_version <= MSMP4_V3) {
711  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
712  run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
713  level= SHOW_SBITS(re, &s->gb, 8);
714  SKIP_COUNTER(re, &s->gb, 1+6+8);
715  }else{
716  int sign;
717  last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
718  if(!s->esc3_level_length){
719  int ll;
720  ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
721  show_bits(&s->gb, 24), s->mb_x, s->mb_y);
722  if(s->qscale<8){
723  ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
724  if(ll==0){
725  ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
726  }
727  }else{
728  ll=2;
729  while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
730  ll++;
731  SKIP_BITS(re, &s->gb, 1);
732  }
733  if(ll<8) SKIP_BITS(re, &s->gb, 1);
734  }
735 
736  s->esc3_level_length= ll;
737  s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
738  UPDATE_CACHE(re, &s->gb);
739  }
740  run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);
741  SKIP_BITS(re, &s->gb, s->esc3_run_length);
742 
743  sign= SHOW_UBITS(re, &s->gb, 1);
744  SKIP_BITS(re, &s->gb, 1);
745 
746  level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
747  SKIP_BITS(re, &s->gb, s->esc3_level_length);
748  if(sign) level= -level;
749  }
750 
751  //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
752  if (level>0) level= level * qmul + qadd;
753  else level= level * qmul - qadd;
754  i+= run + 1;
755  if(last) i+=192;
756  } else {
757  /* second escape */
758  SKIP_BITS(re, &s->gb, 2);
759  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
760  i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
761  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
762  LAST_SKIP_BITS(re, &s->gb, 1);
763  }
764  } else {
765  /* first escape */
766  SKIP_BITS(re, &s->gb, 1);
767  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
768  i+= run;
769  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
770  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
771  LAST_SKIP_BITS(re, &s->gb, 1);
772  }
773  } else {
774  i+= run;
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  if (i > 62){
779  i-= 192;
780  if(i&(~63)){
781  const int left= get_bits_left(&s->gb);
782  if (((i + 192 == 64 && level / qmul == -1) ||
783  !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
784  left >= 0) {
785  av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
786  i = 63;
787  break;
788  }else{
789  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
790  return -1;
791  }
792  }
793 
794  block[scan_table[i]] = level;
795  break;
796  }
797 
798  block[scan_table[i]] = level;
799  }
800  CLOSE_READER(re, &s->gb);
801  }
802  not_coded:
803  if (s->mb_intra) {
804  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
805  if (s->ac_pred) {
806  i = 63; /* XXX: not optimal */
807  }
808  }
809  if (s->msmpeg4_version >= MSMP4_WMV1 && i > 0) i=63; //FIXME/XXX optimize
810  s->block_last_index[n] = i;
811 
812  return 0;
813 }
814 
815 void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
816 {
817  const MVTable *mv;
818  int code, mx, my;
819 
820  mv = &ff_mv_tables[s->mv_table_index];
821 
822  code = get_vlc2(&s->gb, mv->vlc, MV_VLC_BITS, 2);
824  mx = get_bits(&s->gb, 6);
825  my = get_bits(&s->gb, 6);
826  } else {
827  mx = mv->table_mvx[code];
828  my = mv->table_mvy[code];
829  }
830 
831  mx += *mx_ptr - 32;
832  my += *my_ptr - 32;
833  /* WARNING : they do not do exactly modulo encoding */
834  if (mx <= -64)
835  mx += 64;
836  else if (mx >= 64)
837  mx -= 64;
838 
839  if (my <= -64)
840  my += 64;
841  else if (my >= 64)
842  my -= 64;
843  *mx_ptr = mx;
844  *my_ptr = my;
845 }
846 
848  .p.name = "msmpeg4v1",
849  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 1"),
850  .p.type = AVMEDIA_TYPE_VIDEO,
851  .p.id = AV_CODEC_ID_MSMPEG4V1,
852  .priv_data_size = sizeof(MpegEncContext),
855  .close = ff_mpv_decode_close,
857  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
859  .p.max_lowres = 3,
860 };
861 
863  .p.name = "msmpeg4v2",
864  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 2"),
865  .p.type = AVMEDIA_TYPE_VIDEO,
866  .p.id = AV_CODEC_ID_MSMPEG4V2,
867  .priv_data_size = sizeof(MpegEncContext),
870  .close = ff_mpv_decode_close,
872  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
874  .p.max_lowres = 3,
875 };
876 
878  .p.name = "msmpeg4",
879  CODEC_LONG_NAME("MPEG-4 part 2 Microsoft variant version 3"),
880  .p.type = AVMEDIA_TYPE_VIDEO,
881  .p.id = AV_CODEC_ID_MSMPEG4V3,
882  .priv_data_size = sizeof(MpegEncContext),
885  .close = ff_mpv_decode_close,
887  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
889  .p.max_lowres = 3,
890 };
891 
893  .p.name = "wmv1",
894  CODEC_LONG_NAME("Windows Media Video 7"),
895  .p.type = AVMEDIA_TYPE_VIDEO,
896  .p.id = AV_CODEC_ID_WMV1,
897  .priv_data_size = sizeof(MpegEncContext),
900  .close = ff_mpv_decode_close,
902  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
904  .p.max_lowres = 3,
905 };
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:265
h263data.h
ff_h263_cbpy_vlc
VLCElem ff_h263_cbpy_vlc[]
Definition: ituh263dec.c:104
level
uint8_t level
Definition: svq3.c:205
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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:49
mpeg4videodec.h
msmpeg4v2_decode_motion
static int msmpeg4v2_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: msmpeg4dec.c:75
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
msmpeg4_decode_init_static
static av_cold void msmpeg4_decode_init_static(void)
Definition: msmpeg4dec.c:299
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
MBAC_BITRATE
#define MBAC_BITRATE
Definition: msmpeg4.h:30
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:221
ff_msmpeg4_common_init
av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
Definition: msmpeg4.c:117
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:42
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:546
FFCodec
Definition: codec_internal.h:127
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
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:1407
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:263
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:53
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:228
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:179
ff_mpeg4_pred_ac
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:315
RLTable
RLTable.
Definition: rl.h:39
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:815
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:44
V2_INTRA_CBPC_VLC_BITS
#define V2_INTRA_CBPC_VLC_BITS
Definition: msmpeg4dec.c:42
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:93
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
ff_msmp4_vc1_vlcs_init_once
av_cold void ff_msmp4_vc1_vlcs_init_once(void)
Definition: msmpeg4_vc1_data.c:56
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
ff_msmpeg4_decode_picture_header
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:390
msmpeg4data.h
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:188
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
RLTable::max_level
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mb_non_intra_vlc
const VLCElem * ff_mb_non_intra_vlc[4]
Definition: msmpeg4dec.c:67
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:260
ff_msmpeg4v1_decoder
const FFCodec ff_msmpeg4v1_decoder
Definition: msmpeg4dec.c:847
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
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:241
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:53
rl_vlc
static const VLCElem * rl_vlc[2]
Definition: mobiclip.c:278
DEFAULT_INTER_INDEX
#define DEFAULT_INTER_INDEX
Definition: msmpeg4dec.c:47
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:204
ff_v2_mb_type
const uint8_t ff_v2_mb_type[8][2]
Definition: msmpeg4data.c:1624
state
static struct @466 state
ff_h263_mv_vlc
VLCElem ff_h263_mv_vlc[]
Definition: ituh263dec.c:105
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:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
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:426
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:247
ff_h263_intra_MCBPC_vlc
VLCElem ff_h263_intra_MCBPC_vlc[]
Definition: ituh263dec.c:102
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:652
V2_MB_TYPE_VLC_BITS
#define V2_MB_TYPE_VLC_BITS
Definition: msmpeg4dec.c:43
AVOnce
#define AVOnce
Definition: thread.h:202
v2_intra_cbpc_vlc
static VLCElem v2_intra_cbpc_vlc[8]
Definition: msmpeg4dec.c:70
ff_inter_intra_vlc
VLCElem ff_inter_intra_vlc[8]
Definition: msmpeg4dec.c:72
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ff_msmp4_mb_i_vlc
VLCElem ff_msmp4_mb_i_vlc[536]
Definition: msmpeg4_vc1_data.c:35
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:56
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:261
MSMP4_DC_VLC_BITS
#define MSMP4_DC_VLC_BITS
Definition: msmpeg4_vc1_data.h:38
VLCElem
Definition: vlc.h:32
msmpeg4v12_decode_mb
static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:106
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263dec.h:38
msmpeg4v34_decode_mb
static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: msmpeg4dec.c:208
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:55
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
II_BITRATE
#define II_BITRATE
Definition: msmpeg4.h:29
v2_mb_type_vlc
static VLCElem v2_mb_type_vlc[128]
Definition: msmpeg4dec.c:71
ff_msmpeg4v3_decoder
const FFCodec ff_msmpeg4v3_decoder
Definition: msmpeg4dec.c:877
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
ff_msmpeg4_pred_dc
int ff_msmpeg4_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr, int *dir_ptr)
Definition: msmpeg4.c:196
ff_v2_intra_cbpc
const uint8_t ff_v2_intra_cbpc[4][2]
Definition: msmpeg4data.c:1629
msmpeg4dec.h
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:233
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:371
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
decode012
static int BS_FUNC() decode012(BSCTX *bc)
Return decoded truncated unary code for the values 0, 1, 2.
Definition: bitstream_template.h:436
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:36
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_h263_decode_init
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:90
AVCodecContext::height
int height
Definition: avcodec.h:624
v2_dc_lum_vlc
static VLCElem v2_dc_lum_vlc[1472]
Definition: msmpeg4dec.c:68
avcodec.h
msmpeg4.h
ff_wmv1_decoder
const FFCodec ff_wmv1_decoder
Definition: msmpeg4dec.c:892
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:606
v2_dc_chroma_vlc
static VLCElem v2_dc_chroma_vlc[1506]
Definition: msmpeg4dec.c:69
ret
ret
Definition: filter_design.txt:187
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:451
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:259
ff_table_inter_intra
const uint8_t ff_table_inter_intra[4][2]
Definition: msmpeg4data.c:1648
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:270
MVTable
Definition: msmpeg4data.h:41
ff_vlc_init_tables_sparse
const av_cold VLCElem * ff_vlc_init_tables_sparse(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: vlc.c:400
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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:574
ff_h263_inter_MCBPC_vlc
VLCElem ff_h263_inter_MCBPC_vlc[]
Definition: ituh263dec.c:103
ff_msmp4_dc_vlc
const VLCElem * ff_msmp4_dc_vlc[2][2]
Definition: msmpeg4_vc1_data.c:36
VLC_INIT_RL
#define VLC_INIT_RL(rl, static_size)
Definition: rl.h:83
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:261
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
ff_msmpeg4v2_decoder
const FFCodec ff_msmpeg4v2_decoder
Definition: msmpeg4dec.c:862
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:35
ff_msmpeg4_decode_init
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
Definition: msmpeg4dec.c:356
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:50
ff_msmpeg4_coded_block_pred
int ff_msmpeg4_coded_block_pred(MpegEncContext *s, int n, uint8_t **coded_block_ptr)
Definition: msmpeg4.c:156
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
ff_mpv_decode_close
int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:163
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: msmpeg4dec.c:45
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:65
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263dec.h:37
h263.h