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