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