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