FFmpeg: libavcodec/ituh263dec.c Source File

FFmpeg
ituh263dec.c
Go to the documentation of this file.
1 /*
2  * ITU H.263 bitstream decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * H.263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P
6  * Copyright (c) 2002-2004 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 /**
26  * @file
27  * H.263 decoder.
28  */
29 
30  #define UNCHECKED_BITSTREAM_READER 1
31 
32 #include "config_components.h"
33 
34 #include "libavutil/attributes.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/mem_internal.h"
39 #include "libavutil/thread.h"
40 #include "avcodec.h"
41 #include "mpegvideo.h"
42 #include "h263.h"
43 #include "h263data.h"
44 #include "h263dec.h"
45 #include "mathops.h"
46 #include "mpegutils.h"
47 #include "unary.h"
48 #include "rv10dec.h"
49 #include "mpeg4video.h"
50 #include "mpegvideodata.h"
51 #include "mpegvideodec.h"
52 #include "mpeg4videodec.h"
53 
54 // The defines below define the number of bits that are read at once for
55 // reading vlc values. Changing these may improve speed and data cache needs
56 // be aware though that decreasing them may need the number of stages that is
57 // passed to get_vlc* to be increased.
58  #define H263_MBTYPE_B_VLC_BITS 6
59  #define CBPC_B_VLC_BITS 3
60 
61  static const int h263_mb_type_b_map[15]= {
62  MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
63  MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP,
64  MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT,
65  MB_TYPE_L0 | MB_TYPE_16x16,
66  MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_16x16,
67  MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
68  MB_TYPE_L1 | MB_TYPE_16x16,
69  MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_16x16,
70  MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
71  MB_TYPE_L0L1 | MB_TYPE_16x16,
72  MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_16x16,
73  MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,
74  0, //stuffing
75  MB_TYPE_INTRA4x4 | MB_TYPE_CBP,
76  MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT,
77 };
78 
79  void ff_h263_show_pict_info(MpegEncContext *s){
80  if(s->avctx->debug&FF_DEBUG_PICT_INFO){
81  av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
82  s->qscale, av_get_picture_type_char(s->pict_type),
83  s->gb.size_in_bits, 1-s->no_rounding,
84  s->obmc ? " AP" : "",
85  s->umvplus ? " UMV" : "",
86  s->h263_long_vectors ? " LONG" : "",
87  s->h263_plus ? " +" : "",
88  s->h263_aic ? " AIC" : "",
89  s->alt_inter_vlc ? " AIV" : "",
90  s->modified_quant ? " MQ" : "",
91  s->loop_filter ? " LOOP" : "",
92  s->h263_slice_structured ? " SS" : "",
93  s->avctx->framerate.num, s->avctx->framerate.den
94  );
95  }
96 }
97 
98 /***********************************************/
99 /* decoding */
100 
101  VLC ff_h263_intra_MCBPC_vlc;
102  VLC ff_h263_inter_MCBPC_vlc;
103  VLC ff_h263_cbpy_vlc;
104  VLC ff_h263_mv_vlc;
105  static VLC h263_mbtype_b_vlc;
106  static VLC cbpc_b_vlc;
107 
108 /* init vlcs */
109 
110  static av_cold void h263_decode_init_vlc(void)
111 {
112  INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
113  ff_h263_intra_MCBPC_bits, 1, 1,
114  ff_h263_intra_MCBPC_code, 1, 1, 72);
115  INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
116  ff_h263_inter_MCBPC_bits, 1, 1,
117  ff_h263_inter_MCBPC_code, 1, 1, 198);
118  INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,
119  &ff_h263_cbpy_tab[0][1], 2, 1,
120  &ff_h263_cbpy_tab[0][0], 2, 1, 64);
121  INIT_VLC_STATIC(&ff_h263_mv_vlc, H263_MV_VLC_BITS, 33,
122  &ff_mvtab[0][1], 2, 1,
123  &ff_mvtab[0][0], 2, 1, 538);
124  ff_h263_init_rl_inter();
125  INIT_VLC_RL(ff_h263_rl_inter, 554);
126  INIT_FIRST_VLC_RL(ff_rl_intra_aic, 554);
127  INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
128  &ff_h263_mbtype_b_tab[0][1], 2, 1,
129  &ff_h263_mbtype_b_tab[0][0], 2, 1, 80);
130  INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
131  &ff_cbpc_b_tab[0][1], 2, 1,
132  &ff_cbpc_b_tab[0][0], 2, 1, 8);
133 }
134 
135  av_cold void ff_h263_decode_init_vlc(void)
136 {
137  static AVOnce init_static_once = AV_ONCE_INIT;
138  ff_thread_once(&init_static_once, h263_decode_init_vlc);
139 }
140 
141  int ff_h263_decode_mba(MpegEncContext *s)
142 {
143  int i, mb_pos;
144 
145  for (i = 0; i < 6; i++)
146  if (s->mb_num - 1 <= ff_mba_max[i])
147  break;
148  mb_pos = get_bits(&s->gb, ff_mba_length[i]);
149  s->mb_x = mb_pos % s->mb_width;
150  s->mb_y = mb_pos / s->mb_width;
151 
152  return mb_pos;
153 }
154 
155 /**
156  * Decode the group of blocks header or slice header.
157  * @return <0 if an error occurred
158  */
159  static int h263_decode_gob_header(MpegEncContext *s)
160 {
161  unsigned int val, gob_number;
162  int left;
163 
164  /* Check for GOB Start Code */
165  val = show_bits(&s->gb, 16);
166  if(val)
167  return -1;
168 
169  /* We have a GBSC probably with GSTUFF */
170  skip_bits(&s->gb, 16); /* Drop the zeros */
171  left= get_bits_left(&s->gb);
172  left = FFMIN(left, 32);
173  //MN: we must check the bits left or we might end in an infinite loop (or segfault)
174  for(;left>13; left--){
175  if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
176  }
177  if(left<=13)
178  return -1;
179 
180  if(s->h263_slice_structured){
181  if(check_marker(s->avctx, &s->gb, "before MBA")==0)
182  return -1;
183 
184  ff_h263_decode_mba(s);
185 
186  if(s->mb_num > 1583)
187  if(check_marker(s->avctx, &s->gb, "after MBA")==0)
188  return -1;
189 
190  s->qscale = get_bits(&s->gb, 5); /* SQUANT */
191  if(check_marker(s->avctx, &s->gb, "after SQUANT")==0)
192  return -1;
193  skip_bits(&s->gb, 2); /* GFID */
194  }else{
195  gob_number = get_bits(&s->gb, 5); /* GN */
196  s->mb_x= 0;
197  s->mb_y= s->gob_index* gob_number;
198  skip_bits(&s->gb, 2); /* GFID */
199  s->qscale = get_bits(&s->gb, 5); /* GQUANT */
200  }
201 
202  if(s->mb_y >= s->mb_height)
203  return -1;
204 
205  if(s->qscale==0)
206  return -1;
207 
208  return 0;
209 }
210 
211 /**
212  * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
213  * @return bit position of the resync_marker, or <0 if none was found
214  */
215  int ff_h263_resync(MpegEncContext *s){
216  int left, pos, ret;
217 
218  /* In MPEG-4 studio mode look for a new slice startcode
219  * and decode slice header */
220  if(s->codec_id==AV_CODEC_ID_MPEG4 && s->studio_profile) {
221  align_get_bits(&s->gb);
222 
223  while (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) != SLICE_STARTCODE) {
224  get_bits(&s->gb, 8);
225  }
226 
227  if (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) == SLICE_STARTCODE)
228  return get_bits_count(&s->gb);
229  else
230  return -1;
231  }
232 
233  if(s->codec_id==AV_CODEC_ID_MPEG4){
234  skip_bits1(&s->gb);
235  align_get_bits(&s->gb);
236  }
237 
238  if(show_bits(&s->gb, 16)==0){
239  pos= get_bits_count(&s->gb);
240  if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
241  ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
242  else
243  ret= h263_decode_gob_header(s);
244  if(ret>=0)
245  return pos;
246  }
247  //OK, it's not where it is supposed to be ...
248  s->gb= s->last_resync_gb;
249  align_get_bits(&s->gb);
250  left= get_bits_left(&s->gb);
251 
252  for(;left>16+1+5+5; left-=8){
253  if(show_bits(&s->gb, 16)==0){
254  GetBitContext bak= s->gb;
255 
256  pos= get_bits_count(&s->gb);
257  if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
258  ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
259  else
260  ret= h263_decode_gob_header(s);
261  if(ret>=0)
262  return pos;
263 
264  s->gb= bak;
265  }
266  skip_bits(&s->gb, 8);
267  }
268 
269  return -1;
270 }
271 
272  int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)
273 {
274  int code, val, sign, shift;
275  code = get_vlc2(&s->gb, ff_h263_mv_vlc.table, H263_MV_VLC_BITS, 2);
276 
277  if (code == 0)
278  return pred;
279  if (code < 0)
280  return 0xffff;
281 
282  sign = get_bits1(&s->gb);
283  shift = f_code - 1;
284  val = code;
285  if (shift) {
286  val = (val - 1) << shift;
287  val |= get_bits(&s->gb, shift);
288  val++;
289  }
290  if (sign)
291  val = -val;
292  val += pred;
293 
294  /* modulo decoding */
295  if (!s->h263_long_vectors) {
296  val = sign_extend(val, 5 + f_code);
297  } else {
298  /* horrible H.263 long vector mode */
299  if (pred < -31 && val < -63)
300  val += 64;
301  if (pred > 32 && val > 63)
302  val -= 64;
303 
304  }
305  return val;
306 }
307 
308 
309 /* Decode RVLC of H.263+ UMV */
310  static int h263p_decode_umotion(MpegEncContext * s, int pred)
311 {
312  int code = 0, sign;
313 
314  if (get_bits1(&s->gb)) /* Motion difference = 0 */
315  return pred;
316 
317  code = 2 + get_bits1(&s->gb);
318 
319  while (get_bits1(&s->gb))
320  {
321  code <<= 1;
322  code += get_bits1(&s->gb);
323  if (code >= 32768) {
324  avpriv_request_sample(s->avctx, "Huge DMV");
325  return 0xffff;
326  }
327  }
328  sign = code & 1;
329  code >>= 1;
330 
331  code = (sign) ? (pred - code) : (pred + code);
332  ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
333  return code;
334 
335 }
336 
337 /**
338  * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :)
339  */
340  static void preview_obmc(MpegEncContext *s){
341  GetBitContext gb= s->gb;
342 
343  int cbpc, i, pred_x, pred_y, mx, my;
344  int16_t *mot_val;
345  const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
346  const int stride= s->b8_stride*2;
347 
348  for(i=0; i<4; i++)
349  s->block_index[i]+= 2;
350  for(i=4; i<6; i++)
351  s->block_index[i]+= 1;
352  s->mb_x++;
353 
354  av_assert2(s->pict_type == AV_PICTURE_TYPE_P);
355 
356  do{
357  if (get_bits1(&s->gb)) {
358  /* skip mb */
359  mot_val = s->current_picture.motion_val[0][s->block_index[0]];
360  mot_val[0 ]= mot_val[2 ]=
361  mot_val[0+stride]= mot_val[2+stride]= 0;
362  mot_val[1 ]= mot_val[3 ]=
363  mot_val[1+stride]= mot_val[3+stride]= 0;
364 
365  s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
366  goto end;
367  }
368  cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
369  }while(cbpc == 20);
370 
371  if(cbpc & 4){
372  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
373  }else{
374  get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
375  if (cbpc & 8) {
376  if(s->modified_quant){
377  if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
378  else skip_bits(&s->gb, 5);
379  }else
380  skip_bits(&s->gb, 2);
381  }
382 
383  if ((cbpc & 16) == 0) {
384  s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
385  /* 16x16 motion prediction */
386  mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
387  if (s->umvplus)
388  mx = h263p_decode_umotion(s, pred_x);
389  else
390  mx = ff_h263_decode_motion(s, pred_x, 1);
391 
392  if (s->umvplus)
393  my = h263p_decode_umotion(s, pred_y);
394  else
395  my = ff_h263_decode_motion(s, pred_y, 1);
396 
397  mot_val[0 ]= mot_val[2 ]=
398  mot_val[0+stride]= mot_val[2+stride]= mx;
399  mot_val[1 ]= mot_val[3 ]=
400  mot_val[1+stride]= mot_val[3+stride]= my;
401  } else {
402  s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
403  for(i=0;i<4;i++) {
404  mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
405  if (s->umvplus)
406  mx = h263p_decode_umotion(s, pred_x);
407  else
408  mx = ff_h263_decode_motion(s, pred_x, 1);
409 
410  if (s->umvplus)
411  my = h263p_decode_umotion(s, pred_y);
412  else
413  my = ff_h263_decode_motion(s, pred_y, 1);
414  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
415  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
416  mot_val[0] = mx;
417  mot_val[1] = my;
418  }
419  }
420  }
421 end:
422 
423  for(i=0; i<4; i++)
424  s->block_index[i]-= 2;
425  for(i=4; i<6; i++)
426  s->block_index[i]-= 1;
427  s->mb_x--;
428 
429  s->gb= gb;
430 }
431 
432  static void h263_decode_dquant(MpegEncContext *s){
433  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
434 
435  if(s->modified_quant){
436  if(get_bits1(&s->gb))
437  s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
438  else
439  s->qscale= get_bits(&s->gb, 5);
440  }else
441  s->qscale += quant_tab[get_bits(&s->gb, 2)];
442  ff_set_qscale(s, s->qscale);
443 }
444 
445  static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)
446 {
447  int x, y, wrap, a, c, pred_dc, scale;
448  int16_t *dc_val, *ac_val, *ac_val1;
449 
450  /* find prediction */
451  if (n < 4) {
452  x = 2 * s->mb_x + (n & 1);
453  y = 2 * s->mb_y + (n>> 1);
454  wrap = s->b8_stride;
455  dc_val = s->dc_val[0];
456  ac_val = s->ac_val[0][0];
457  scale = s->y_dc_scale;
458  } else {
459  x = s->mb_x;
460  y = s->mb_y;
461  wrap = s->mb_stride;
462  dc_val = s->dc_val[n - 4 + 1];
463  ac_val = s->ac_val[n - 4 + 1][0];
464  scale = s->c_dc_scale;
465  }
466 
467  ac_val += ((y) * wrap + (x)) * 16;
468  ac_val1 = ac_val;
469 
470  /* B C
471  * A X
472  */
473  a = dc_val[(x - 1) + (y) * wrap];
474  c = dc_val[(x) + (y - 1) * wrap];
475 
476  /* No prediction outside GOB boundary */
477  if (s->first_slice_line && n != 3) {
478  if (n != 2) c= 1024;
479  if (n != 1 && s->mb_x == s->resync_mb_x) a= 1024;
480  }
481 
482  if (s->ac_pred) {
483  pred_dc = 1024;
484  if (s->h263_aic_dir) {
485  /* left prediction */
486  if (a != 1024) {
487  ac_val -= 16;
488  for (int i = 1; i < 8; i++) {
489  block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
490  }
491  pred_dc = a;
492  }
493  } else {
494  /* top prediction */
495  if (c != 1024) {
496  ac_val -= 16 * wrap;
497  for (int i = 1; i < 8; i++) {
498  block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
499  }
500  pred_dc = c;
501  }
502  }
503  } else {
504  /* just DC prediction */
505  if (a != 1024 && c != 1024)
506  pred_dc = (a + c) >> 1;
507  else if (a != 1024)
508  pred_dc = a;
509  else
510  pred_dc = c;
511  }
512 
513  /* we assume pred is positive */
514  block[0] = block[0] * scale + pred_dc;
515 
516  if (block[0] < 0)
517  block[0] = 0;
518  else
519  block[0] |= 1;
520 
521  /* Update AC/DC tables */
522  dc_val[(x) + (y) * wrap] = block[0];
523 
524  /* left copy */
525  for (int i = 1; i < 8; i++)
526  ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
527  /* top copy */
528  for (int i = 1; i < 8; i++)
529  ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
530 }
531 
532  static int h263_decode_block(MpegEncContext * s, int16_t * block,
533  int n, int coded)
534 {
535  int level, i, j, run;
536  RLTable *rl = &ff_h263_rl_inter;
537  const uint8_t *scan_table;
538  GetBitContext gb= s->gb;
539 
540  scan_table = s->intra_scantable.permutated;
541  if (s->h263_aic && s->mb_intra) {
542  rl = &ff_rl_intra_aic;
543  i = 0;
544  if (s->ac_pred) {
545  if (s->h263_aic_dir)
546  scan_table = s->intra_v_scantable.permutated; /* left */
547  else
548  scan_table = s->intra_h_scantable.permutated; /* top */
549  }
550  } else if (s->mb_intra) {
551  /* DC coef */
552  if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) {
553  if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {
554  int component, diff;
555  component = (n <= 3 ? 0 : n - 4 + 1);
556  level = s->last_dc[component];
557  if (s->rv10_first_dc_coded[component]) {
558  diff = ff_rv_decode_dc(s, n);
559  if (diff < 0)
560  return -1;
561  level += diff;
562  level = level & 0xff; /* handle wrap round */
563  s->last_dc[component] = level;
564  } else {
565  s->rv10_first_dc_coded[component] = 1;
566  }
567  } else {
568  level = get_bits(&s->gb, 8);
569  if (level == 255)
570  level = 128;
571  }
572  }else{
573  level = get_bits(&s->gb, 8);
574  if((level&0x7F) == 0){
575  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
576  if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
577  return -1;
578  }
579  if (level == 255)
580  level = 128;
581  }
582  block[0] = level;
583  i = 1;
584  } else {
585  i = 0;
586  }
587  if (!coded) {
588  if (s->mb_intra && s->h263_aic)
589  goto not_coded;
590  s->block_last_index[n] = i - 1;
591  return 0;
592  }
593 retry:
594  {
595  OPEN_READER(re, &s->gb);
596  i--; // offset by -1 to allow direct indexing of scan_table
597  for(;;) {
598  UPDATE_CACHE(re, &s->gb);
599  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
600  if (run == 66) {
601  if (level){
602  CLOSE_READER(re, &s->gb);
603  av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
604  return -1;
605  }
606  /* escape */
607  if (CONFIG_FLV_DECODER && s->h263_flv > 1) {
608  int is11 = SHOW_UBITS(re, &s->gb, 1);
609  SKIP_CACHE(re, &s->gb, 1);
610  run = SHOW_UBITS(re, &s->gb, 7) + 1;
611  if (is11) {
612  SKIP_COUNTER(re, &s->gb, 1 + 7);
613  UPDATE_CACHE(re, &s->gb);
614  level = SHOW_SBITS(re, &s->gb, 11);
615  SKIP_COUNTER(re, &s->gb, 11);
616  } else {
617  SKIP_CACHE(re, &s->gb, 7);
618  level = SHOW_SBITS(re, &s->gb, 7);
619  SKIP_COUNTER(re, &s->gb, 1 + 7 + 7);
620  }
621  } else {
622  run = SHOW_UBITS(re, &s->gb, 7) + 1;
623  SKIP_CACHE(re, &s->gb, 7);
624  level = (int8_t)SHOW_UBITS(re, &s->gb, 8);
625  SKIP_COUNTER(re, &s->gb, 7 + 8);
626  if(level == -128){
627  UPDATE_CACHE(re, &s->gb);
628  if (s->codec_id == AV_CODEC_ID_RV10) {
629  /* XXX: should patch encoder too */
630  level = SHOW_SBITS(re, &s->gb, 12);
631  SKIP_COUNTER(re, &s->gb, 12);
632  }else{
633  level = SHOW_UBITS(re, &s->gb, 5);
634  SKIP_CACHE(re, &s->gb, 5);
635  level |= SHOW_SBITS(re, &s->gb, 6) * (1<<5);
636  SKIP_COUNTER(re, &s->gb, 5 + 6);
637  }
638  }
639  }
640  } else {
641  if (SHOW_UBITS(re, &s->gb, 1))
642  level = -level;
643  SKIP_COUNTER(re, &s->gb, 1);
644  }
645  i += run;
646  if (i >= 64){
647  CLOSE_READER(re, &s->gb);
648  // redo update without last flag, revert -1 offset
649  i = i - run + ((run-1)&63) + 1;
650  if (i < 64) {
651  // only last marker, no overrun
652  block[scan_table[i]] = level;
653  break;
654  }
655  if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){
656  //Looks like a hack but no, it's the way it is supposed to work ...
657  rl = &ff_rl_intra_aic;
658  i = 0;
659  s->gb= gb;
660  s->bdsp.clear_block(block);
661  goto retry;
662  }
663  av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
664  return -1;
665  }
666  j = scan_table[i];
667  block[j] = level;
668  }
669  }
670 not_coded:
671  if (s->mb_intra && s->h263_aic) {
672  h263_pred_acdc(s, block, n);
673  i = 63;
674  }
675  s->block_last_index[n] = i;
676  return 0;
677 }
678 
679  static int h263_skip_b_part(MpegEncContext *s, int cbp)
680 {
681  LOCAL_ALIGNED_32(int16_t, dblock, [64]);
682  int i, mbi;
683  int bli[6];
684 
685  /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
686  * but real value should be restored in order to be used later (in OBMC condition)
687  */
688  mbi = s->mb_intra;
689  memcpy(bli, s->block_last_index, sizeof(bli));
690  s->mb_intra = 0;
691  for (i = 0; i < 6; i++) {
692  if (h263_decode_block(s, dblock, i, cbp&32) < 0)
693  return -1;
694  cbp+=cbp;
695  }
696  s->mb_intra = mbi;
697  memcpy(s->block_last_index, bli, sizeof(bli));
698  return 0;
699 }
700 
701  static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
702 {
703  int c, mv = 1;
704 
705  if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame
706  c = get_bits1(gb);
707  if (pb_frame == 2 && c)
708  mv = !get_bits1(gb);
709  } else { // h.263 Annex M improved PB-frame
710  mv = get_unary(gb, 0, 4) + 1;
711  c = mv & 1;
712  mv = !!(mv & 2);
713  }
714  if(c)
715  *cbpb = get_bits(gb, 6);
716  return mv;
717 }
718 
719  #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
720  #define tab_bias (tab_size / 2)
721  static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
722 {
723  int xy = s->block_index[i];
724  uint16_t time_pp = s->pp_time;
725  uint16_t time_pb = s->pb_time;
726  int p_mx, p_my;
727 
728  p_mx = p->motion_val[0][xy][0];
729  if ((unsigned)(p_mx + tab_bias) < tab_size) {
730  s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias];
731  s->mv[1][i][0] = s->direct_scale_mv[1][p_mx + tab_bias];
732  } else {
733  s->mv[0][i][0] = p_mx * time_pb / time_pp;
734  s->mv[1][i][0] = p_mx * (time_pb - time_pp) / time_pp;
735  }
736  p_my = p->motion_val[0][xy][1];
737  if ((unsigned)(p_my + tab_bias) < tab_size) {
738  s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias];
739  s->mv[1][i][1] = s->direct_scale_mv[1][p_my + tab_bias];
740  } else {
741  s->mv[0][i][1] = p_my * time_pb / time_pp;
742  s->mv[1][i][1] = p_my * (time_pb - time_pp) / time_pp;
743  }
744 }
745 
746 /**
747  * @return the mb_type
748  */
749  static int set_direct_mv(MpegEncContext *s)
750 {
751  const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
752  Picture *p = &s->next_picture;
753  int colocated_mb_type = p->mb_type[mb_index];
754  int i;
755 
756  if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {
757  p = &s->last_picture;
758  colocated_mb_type = p->mb_type[mb_index];
759  }
760 
761  if (IS_8X8(colocated_mb_type)) {
762  s->mv_type = MV_TYPE_8X8;
763  for (i = 0; i < 4; i++)
764  set_one_direct_mv(s, p, i);
765  return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
766  } else {
767  set_one_direct_mv(s, p, 0);
768  s->mv[0][1][0] =
769  s->mv[0][2][0] =
770  s->mv[0][3][0] = s->mv[0][0][0];
771  s->mv[0][1][1] =
772  s->mv[0][2][1] =
773  s->mv[0][3][1] = s->mv[0][0][1];
774  s->mv[1][1][0] =
775  s->mv[1][2][0] =
776  s->mv[1][3][0] = s->mv[1][0][0];
777  s->mv[1][1][1] =
778  s->mv[1][2][1] =
779  s->mv[1][3][1] = s->mv[1][0][1];
780  s->mv_type = MV_TYPE_8X8;
781  // Note see prev line
782  return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;
783  }
784 }
785 
786  int ff_h263_decode_mb(MpegEncContext *s,
787  int16_t block[6][64])
788 {
789  int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
790  int16_t *mot_val;
791  const int xy= s->mb_x + s->mb_y * s->mb_stride;
792  int cbpb = 0, pb_mv_count = 0;
793 
794  av_assert2(!s->h263_pred);
795 
796  if (s->pict_type == AV_PICTURE_TYPE_P) {
797  do{
798  if (get_bits1(&s->gb)) {
799  /* skip mb */
800  s->mb_intra = 0;
801  for(i=0;i<6;i++)
802  s->block_last_index[i] = -1;
803  s->mv_dir = MV_DIR_FORWARD;
804  s->mv_type = MV_TYPE_16X16;
805  s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
806  s->mv[0][0][0] = 0;
807  s->mv[0][0][1] = 0;
808  s->mb_skipped = !(s->obmc | s->loop_filter);
809  goto end;
810  }
811  cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
812  if (cbpc < 0){
813  av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
814  return SLICE_ERROR;
815  }
816  }while(cbpc == 20);
817 
818  s->bdsp.clear_blocks(s->block[0]);
819 
820  dquant = cbpc & 8;
821  s->mb_intra = ((cbpc & 4) != 0);
822  if (s->mb_intra) goto intra;
823 
824  if(s->pb_frame && get_bits1(&s->gb))
825  pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
826  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
827 
828  if (cbpy < 0) {
829  av_log(s->avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
830  return SLICE_ERROR;
831  }
832 
833  if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
834  cbpy ^= 0xF;
835 
836  cbp = (cbpc & 3) | (cbpy << 2);
837  if (dquant) {
838  h263_decode_dquant(s);
839  }
840 
841  s->mv_dir = MV_DIR_FORWARD;
842  if ((cbpc & 16) == 0) {
843  s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
844  /* 16x16 motion prediction */
845  s->mv_type = MV_TYPE_16X16;
846  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
847  if (s->umvplus)
848  mx = h263p_decode_umotion(s, pred_x);
849  else
850  mx = ff_h263_decode_motion(s, pred_x, 1);
851 
852  if (mx >= 0xffff)
853  return SLICE_ERROR;
854 
855  if (s->umvplus)
856  my = h263p_decode_umotion(s, pred_y);
857  else
858  my = ff_h263_decode_motion(s, pred_y, 1);
859 
860  if (my >= 0xffff)
861  return SLICE_ERROR;
862  s->mv[0][0][0] = mx;
863  s->mv[0][0][1] = my;
864 
865  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
866  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
867  } else {
868  s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
869  s->mv_type = MV_TYPE_8X8;
870  for(i=0;i<4;i++) {
871  mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
872  if (s->umvplus)
873  mx = h263p_decode_umotion(s, pred_x);
874  else
875  mx = ff_h263_decode_motion(s, pred_x, 1);
876  if (mx >= 0xffff)
877  return SLICE_ERROR;
878 
879  if (s->umvplus)
880  my = h263p_decode_umotion(s, pred_y);
881  else
882  my = ff_h263_decode_motion(s, pred_y, 1);
883  if (my >= 0xffff)
884  return SLICE_ERROR;
885  s->mv[0][i][0] = mx;
886  s->mv[0][i][1] = my;
887  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
888  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
889  mot_val[0] = mx;
890  mot_val[1] = my;
891  }
892  }
893  } else if(s->pict_type==AV_PICTURE_TYPE_B) {
894  int mb_type;
895  const int stride= s->b8_stride;
896  int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)];
897  int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)];
898 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
899 
900  //FIXME ugly
901  mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
902  mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
903  mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
904  mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
905 
906  do{
907  mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
908  if (mb_type < 0){
909  av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
910  return SLICE_ERROR;
911  }
912 
913  mb_type= h263_mb_type_b_map[ mb_type ];
914  }while(!mb_type);
915 
916  s->mb_intra = IS_INTRA(mb_type);
917  if(HAS_CBP(mb_type)){
918  s->bdsp.clear_blocks(s->block[0]);
919  cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
920  if(s->mb_intra){
921  dquant = IS_QUANT(mb_type);
922  goto intra;
923  }
924 
925  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
926 
927  if (cbpy < 0){
928  av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
929  return SLICE_ERROR;
930  }
931 
932  if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
933  cbpy ^= 0xF;
934 
935  cbp = (cbpc & 3) | (cbpy << 2);
936  }else
937  cbp=0;
938 
939  av_assert2(!s->mb_intra);
940 
941  if(IS_QUANT(mb_type)){
942  h263_decode_dquant(s);
943  }
944 
945  if(IS_DIRECT(mb_type)){
946  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
947  mb_type |= set_direct_mv(s);
948  }else{
949  s->mv_dir = 0;
950  s->mv_type= MV_TYPE_16X16;
951 //FIXME UMV
952 
953  if(USES_LIST(mb_type, 0)){
954  int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
955  s->mv_dir = MV_DIR_FORWARD;
956 
957  if (s->umvplus)
958  mx = h263p_decode_umotion(s, pred_x);
959  else
960  mx = ff_h263_decode_motion(s, pred_x, 1);
961  if (mx >= 0xffff)
962  return SLICE_ERROR;
963 
964  if (s->umvplus)
965  my = h263p_decode_umotion(s, pred_y);
966  else
967  my = ff_h263_decode_motion(s, pred_y, 1);
968  if (my >= 0xffff)
969  return SLICE_ERROR;
970 
971  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
972  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
973 
974  s->mv[0][0][0] = mx;
975  s->mv[0][0][1] = my;
976  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
977  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
978  }
979 
980  if(USES_LIST(mb_type, 1)){
981  int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);
982  s->mv_dir |= MV_DIR_BACKWARD;
983 
984  if (s->umvplus)
985  mx = h263p_decode_umotion(s, pred_x);
986  else
987  mx = ff_h263_decode_motion(s, pred_x, 1);
988  if (mx >= 0xffff)
989  return SLICE_ERROR;
990 
991  if (s->umvplus)
992  my = h263p_decode_umotion(s, pred_y);
993  else
994  my = ff_h263_decode_motion(s, pred_y, 1);
995  if (my >= 0xffff)
996  return SLICE_ERROR;
997 
998  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
999  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1000 
1001  s->mv[1][0][0] = mx;
1002  s->mv[1][0][1] = my;
1003  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
1004  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1005  }
1006  }
1007 
1008  s->current_picture.mb_type[xy] = mb_type;
1009  } else { /* I-Frame */
1010  do{
1011  cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
1012  if (cbpc < 0){
1013  av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1014  return SLICE_ERROR;
1015  }
1016  }while(cbpc == 8);
1017 
1018  s->bdsp.clear_blocks(s->block[0]);
1019 
1020  dquant = cbpc & 4;
1021  s->mb_intra = 1;
1022 intra:
1023  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1024  if (s->h263_aic) {
1025  s->ac_pred = get_bits1(&s->gb);
1026  if(s->ac_pred){
1027  s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1028 
1029  s->h263_aic_dir = get_bits1(&s->gb);
1030  }
1031  }else
1032  s->ac_pred = 0;
1033 
1034  if(s->pb_frame && get_bits1(&s->gb))
1035  pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
1036  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1037  if(cbpy<0){
1038  av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1039  return SLICE_ERROR;
1040  }
1041  cbp = (cbpc & 3) | (cbpy << 2);
1042  if (dquant) {
1043  h263_decode_dquant(s);
1044  }
1045 
1046  pb_mv_count += !!s->pb_frame;
1047  }
1048 
1049  while(pb_mv_count--){
1050  ff_h263_decode_motion(s, 0, 1);
1051  ff_h263_decode_motion(s, 0, 1);
1052  }
1053 
1054  /* decode each block */
1055  for (i = 0; i < 6; i++) {
1056  if (h263_decode_block(s, block[i], i, cbp&32) < 0)
1057  return -1;
1058  cbp+=cbp;
1059  }
1060 
1061  if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
1062  return -1;
1063  if(s->obmc && !s->mb_intra){
1064  if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
1065  preview_obmc(s);
1066  }
1067 end:
1068 
1069  if (get_bits_left(&s->gb) < 0)
1070  return AVERROR_INVALIDDATA;
1071 
1072  /* per-MB end of slice check */
1073  {
1074  int v= show_bits(&s->gb, 16);
1075 
1076  if (get_bits_left(&s->gb) < 16) {
1077  v >>= 16 - get_bits_left(&s->gb);
1078  }
1079 
1080  if(v==0)
1081  return SLICE_END;
1082  }
1083 
1084  return SLICE_OK;
1085 }
1086 
1087 /* Most is hardcoded; should extend to handle all H.263 streams. */
1088  int ff_h263_decode_picture_header(MpegEncContext *s)
1089 {
1090  int format, width, height, i, ret;
1091  uint32_t startcode;
1092 
1093  align_get_bits(&s->gb);
1094 
1095  if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) {
1096  av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
1097  }
1098 
1099  startcode= get_bits(&s->gb, 22-8);
1100 
1101  for(i= get_bits_left(&s->gb); i>24; i-=8) {
1102  startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
1103 
1104  if(startcode == 0x20)
1105  break;
1106  }
1107 
1108  if (startcode != 0x20) {
1109  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
1110  return -1;
1111  }
1112  /* temporal reference */
1113  i = get_bits(&s->gb, 8); /* picture timestamp */
1114 
1115  i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;
1116 
1117  s->picture_number= (s->picture_number&~0xFF) + i;
1118 
1119  /* PTYPE starts here */
1120  if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) {
1121  return -1;
1122  }
1123  if (get_bits1(&s->gb) != 0) {
1124  av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n");
1125  return -1; /* H.263 id */
1126  }
1127  skip_bits1(&s->gb); /* split screen off */
1128  skip_bits1(&s->gb); /* camera off */
1129  skip_bits1(&s->gb); /* freeze picture release off */
1130 
1131  format = get_bits(&s->gb, 3);
1132  /*
1133  0 forbidden
1134  1 sub-QCIF
1135  10 QCIF
1136  7 extended PTYPE (PLUSPTYPE)
1137  */
1138 
1139  if (format != 7 && format != 6) {
1140  s->h263_plus = 0;
1141  /* H.263v1 */
1142  width = ff_h263_format[format][0];
1143  height = ff_h263_format[format][1];
1144  if (!width)
1145  return -1;
1146 
1147  s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);
1148 
1149  s->h263_long_vectors = get_bits1(&s->gb);
1150 
1151  if (get_bits1(&s->gb) != 0) {
1152  av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");
1153  return -1; /* SAC: off */
1154  }
1155  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1156 
1157  s->pb_frame = get_bits1(&s->gb);
1158  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1159  skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1160 
1161  s->width = width;
1162  s->height = height;
1163  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1164  s->avctx->framerate = (AVRational){ 30000, 1001 };
1165  } else {
1166  int ufep;
1167 
1168  /* H.263v2 */
1169  s->h263_plus = 1;
1170  ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1171 
1172  /* ufep other than 0 and 1 are reserved */
1173  if (ufep == 1) {
1174  /* OPPTYPE */
1175  format = get_bits(&s->gb, 3);
1176  ff_dlog(s->avctx, "ufep=1, format: %d\n", format);
1177  s->custom_pcf= get_bits1(&s->gb);
1178  s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
1179  if (get_bits1(&s->gb) != 0) {
1180  av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
1181  }
1182  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1183  s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1184  s->loop_filter= get_bits1(&s->gb);
1185  if(s->avctx->lowres)
1186  s->loop_filter = 0;
1187 
1188  s->h263_slice_structured= get_bits1(&s->gb);
1189  if (get_bits1(&s->gb) != 0) {
1190  av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
1191  }
1192  if (get_bits1(&s->gb) != 0) {
1193  av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
1194  }
1195  s->alt_inter_vlc= get_bits1(&s->gb);
1196  s->modified_quant= get_bits1(&s->gb);
1197  if(s->modified_quant)
1198  s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1199 
1200  skip_bits(&s->gb, 1); /* Prevent start code emulation */
1201 
1202  skip_bits(&s->gb, 3); /* Reserved */
1203  } else if (ufep != 0) {
1204  av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
1205  return -1;
1206  }
1207 
1208  /* MPPTYPE */
1209  s->pict_type = get_bits(&s->gb, 3);
1210  switch(s->pict_type){
1211  case 0: s->pict_type= AV_PICTURE_TYPE_I;break;
1212  case 1: s->pict_type= AV_PICTURE_TYPE_P;break;
1213  case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;
1214  case 3: s->pict_type= AV_PICTURE_TYPE_B;break;
1215  case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO
1216  default:
1217  return -1;
1218  }
1219  skip_bits(&s->gb, 2);
1220  s->no_rounding = get_bits1(&s->gb);
1221  skip_bits(&s->gb, 4);
1222 
1223  /* Get the picture dimensions */
1224  if (ufep) {
1225  if (format == 6) {
1226  /* Custom Picture Format (CPFMT) */
1227  int aspect_ratio_info = get_bits(&s->gb, 4);
1228  ff_dlog(s->avctx, "aspect: %d\n", aspect_ratio_info);
1229  /* aspect ratios:
1230  0 - forbidden
1231  1 - 1:1
1232  2 - 12:11 (CIF 4:3)
1233  3 - 10:11 (525-type 4:3)
1234  4 - 16:11 (CIF 16:9)
1235  5 - 40:33 (525-type 16:9)
1236  6-14 - reserved
1237  */
1238  width = (get_bits(&s->gb, 9) + 1) * 4;
1239  check_marker(s->avctx, &s->gb, "in dimensions");
1240  height = get_bits(&s->gb, 9) * 4;
1241  ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1242  if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
1243  /* expected dimensions */
1244  s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
1245  s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
1246  }else{
1247  s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info];
1248  }
1249  } else {
1250  width = ff_h263_format[format][0];
1251  height = ff_h263_format[format][1];
1252  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1253  }
1254  s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;
1255  if ((width == 0) || (height == 0))
1256  return -1;
1257  s->width = width;
1258  s->height = height;
1259 
1260  if(s->custom_pcf){
1261  int gcd;
1262  s->avctx->framerate.num = 1800000;
1263  s->avctx->framerate.den = 1000 + get_bits1(&s->gb);
1264  s->avctx->framerate.den *= get_bits(&s->gb, 7);
1265  if(s->avctx->framerate.den == 0){
1266  av_log(s, AV_LOG_ERROR, "zero framerate\n");
1267  return -1;
1268  }
1269  gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num);
1270  s->avctx->framerate.den /= gcd;
1271  s->avctx->framerate.num /= gcd;
1272  }else{
1273  s->avctx->framerate = (AVRational){ 30000, 1001 };
1274  }
1275  }
1276 
1277  if(s->custom_pcf){
1278  skip_bits(&s->gb, 2); //extended Temporal reference
1279  }
1280 
1281  if (ufep) {
1282  if (s->umvplus) {
1283  if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1284  skip_bits1(&s->gb);
1285  }
1286  if(s->h263_slice_structured){
1287  if (get_bits1(&s->gb) != 0) {
1288  av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
1289  }
1290  if (get_bits1(&s->gb) != 0) {
1291  av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
1292  }
1293  }
1294  if (s->pict_type == AV_PICTURE_TYPE_B) {
1295  skip_bits(&s->gb, 4); //ELNUM
1296  if (ufep == 1) {
1297  skip_bits(&s->gb, 4); // RLNUM
1298  }
1299  }
1300  }
1301 
1302  s->qscale = get_bits(&s->gb, 5);
1303  }
1304 
1305  if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0)
1306  return ret;
1307 
1308  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1309  if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb))
1310  return AVERROR_INVALIDDATA;
1311  }
1312 
1313  s->mb_width = (s->width + 15) / 16;
1314  s->mb_height = (s->height + 15) / 16;
1315  s->mb_num = s->mb_width * s->mb_height;
1316 
1317  if (s->pb_frame) {
1318  skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
1319  if (s->custom_pcf)
1320  skip_bits(&s->gb, 2); //extended Temporal reference
1321  skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
1322  }
1323 
1324  if (s->pict_type!=AV_PICTURE_TYPE_B) {
1325  s->time = s->picture_number;
1326  s->pp_time = s->time - s->last_non_b_time;
1327  s->last_non_b_time = s->time;
1328  }else{
1329  s->time = s->picture_number;
1330  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
1331  if (s->pp_time <=s->pb_time ||
1332  s->pp_time <= s->pp_time - s->pb_time ||
1333  s->pp_time <= 0){
1334  s->pp_time = 2;
1335  s->pb_time = 1;
1336  }
1337  ff_mpeg4_init_direct_mv(s);
1338  }
1339 
1340  /* PEI */
1341  if (skip_1stop_8data_bits(&s->gb) < 0)
1342  return AVERROR_INVALIDDATA;
1343 
1344  if(s->h263_slice_structured){
1345  if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) {
1346  return -1;
1347  }
1348 
1349  ff_h263_decode_mba(s);
1350 
1351  if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) {
1352  return -1;
1353  }
1354  }
1355  s->f_code = 1;
1356 
1357  if (s->pict_type == AV_PICTURE_TYPE_B)
1358  s->low_delay = 0;
1359 
1360  if(s->h263_aic){
1361  s->y_dc_scale_table=
1362  s->c_dc_scale_table= ff_aic_dc_scale_table;
1363  }else{
1364  s->y_dc_scale_table=
1365  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1366  }
1367 
1368  ff_h263_show_pict_info(s);
1369  if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
1370  int i,j;
1371  for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1372  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1373  for(i=0; i<13; i++){
1374  for(j=0; j<3; j++){
1375  int v= get_bits(&s->gb, 8);
1376  v |= get_sbits(&s->gb, 8) * (1 << 8);
1377  av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
1378  }
1379  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1380  }
1381  for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1382  }
1383 
1384  return 0;
1385 }
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:82
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:246
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
h263data.h
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:26
level
uint8_t level
Definition: svq3.c:206
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
h263_pred_acdc
static void h263_pred_acdc(MpegEncContext *s, int16_t *block, int n)
Definition: ituh263dec.c:445
ff_h263_show_pict_info
void ff_h263_show_pict_info(MpegEncContext *s)
Print picture info if FF_DEBUG_PICT_INFO is set.
Definition: ituh263dec.c:79
mem_internal.h
thread.h
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
mpeg4videodec.h
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:125
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
MV_DIRECT
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
Definition: mpegvideo.h:244
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
h263_decode_init_vlc
static av_cold void h263_decode_init_vlc(void)
Definition: ituh263dec.c:110
MB_TYPE_INTRA4x4
#define MB_TYPE_INTRA4x4
Definition: mpegutils.h:44
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
h263_decode_dquant
static void h263_decode_dquant(MpegEncContext *s)
Definition: ituh263dec.c:432
h263_mb_type_b_map
static const int h263_mb_type_b_map[15]
Definition: ituh263dec.c:61
mpegvideo.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1359
mathematics.h
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:61
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
Picture
Picture.
Definition: mpegpicture.h:46
h263_decode_block
static int h263_decode_block(MpegEncContext *s, int16_t *block, int n, int coded)
Definition: ituh263dec.c:532
ff_h263_decode_mba
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:141
mpegutils.h
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1323
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:243
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
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
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:786
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
wrap
#define wrap(func)
Definition: neontest.h:65
ff_h263_pixel_aspect
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.c:273
preview_obmc
static void preview_obmc(MpegEncContext *s)
read the next MVs for OBMC.
Definition: ituh263dec.c:340
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:61
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:92
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:64
val
static double val(void *priv, double ch)
Definition: aeval.c:77
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:472
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:94
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:1353
ff_cbpc_b_tab
const uint8_t ff_cbpc_b_tab[4][2]
Definition: h263data.c:75
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
mpegvideodec.h
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:83
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
cbpc_b_vlc
static VLC cbpc_b_vlc
Definition: ituh263dec.c:106
MB_TYPE_ACPRED
#define MB_TYPE_ACPRED
Definition: mpegutils.h:53
h263_decode_gob_header
static int h263_decode_gob_header(MpegEncContext *s)
Decode the group of blocks header or slice header.
Definition: ituh263dec.c:159
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
ff_h263_decode_init_vlc
av_cold void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:135
width
#define width
ff_h263_chroma_qscale_table
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
set_one_direct_mv
static void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
Definition: ituh263dec.c:721
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
IS_INTRA
#define IS_INTRA(x, y)
ff_h263_resync
int ff_h263_resync(MpegEncContext *s)
Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
Definition: ituh263dec.c:215
tab_size
#define tab_size
Definition: ituh263dec.c:719
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
run
uint8_t run
Definition: svq3.c:205
tab_bias
#define tab_bias
Definition: ituh263dec.c:720
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MB_TYPE_8x8
#define MB_TYPE_8x8
Definition: mpegutils.h:50
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
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:1709
mathops.h
ff_mba_max
const uint16_t ff_mba_max[6]
Definition: h263data.c:265
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:63
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1088
ff_h263_inter_MCBPC_vlc
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:102
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
AVOnce
#define AVOnce
Definition: thread.h:176
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_h263_intra_MCBPC_vlc
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:101
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:247
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: mpegvideodec.h:72
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
ff_h263_mv_vlc
VLC ff_h263_mv_vlc
Definition: ituh263dec.c:104
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ff_h263_cbpy_tab
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.c:82
ff_rl_intra_aic
RLTable ff_rl_intra_aic
Definition: h263data.c:228
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263dec.h:33
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
h263_mbtype_b_vlc
static VLC h263_mbtype_b_vlc
Definition: ituh263dec.c:105
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
height
#define height
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
mpegvideodata.h
attributes.h
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:54
ff_h263_inter_MCBPC_bits
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:47
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:77
unary.h
H263_MBTYPE_B_VLC_BITS
#define H263_MBTYPE_B_VLC_BITS
Definition: ituh263dec.c:58
ff_rv_decode_dc
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:84
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:62
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:55
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
internal.h
ff_mpeg4_decode_video_packet_header
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:516
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:31
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:88
h263_skip_b_part
static int h263_skip_b_part(MpegEncContext *s, int cbp)
Definition: ituh263dec.c:679
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_h263_format
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:236
CBPC_B_VLC_BITS
#define CBPC_B_VLC_BITS
Definition: ituh263dec.c:59
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:728
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:470
pred
static const float pred[4]
Definition: siprdata.h:259
ff_aic_dc_scale_table
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.c:245
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:683
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:133
pos
unsigned int pos
Definition: spdifenc.c:412
ff_mpeg4_init_direct_mv
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:83
ff_mvtab
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
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
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition: avcodec.h:312
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
ff_h263_intra_MCBPC_bits
const uint8_t ff_h263_intra_MCBPC_bits[9]
Definition: h263data.c:33
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:844
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:57
ff_h263_intra_MCBPC_code
const uint8_t ff_h263_intra_MCBPC_code[9]
Definition: h263data.c:32
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
mpeg4video.h
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
VLC
Definition: vlc.h:31
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:132
ff_mba_length
const uint8_t ff_mba_length[7]
Definition: h263data.c:269
VLC::table
VLCElem * table
Definition: vlc.h:33
h263p_decode_umotion
static int h263p_decode_umotion(MpegEncContext *s, int pred)
Definition: ituh263dec.c:310
shift
static int shift(int a, int b)
Definition: sonic.c:88
ff_h263_inter_MCBPC_code
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.c:38
INIT_VLC_RL
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:73
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
set_direct_mv
static int set_direct_mv(MpegEncContext *s)
Definition: ituh263dec.c:749
ff_modified_quant_tab
const uint8_t ff_modified_quant_tab[2][32]
Definition: h263data.c:250
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
SLICE_ERROR
#define SLICE_ERROR
Definition: mpegvideo.h:471
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
h263_get_modb
static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
Definition: ituh263dec.c:701
pred_dc
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
Definition: hevcpred_template.c:390
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:207
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:242
imgutils.h
MB_TYPE_DIRECT2
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:52
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
ff_h263_mbtype_b_tab
const uint8_t ff_h263_mbtype_b_tab[15][2]
Definition: h263data.c:57
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61

AltStyle によって変換されたページ (->オリジナル) /