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 int 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 
108 
109 /* init vlcs */
110 
111 static av_cold void h263_decode_init_vlc(void)
112 {
115  ff_h263_intra_MCBPC_code, 1, 1, 72);
118  ff_h263_inter_MCBPC_code, 1, 1, 198);
120  &ff_h263_cbpy_tab[0][1], 2, 1,
121  &ff_h263_cbpy_tab[0][0], 2, 1, 64);
123  &ff_mvtab[0][1], 2, 1,
124  &ff_mvtab[0][0], 2, 1, 538);
129  &ff_h263_mbtype_b_tab[0][1], 2, 1,
130  &ff_h263_mbtype_b_tab[0][0], 2, 1, 80);
132  &ff_cbpc_b_tab[0][1], 2, 1,
133  &ff_cbpc_b_tab[0][0], 2, 1, 8);
134 }
135 
137 {
138  static AVOnce init_static_once = AV_ONCE_INIT;
139  ff_thread_once(&init_static_once, h263_decode_init_vlc);
140 }
141 
143 {
144  int i, mb_pos;
145 
146  for (i = 0; i < 6; i++)
147  if (s->mb_num - 1 <= ff_mba_max[i])
148  break;
149  mb_pos = get_bits(&s->gb, ff_mba_length[i]);
150  s->mb_x = mb_pos % s->mb_width;
151  s->mb_y = mb_pos / s->mb_width;
152 
153  return mb_pos;
154 }
155 
156 /**
157  * Decode the group of blocks header or slice header.
158  * @return <0 if an error occurred
159  */
161 {
162  unsigned int val, gob_number;
163  int left;
164 
165  /* Check for GOB Start Code */
166  val = show_bits(&s->gb, 16);
167  if(val)
168  return -1;
169 
170  /* We have a GBSC probably with GSTUFF */
171  skip_bits(&s->gb, 16); /* Drop the zeros */
172  left= get_bits_left(&s->gb);
173  left = FFMIN(left, 32);
174  //MN: we must check the bits left or we might end in an infinite loop (or segfault)
175  for(;left>13; left--){
176  if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
177  }
178  if(left<=13)
179  return -1;
180 
181  if(s->h263_slice_structured){
182  if(check_marker(s->avctx, &s->gb, "before MBA")==0)
183  return -1;
184 
186 
187  if(s->mb_num > 1583)
188  if(check_marker(s->avctx, &s->gb, "after MBA")==0)
189  return -1;
190 
191  s->qscale = get_bits(&s->gb, 5); /* SQUANT */
192  if(check_marker(s->avctx, &s->gb, "after SQUANT")==0)
193  return -1;
194  skip_bits(&s->gb, 2); /* GFID */
195  }else{
196  gob_number = get_bits(&s->gb, 5); /* GN */
197  s->mb_x= 0;
198  s->mb_y= s->gob_index* gob_number;
199  skip_bits(&s->gb, 2); /* GFID */
200  s->qscale = get_bits(&s->gb, 5); /* GQUANT */
201  }
202 
203  if(s->mb_y >= s->mb_height)
204  return -1;
205 
206  if(s->qscale==0)
207  return -1;
208 
209  return 0;
210 }
211 
212 /**
213  * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
214  * @return bit position of the resync_marker, or <0 if none was found
215  */
217  int left, pos, ret;
218 
219  /* In MPEG-4 studio mode look for a new slice startcode
220  * and decode slice header */
221  if(s->codec_id==AV_CODEC_ID_MPEG4 && s->studio_profile) {
222  align_get_bits(&s->gb);
223 
224  while (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) != SLICE_STARTCODE) {
225  get_bits(&s->gb, 8);
226  }
227 
228  if (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) == SLICE_STARTCODE)
229  return get_bits_count(&s->gb);
230  else
231  return -1;
232  }
233 
234  if(s->codec_id==AV_CODEC_ID_MPEG4){
235  skip_bits1(&s->gb);
236  align_get_bits(&s->gb);
237  }
238 
239  if(show_bits(&s->gb, 16)==0){
240  pos= get_bits_count(&s->gb);
241  if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
242  ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
243  else
245  if(ret>=0)
246  return pos;
247  }
248  //OK, it's not where it is supposed to be ...
249  s->gb= s->last_resync_gb;
250  align_get_bits(&s->gb);
251  left= get_bits_left(&s->gb);
252 
253  for(;left>16+1+5+5; left-=8){
254  if(show_bits(&s->gb, 16)==0){
255  GetBitContext bak= s->gb;
256 
257  pos= get_bits_count(&s->gb);
258  if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)
259  ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);
260  else
262  if(ret>=0)
263  return pos;
264 
265  s->gb= bak;
266  }
267  skip_bits(&s->gb, 8);
268  }
269 
270  return -1;
271 }
272 
274 {
275  int code, val, sign, shift;
277 
278  if (code == 0)
279  return pred;
280  if (code < 0)
281  return 0xffff;
282 
283  sign = get_bits1(&s->gb);
284  shift = f_code - 1;
285  val = code;
286  if (shift) {
287  val = (val - 1) << shift;
288  val |= get_bits(&s->gb, shift);
289  val++;
290  }
291  if (sign)
292  val = -val;
293  val += pred;
294 
295  /* modulo decoding */
296  if (!s->h263_long_vectors) {
297  val = sign_extend(val, 5 + f_code);
298  } else {
299  /* horrible H.263 long vector mode */
300  if (pred < -31 && val < -63)
301  val += 64;
302  if (pred > 32 && val > 63)
303  val -= 64;
304 
305  }
306  return val;
307 }
308 
309 
310 /* Decode RVLC of H.263+ UMV */
312 {
313  int code = 0, sign;
314 
315  if (get_bits1(&s->gb)) /* Motion difference = 0 */
316  return pred;
317 
318  code = 2 + get_bits1(&s->gb);
319 
320  while (get_bits1(&s->gb))
321  {
322  code <<= 1;
323  code += get_bits1(&s->gb);
324  if (code >= 32768) {
325  avpriv_request_sample(s->avctx, "Huge DMV");
326  return 0xffff;
327  }
328  }
329  sign = code & 1;
330  code >>= 1;
331 
332  code = (sign) ? (pred - code) : (pred + code);
333  ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
334  return code;
335 
336 }
337 
338 /**
339  * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :)
340  */
342  GetBitContext gb= s->gb;
343 
344  int cbpc, i, pred_x, pred_y, mx, my;
345  int16_t *mot_val;
346  const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
347  const int stride= s->b8_stride*2;
348 
349  for(i=0; i<4; i++)
350  s->block_index[i]+= 2;
351  for(i=4; i<6; i++)
352  s->block_index[i]+= 1;
353  s->mb_x++;
354 
355  av_assert2(s->pict_type == AV_PICTURE_TYPE_P);
356 
357  do{
358  if (get_bits1(&s->gb)) {
359  /* skip mb */
360  mot_val = s->current_picture.motion_val[0][s->block_index[0]];
361  mot_val[0 ]= mot_val[2 ]=
362  mot_val[0+stride]= mot_val[2+stride]= 0;
363  mot_val[1 ]= mot_val[3 ]=
364  mot_val[1+stride]= mot_val[3+stride]= 0;
365 
366  s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
367  goto end;
368  }
370  }while(cbpc == 20);
371 
372  if(cbpc & 4){
373  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
374  }else{
376  if (cbpc & 8) {
377  if(s->modified_quant){
378  if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
379  else skip_bits(&s->gb, 5);
380  }else
381  skip_bits(&s->gb, 2);
382  }
383 
384  if ((cbpc & 16) == 0) {
385  s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
386  /* 16x16 motion prediction */
387  mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
388  if (s->umvplus)
389  mx = h263p_decode_umotion(s, pred_x);
390  else
391  mx = ff_h263_decode_motion(s, pred_x, 1);
392 
393  if (s->umvplus)
394  my = h263p_decode_umotion(s, pred_y);
395  else
396  my = ff_h263_decode_motion(s, pred_y, 1);
397 
398  mot_val[0 ]= mot_val[2 ]=
399  mot_val[0+stride]= mot_val[2+stride]= mx;
400  mot_val[1 ]= mot_val[3 ]=
401  mot_val[1+stride]= mot_val[3+stride]= my;
402  } else {
403  s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
404  for(i=0;i<4;i++) {
405  mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
406  if (s->umvplus)
407  mx = h263p_decode_umotion(s, pred_x);
408  else
409  mx = ff_h263_decode_motion(s, pred_x, 1);
410 
411  if (s->umvplus)
412  my = h263p_decode_umotion(s, pred_y);
413  else
414  my = ff_h263_decode_motion(s, pred_y, 1);
415  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
416  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
417  mot_val[0] = mx;
418  mot_val[1] = my;
419  }
420  }
421  }
422 end:
423 
424  for(i=0; i<4; i++)
425  s->block_index[i]-= 2;
426  for(i=4; i<6; i++)
427  s->block_index[i]-= 1;
428  s->mb_x--;
429 
430  s->gb= gb;
431 }
432 
434  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
435 
436  if(s->modified_quant){
437  if(get_bits1(&s->gb))
438  s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
439  else
440  s->qscale= get_bits(&s->gb, 5);
441  }else
442  s->qscale += quant_tab[get_bits(&s->gb, 2)];
443  ff_set_qscale(s, s->qscale);
444 }
445 
446 static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)
447 {
448  int x, y, wrap, a, c, pred_dc, scale;
449  int16_t *dc_val, *ac_val, *ac_val1;
450 
451  /* find prediction */
452  if (n < 4) {
453  x = 2 * s->mb_x + (n & 1);
454  y = 2 * s->mb_y + (n>> 1);
455  wrap = s->b8_stride;
456  dc_val = s->dc_val[0];
457  ac_val = s->ac_val[0][0];
458  scale = s->y_dc_scale;
459  } else {
460  x = s->mb_x;
461  y = s->mb_y;
462  wrap = s->mb_stride;
463  dc_val = s->dc_val[n - 4 + 1];
464  ac_val = s->ac_val[n - 4 + 1][0];
465  scale = s->c_dc_scale;
466  }
467 
468  ac_val += ((y) * wrap + (x)) * 16;
469  ac_val1 = ac_val;
470 
471  /* B C
472  * A X
473  */
474  a = dc_val[(x - 1) + (y) * wrap];
475  c = dc_val[(x) + (y - 1) * wrap];
476 
477  /* No prediction outside GOB boundary */
478  if (s->first_slice_line && n != 3) {
479  if (n != 2) c= 1024;
480  if (n != 1 && s->mb_x == s->resync_mb_x) a= 1024;
481  }
482 
483  if (s->ac_pred) {
484  pred_dc = 1024;
485  if (s->h263_aic_dir) {
486  /* left prediction */
487  if (a != 1024) {
488  ac_val -= 16;
489  for (int i = 1; i < 8; i++) {
490  block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
491  }
492  pred_dc = a;
493  }
494  } else {
495  /* top prediction */
496  if (c != 1024) {
497  ac_val -= 16 * wrap;
498  for (int i = 1; i < 8; i++) {
499  block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
500  }
501  pred_dc = c;
502  }
503  }
504  } else {
505  /* just DC prediction */
506  if (a != 1024 && c != 1024)
507  pred_dc = (a + c) >> 1;
508  else if (a != 1024)
509  pred_dc = a;
510  else
511  pred_dc = c;
512  }
513 
514  /* we assume pred is positive */
515  block[0] = block[0] * scale + pred_dc;
516 
517  if (block[0] < 0)
518  block[0] = 0;
519  else
520  block[0] |= 1;
521 
522  /* Update AC/DC tables */
523  dc_val[(x) + (y) * wrap] = block[0];
524 
525  /* left copy */
526  for (int i = 1; i < 8; i++)
527  ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
528  /* top copy */
529  for (int i = 1; i < 8; i++)
530  ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
531 }
532 
533 static int h263_decode_block(MpegEncContext * s, int16_t * block,
534  int n, int coded)
535 {
536  int level, i, j, run;
537  RLTable *rl = &ff_h263_rl_inter;
538  const uint8_t *scan_table;
539  GetBitContext gb= s->gb;
540 
541  scan_table = s->intra_scantable.permutated;
542  if (s->h263_aic && s->mb_intra) {
543  rl = &ff_rl_intra_aic;
544  i = 0;
545  if (s->ac_pred) {
546  if (s->h263_aic_dir)
547  scan_table = s->intra_v_scantable.permutated; /* left */
548  else
549  scan_table = s->intra_h_scantable.permutated; /* top */
550  }
551  } else if (s->mb_intra) {
552  /* DC coef */
553  if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) {
554  if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {
555  int component, diff;
556  component = (n <= 3 ? 0 : n - 4 + 1);
557  level = s->last_dc[component];
558  if (s->rv10_first_dc_coded[component]) {
559  diff = ff_rv_decode_dc(s, n);
560  if (diff < 0)
561  return -1;
562  level += diff;
563  level = level & 0xff; /* handle wrap round */
564  s->last_dc[component] = level;
565  } else {
566  s->rv10_first_dc_coded[component] = 1;
567  }
568  } else {
569  level = get_bits(&s->gb, 8);
570  if (level == 255)
571  level = 128;
572  }
573  }else{
574  level = get_bits(&s->gb, 8);
575  if((level&0x7F) == 0){
576  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
577  if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
578  return -1;
579  }
580  if (level == 255)
581  level = 128;
582  }
583  block[0] = level;
584  i = 1;
585  } else {
586  i = 0;
587  }
588  if (!coded) {
589  if (s->mb_intra && s->h263_aic)
590  goto not_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 not_coded:
672  if (s->mb_intra && s->h263_aic) {
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, Picture *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  Picture *p = &s->next_picture;
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_picture;
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->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
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.table, 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->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
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->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
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->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)];
898  int16_t *mot_val1 = s->current_picture.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{
909  if (mb_type < 0){
910  av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
911  return SLICE_ERROR;
912  }
913 
914  mb_type= h263_mb_type_b_map[ mb_type ];
915  }while(!mb_type);
916 
917  s->mb_intra = IS_INTRA(mb_type);
918  if(HAS_CBP(mb_type)){
919  s->bdsp.clear_blocks(s->block[0]);
920  cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
921  if(s->mb_intra){
922  dquant = IS_QUANT(mb_type);
923  goto intra;
924  }
925 
926  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
927 
928  if (cbpy < 0){
929  av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
930  return SLICE_ERROR;
931  }
932 
933  if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
934  cbpy ^= 0xF;
935 
936  cbp = (cbpc & 3) | (cbpy << 2);
937  }else
938  cbp=0;
939 
940  av_assert2(!s->mb_intra);
941 
942  if(IS_QUANT(mb_type)){
944  }
945 
946  if(IS_DIRECT(mb_type)){
948  mb_type |= set_direct_mv(s);
949  }else{
950  s->mv_dir = 0;
951  s->mv_type= MV_TYPE_16X16;
952 //FIXME UMV
953 
954  if(USES_LIST(mb_type, 0)){
955  int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
956  s->mv_dir = MV_DIR_FORWARD;
957 
958  if (s->umvplus)
959  mx = h263p_decode_umotion(s, pred_x);
960  else
961  mx = ff_h263_decode_motion(s, pred_x, 1);
962  if (mx >= 0xffff)
963  return SLICE_ERROR;
964 
965  if (s->umvplus)
966  my = h263p_decode_umotion(s, pred_y);
967  else
968  my = ff_h263_decode_motion(s, pred_y, 1);
969  if (my >= 0xffff)
970  return SLICE_ERROR;
971 
972  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
973  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
974 
975  s->mv[0][0][0] = mx;
976  s->mv[0][0][1] = my;
977  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
978  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
979  }
980 
981  if(USES_LIST(mb_type, 1)){
982  int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);
983  s->mv_dir |= MV_DIR_BACKWARD;
984 
985  if (s->umvplus)
986  mx = h263p_decode_umotion(s, pred_x);
987  else
988  mx = ff_h263_decode_motion(s, pred_x, 1);
989  if (mx >= 0xffff)
990  return SLICE_ERROR;
991 
992  if (s->umvplus)
993  my = h263p_decode_umotion(s, pred_y);
994  else
995  my = ff_h263_decode_motion(s, pred_y, 1);
996  if (my >= 0xffff)
997  return SLICE_ERROR;
998 
999  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
1000  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1001 
1002  s->mv[1][0][0] = mx;
1003  s->mv[1][0][1] = my;
1004  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
1005  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1006  }
1007  }
1008 
1009  s->current_picture.mb_type[xy] = mb_type;
1010  } else { /* I-Frame */
1011  do{
1013  if (cbpc < 0){
1014  av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1015  return SLICE_ERROR;
1016  }
1017  }while(cbpc == 8);
1018 
1019  s->bdsp.clear_blocks(s->block[0]);
1020 
1021  dquant = cbpc & 4;
1022  s->mb_intra = 1;
1023 intra:
1024  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1025  if (s->h263_aic) {
1026  s->ac_pred = get_bits1(&s->gb);
1027  if(s->ac_pred){
1028  s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1029 
1030  s->h263_aic_dir = get_bits1(&s->gb);
1031  }
1032  }else
1033  s->ac_pred = 0;
1034 
1035  if(s->pb_frame && get_bits1(&s->gb))
1036  pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
1037  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1038  if(cbpy<0){
1039  av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1040  return SLICE_ERROR;
1041  }
1042  cbp = (cbpc & 3) | (cbpy << 2);
1043  if (dquant) {
1045  }
1046 
1047  pb_mv_count += !!s->pb_frame;
1048  }
1049 
1050  while(pb_mv_count--){
1051  ff_h263_decode_motion(s, 0, 1);
1052  ff_h263_decode_motion(s, 0, 1);
1053  }
1054 
1055  /* decode each block */
1056  for (i = 0; i < 6; i++) {
1057  if (h263_decode_block(s, block[i], i, cbp&32) < 0)
1058  return -1;
1059  cbp+=cbp;
1060  }
1061 
1062  if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
1063  return -1;
1064  if(s->obmc && !s->mb_intra){
1065  if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
1066  preview_obmc(s);
1067  }
1068 end:
1069 
1070  if (get_bits_left(&s->gb) < 0)
1071  return AVERROR_INVALIDDATA;
1072 
1073  /* per-MB end of slice check */
1074  {
1075  int v= show_bits(&s->gb, 16);
1076 
1077  if (get_bits_left(&s->gb) < 16) {
1078  v >>= 16 - get_bits_left(&s->gb);
1079  }
1080 
1081  if(v==0)
1082  return SLICE_END;
1083  }
1084 
1085  return SLICE_OK;
1086 }
1087 
1088 /* Most is hardcoded; should extend to handle all H.263 streams. */
1090 {
1091  int format, width, height, i, ret;
1092  uint32_t startcode;
1093 
1094  align_get_bits(&s->gb);
1095 
1096  if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) {
1097  av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
1098  }
1099 
1100  startcode= get_bits(&s->gb, 22-8);
1101 
1102  for(i= get_bits_left(&s->gb); i>24; i-=8) {
1103  startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
1104 
1105  if(startcode == 0x20)
1106  break;
1107  }
1108 
1109  if (startcode != 0x20) {
1110  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
1111  return -1;
1112  }
1113  /* temporal reference */
1114  i = get_bits(&s->gb, 8); /* picture timestamp */
1115 
1116  i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;
1117 
1118  s->picture_number= (s->picture_number&~0xFF) + i;
1119 
1120  /* PTYPE starts here */
1121  if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) {
1122  return -1;
1123  }
1124  if (get_bits1(&s->gb) != 0) {
1125  av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n");
1126  return -1; /* H.263 id */
1127  }
1128  skip_bits1(&s->gb); /* split screen off */
1129  skip_bits1(&s->gb); /* camera off */
1130  skip_bits1(&s->gb); /* freeze picture release off */
1131 
1132  format = get_bits(&s->gb, 3);
1133  /*
1134  0 forbidden
1135  1 sub-QCIF
1136  10 QCIF
1137  7 extended PTYPE (PLUSPTYPE)
1138  */
1139 
1140  if (format != 7 && format != 6) {
1141  s->h263_plus = 0;
1142  /* H.263v1 */
1143  width = ff_h263_format[format][0];
1145  if (!width)
1146  return -1;
1147 
1148  s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);
1149 
1150  s->h263_long_vectors = get_bits1(&s->gb);
1151 
1152  if (get_bits1(&s->gb) != 0) {
1153  av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");
1154  return -1; /* SAC: off */
1155  }
1156  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1157 
1158  s->pb_frame = get_bits1(&s->gb);
1159  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1160  skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1161 
1162  s->width = width;
1163  s->height = height;
1164  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1165  s->avctx->framerate = (AVRational){ 30000, 1001 };
1166  } else {
1167  int ufep;
1168 
1169  /* H.263v2 */
1170  s->h263_plus = 1;
1171  ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1172 
1173  /* ufep other than 0 and 1 are reserved */
1174  if (ufep == 1) {
1175  /* OPPTYPE */
1176  format = get_bits(&s->gb, 3);
1177  ff_dlog(s->avctx, "ufep=1, format: %d\n", format);
1178  s->custom_pcf= get_bits1(&s->gb);
1179  s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
1180  if (get_bits1(&s->gb) != 0) {
1181  av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
1182  }
1183  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1184  s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1185  s->loop_filter= get_bits1(&s->gb);
1186  if(s->avctx->lowres)
1187  s->loop_filter = 0;
1188 
1189  s->h263_slice_structured= get_bits1(&s->gb);
1190  if (get_bits1(&s->gb) != 0) {
1191  av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
1192  }
1193  if (get_bits1(&s->gb) != 0) {
1194  av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
1195  }
1196  s->alt_inter_vlc= get_bits1(&s->gb);
1197  s->modified_quant= get_bits1(&s->gb);
1198  if(s->modified_quant)
1199  s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1200 
1201  skip_bits(&s->gb, 1); /* Prevent start code emulation */
1202 
1203  skip_bits(&s->gb, 3); /* Reserved */
1204  } else if (ufep != 0) {
1205  av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
1206  return -1;
1207  }
1208 
1209  /* MPPTYPE */
1210  s->pict_type = get_bits(&s->gb, 3);
1211  switch(s->pict_type){
1212  case 0: s->pict_type= AV_PICTURE_TYPE_I;break;
1213  case 1: s->pict_type= AV_PICTURE_TYPE_P;break;
1214  case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;
1215  case 3: s->pict_type= AV_PICTURE_TYPE_B;break;
1216  case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO
1217  default:
1218  return -1;
1219  }
1220  skip_bits(&s->gb, 2);
1221  s->no_rounding = get_bits1(&s->gb);
1222  skip_bits(&s->gb, 4);
1223 
1224  /* Get the picture dimensions */
1225  if (ufep) {
1226  if (format == 6) {
1227  /* Custom Picture Format (CPFMT) */
1228  int aspect_ratio_info = get_bits(&s->gb, 4);
1229  ff_dlog(s->avctx, "aspect: %d\n", aspect_ratio_info);
1230  /* aspect ratios:
1231  0 - forbidden
1232  1 - 1:1
1233  2 - 12:11 (CIF 4:3)
1234  3 - 10:11 (525-type 4:3)
1235  4 - 16:11 (CIF 16:9)
1236  5 - 40:33 (525-type 16:9)
1237  6-14 - reserved
1238  */
1239  width = (get_bits(&s->gb, 9) + 1) * 4;
1240  check_marker(s->avctx, &s->gb, "in dimensions");
1241  height = get_bits(&s->gb, 9) * 4;
1242  ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1243  if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
1244  /* expected dimensions */
1245  s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
1246  s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
1247  }else{
1248  s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info];
1249  }
1250  } else {
1251  width = ff_h263_format[format][0];
1253  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1254  }
1255  s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;
1256  if ((width == 0) || (height == 0))
1257  return -1;
1258  s->width = width;
1259  s->height = height;
1260 
1261  if(s->custom_pcf){
1262  int gcd;
1263  s->avctx->framerate.num = 1800000;
1264  s->avctx->framerate.den = 1000 + get_bits1(&s->gb);
1265  s->avctx->framerate.den *= get_bits(&s->gb, 7);
1266  if(s->avctx->framerate.den == 0){
1267  av_log(s, AV_LOG_ERROR, "zero framerate\n");
1268  return -1;
1269  }
1270  gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num);
1271  s->avctx->framerate.den /= gcd;
1272  s->avctx->framerate.num /= gcd;
1273  }else{
1274  s->avctx->framerate = (AVRational){ 30000, 1001 };
1275  }
1276  }
1277 
1278  if(s->custom_pcf){
1279  skip_bits(&s->gb, 2); //extended Temporal reference
1280  }
1281 
1282  if (ufep) {
1283  if (s->umvplus) {
1284  if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1285  skip_bits1(&s->gb);
1286  }
1287  if(s->h263_slice_structured){
1288  if (get_bits1(&s->gb) != 0) {
1289  av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
1290  }
1291  if (get_bits1(&s->gb) != 0) {
1292  av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
1293  }
1294  }
1295  if (s->pict_type == AV_PICTURE_TYPE_B) {
1296  skip_bits(&s->gb, 4); //ELNUM
1297  if (ufep == 1) {
1298  skip_bits(&s->gb, 4); // RLNUM
1299  }
1300  }
1301  }
1302 
1303  s->qscale = get_bits(&s->gb, 5);
1304  }
1305 
1306  if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0)
1307  return ret;
1308 
1309  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1310  if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb))
1311  return AVERROR_INVALIDDATA;
1312  }
1313 
1314  s->mb_width = (s->width + 15) / 16;
1315  s->mb_height = (s->height + 15) / 16;
1316  s->mb_num = s->mb_width * s->mb_height;
1317 
1318  if (s->pb_frame) {
1319  skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
1320  if (s->custom_pcf)
1321  skip_bits(&s->gb, 2); //extended Temporal reference
1322  skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
1323  }
1324 
1325  if (s->pict_type!=AV_PICTURE_TYPE_B) {
1326  s->time = s->picture_number;
1327  s->pp_time = s->time - s->last_non_b_time;
1328  s->last_non_b_time = s->time;
1329  }else{
1330  s->time = s->picture_number;
1331  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
1332  if (s->pp_time <=s->pb_time ||
1333  s->pp_time <= s->pp_time - s->pb_time ||
1334  s->pp_time <= 0){
1335  s->pp_time = 2;
1336  s->pb_time = 1;
1337  }
1339  }
1340 
1341  /* PEI */
1342  if (skip_1stop_8data_bits(&s->gb) < 0)
1343  return AVERROR_INVALIDDATA;
1344 
1345  if(s->h263_slice_structured){
1346  if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) {
1347  return -1;
1348  }
1349 
1351 
1352  if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) {
1353  return -1;
1354  }
1355  }
1356  s->f_code = 1;
1357 
1358  if (s->pict_type == AV_PICTURE_TYPE_B)
1359  s->low_delay = 0;
1360 
1361  if(s->h263_aic){
1362  s->y_dc_scale_table=
1363  s->c_dc_scale_table= ff_aic_dc_scale_table;
1364  }else{
1365  s->y_dc_scale_table=
1366  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1367  }
1368 
1370  if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
1371  int i,j;
1372  for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1373  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1374  for(i=0; i<13; i++){
1375  for(j=0; j<3; j++){
1376  int v= get_bits(&s->gb, 8);
1377  v |= get_sbits(&s->gb, 8) * (1 << 8);
1378  av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
1379  }
1380  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1381  }
1382  for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1383  }
1384 
1385  return 0;
1386 }
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:82
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:60
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:255
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
h263data.h
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:26
level
uint8_t level
Definition: svq3.c:204
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
h263_pred_acdc
static void h263_pred_acdc(MpegEncContext *s, int16_t *block, int n)
Definition: ituh263dec.c:446
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
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
mpeg4videodec.h
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:125
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
MV_DIRECT
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
Definition: mpegvideo.h:253
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:44
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
h263_decode_dquant
static void h263_decode_dquant(MpegEncContext *s)
Definition: ituh263dec.c:433
h263_mb_type_b_map
static const int h263_mb_type_b_map[15]
Definition: ituh263dec.c:62
mpegvideo.h
mathematics.h
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:61
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
Picture
Picture.
Definition: mpegpicture.h:46
h263_decode_block
static int h263_decode_block(MpegEncContext *s, int16_t *block, int n, int coded)
Definition: ituh263dec.c:533
ff_h263_decode_mba
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:142
mpegutils.h
SLICE_STARTCODE
#define SLICE_STARTCODE
Definition: mpeg4videodefs.h:60
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1328
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:252
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:180
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:787
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
wrap
#define wrap(func)
Definition: neontest.h:65
ff_h263_pixel_aspect
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.c:273
preview_obmc
static void preview_obmc(MpegEncContext *s)
read the next MVs for OBMC.
Definition: ituh263dec.c:341
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:61
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: defs.h:49
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:92
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:64
val
static double val(void *priv, double ch)
Definition: aeval.c:77
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:481
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:94
ff_cbpc_b_tab
const uint8_t ff_cbpc_b_tab[4][2]
Definition: h263data.c:75
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:83
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
cbpc_b_vlc
static VLC cbpc_b_vlc
Definition: ituh263dec.c:107
MB_TYPE_ACPRED
#define MB_TYPE_ACPRED
Definition: mpegutils.h:53
h263_decode_gob_header
static int h263_decode_gob_header(MpegEncContext *s)
Decode the group of blocks header or slice header.
Definition: ituh263dec.c:160
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
ff_h263_decode_init_vlc
av_cold void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:136
width
#define width
ff_h263_chroma_qscale_table
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
set_one_direct_mv
static void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
Definition: ituh263dec.c:722
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
IS_INTRA
#define IS_INTRA(x, y)
ff_h263_resync
int ff_h263_resync(MpegEncContext *s)
Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
Definition: ituh263dec.c:216
tab_size
#define tab_size
Definition: ituh263dec.c:720
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:137
run
uint8_t run
Definition: svq3.c:203
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:50
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:1605
mathops.h
ff_mba_max
const uint16_t ff_mba_max[6]
Definition: h263data.c:265
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:63
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1089
ff_h263_inter_MCBPC_vlc
VLC ff_h263_inter_MCBPC_vlc
Definition: ituh263dec.c:103
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
AVOnce
#define AVOnce
Definition: thread.h:176
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_h263_intra_MCBPC_vlc
VLC ff_h263_intra_MCBPC_vlc
Definition: ituh263dec.c:102
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:256
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: mpegvideodec.h:72
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
ff_h263_mv_vlc
VLC ff_h263_mv_vlc
Definition: ituh263dec.c:105
shift
static int shift(int a, int b)
Definition: bonk.c:260
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
ff_h263_cbpy_tab
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.c:82
ff_rl_intra_aic
RLTable ff_rl_intra_aic
Definition: h263data.c:228
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263dec.h:33
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
h263_mbtype_b_vlc
static VLC h263_mbtype_b_vlc
Definition: ituh263dec.c:106
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
height
#define height
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
mpegvideodata.h
attributes.h
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:54
ff_h263_inter_MCBPC_bits
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:47
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:77
unary.h
H263_MBTYPE_B_VLC_BITS
#define H263_MBTYPE_B_VLC_BITS
Definition: ituh263dec.c:59
ff_rv_decode_dc
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:84
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:62
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:57
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:185
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
internal.h
ff_mpeg4_decode_video_packet_header
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:517
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:31
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:88
h263_skip_b_part
static int h263_skip_b_part(MpegEncContext *s, int cbp)
Definition: ituh263dec.c:680
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_h263_format
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:236
CBPC_B_VLC_BITS
#define CBPC_B_VLC_BITS
Definition: ituh263dec.c:60
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:728
mpeg4videodefs.h
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:479
pred
static const float pred[4]
Definition: siprdata.h:259
ff_aic_dc_scale_table
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.c:245
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:683
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:146
pos
unsigned int pos
Definition: spdifenc.c:412
ff_mpeg4_init_direct_mv
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:83
ff_mvtab
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition: avcodec.h:322
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
ff_h263_intra_MCBPC_bits
const uint8_t ff_h263_intra_MCBPC_bits[9]
Definition: h263data.c:33
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:844
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:57
ff_h263_intra_MCBPC_code
const uint8_t ff_h263_intra_MCBPC_code[9]
Definition: h263data.c:32
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
mpeg4video.h
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
VLC
Definition: vlc.h:31
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
ff_mba_length
const uint8_t ff_mba_length[7]
Definition: h263data.c:269
VLC::table
VLCElem * table
Definition: vlc.h:33
h263p_decode_umotion
static int h263p_decode_umotion(MpegEncContext *s, int pred)
Definition: ituh263dec.c:311
ff_h263_inter_MCBPC_code
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.c:38
INIT_VLC_RL
#define INIT_VLC_RL(rl, static_size)
Definition: rl.h:73
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
set_direct_mv
static int set_direct_mv(MpegEncContext *s)
Definition: ituh263dec.c: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:36
SLICE_ERROR
#define SLICE_ERROR
Definition: mpegvideo.h:480
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
h263_get_modb
static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
Definition: ituh263dec.c:702
pred_dc
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
Definition: hevcpred_template.c:390
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:162
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:251
imgutils.h
MB_TYPE_DIRECT2
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:52
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_h263_mbtype_b_tab
const uint8_t ff_h263_mbtype_b_tab[15][2]
Definition: h263data.c:57
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
H263_MV_VLC_BITS
#define H263_MV_VLC_BITS
Definition: h263dec.h:30
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:273
ff_h263_cbpy_vlc
VLC ff_h263_cbpy_vlc
Definition: ituh263dec.c:104
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:62
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:66
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263dec.h:32
re
float re
Definition: fft.c:79
h263.h