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 
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, 0);
132  &ff_cbpc_b_tab[0][1], 2, 1,
133  &ff_cbpc_b_tab[0][0], 2, 1, 0);
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->permutated_intra_v_scantable; /* left */
548  else
549  scan_table = s->permutated_intra_h_scantable; /* 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, 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{
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 
915  mb_type= h263_mb_type_b_map[ mb_type ];
916  }while(!mb_type);
917 
918  s->mb_intra = IS_INTRA(mb_type);
919  if(HAS_CBP(mb_type)){
920  s->bdsp.clear_blocks(s->block[0]);
921  cbpc = get_vlc2(&s->gb, cbpc_b_vlc, CBPC_B_VLC_BITS, 1);
922  if(s->mb_intra){
923  dquant = IS_QUANT(mb_type);
924  goto intra;
925  }
926 
927  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
928 
929  if (cbpy < 0){
930  av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
931  return SLICE_ERROR;
932  }
933 
934  if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
935  cbpy ^= 0xF;
936 
937  cbp = (cbpc & 3) | (cbpy << 2);
938  }else
939  cbp=0;
940 
941  av_assert2(!s->mb_intra);
942 
943  if(IS_QUANT(mb_type)){
945  }
946 
947  if(IS_DIRECT(mb_type)){
949  mb_type |= set_direct_mv(s);
950  }else{
951  s->mv_dir = 0;
952  s->mv_type= MV_TYPE_16X16;
953 //FIXME UMV
954 
955  if(USES_LIST(mb_type, 0)){
956  int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
957  s->mv_dir = MV_DIR_FORWARD;
958 
959  if (s->umvplus)
960  mx = h263p_decode_umotion(s, pred_x);
961  else
962  mx = ff_h263_decode_motion(s, pred_x, 1);
963  if (mx >= 0xffff)
964  return SLICE_ERROR;
965 
966  if (s->umvplus)
967  my = h263p_decode_umotion(s, pred_y);
968  else
969  my = ff_h263_decode_motion(s, pred_y, 1);
970  if (my >= 0xffff)
971  return SLICE_ERROR;
972 
973  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
974  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
975 
976  s->mv[0][0][0] = mx;
977  s->mv[0][0][1] = my;
978  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
979  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
980  }
981 
982  if(USES_LIST(mb_type, 1)){
983  int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);
984  s->mv_dir |= MV_DIR_BACKWARD;
985 
986  if (s->umvplus)
987  mx = h263p_decode_umotion(s, pred_x);
988  else
989  mx = ff_h263_decode_motion(s, pred_x, 1);
990  if (mx >= 0xffff)
991  return SLICE_ERROR;
992 
993  if (s->umvplus)
994  my = h263p_decode_umotion(s, pred_y);
995  else
996  my = ff_h263_decode_motion(s, pred_y, 1);
997  if (my >= 0xffff)
998  return SLICE_ERROR;
999 
1000  if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
1001  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
1002 
1003  s->mv[1][0][0] = mx;
1004  s->mv[1][0][1] = my;
1005  mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
1006  mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1007  }
1008  }
1009 
1010  s->current_picture.mb_type[xy] = mb_type;
1011  } else { /* I-Frame */
1012  do{
1014  if (cbpc < 0){
1015  av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1016  return SLICE_ERROR;
1017  }
1018  }while(cbpc == 8);
1019 
1020  s->bdsp.clear_blocks(s->block[0]);
1021 
1022  dquant = cbpc & 4;
1023  s->mb_intra = 1;
1024 intra:
1025  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
1026  if (s->h263_aic) {
1027  s->ac_pred = get_bits1(&s->gb);
1028  if(s->ac_pred){
1029  s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
1030 
1031  s->h263_aic_dir = get_bits1(&s->gb);
1032  }
1033  }else
1034  s->ac_pred = 0;
1035 
1036  if(s->pb_frame && get_bits1(&s->gb))
1037  pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
1038  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
1039  if(cbpy<0){
1040  av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1041  return SLICE_ERROR;
1042  }
1043  cbp = (cbpc & 3) | (cbpy << 2);
1044  if (dquant) {
1046  }
1047 
1048  pb_mv_count += !!s->pb_frame;
1049  }
1050 
1051  while(pb_mv_count--){
1052  ff_h263_decode_motion(s, 0, 1);
1053  ff_h263_decode_motion(s, 0, 1);
1054  }
1055 
1056  /* decode each block */
1057  for (i = 0; i < 6; i++) {
1058  if (h263_decode_block(s, block[i], i, cbp&32) < 0)
1059  return -1;
1060  cbp+=cbp;
1061  }
1062 
1063  if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)
1064  return -1;
1065  if(s->obmc && !s->mb_intra){
1066  if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
1067  preview_obmc(s);
1068  }
1069 end:
1070 
1071  if (get_bits_left(&s->gb) < 0)
1072  return AVERROR_INVALIDDATA;
1073 
1074  /* per-MB end of slice check */
1075  {
1076  int v= show_bits(&s->gb, 16);
1077 
1078  if (get_bits_left(&s->gb) < 16) {
1079  v >>= 16 - get_bits_left(&s->gb);
1080  }
1081 
1082  if(v==0)
1083  return SLICE_END;
1084  }
1085 
1086  return SLICE_OK;
1087 }
1088 
1089 /* Most is hardcoded; should extend to handle all H.263 streams. */
1091 {
1092  int format, width, height, i, ret;
1093  uint32_t startcode;
1094 
1095  align_get_bits(&s->gb);
1096 
1097  if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_num == 0) {
1098  av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
1099  }
1100 
1101  startcode= get_bits(&s->gb, 22-8);
1102 
1103  for(i= get_bits_left(&s->gb); i>24; i-=8) {
1104  startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
1105 
1106  if(startcode == 0x20)
1107  break;
1108  }
1109 
1110  if (startcode != 0x20) {
1111  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
1112  return -1;
1113  }
1114  /* temporal reference */
1115  i = get_bits(&s->gb, 8); /* picture timestamp */
1116 
1117  i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;
1118 
1119  s->picture_number= (s->picture_number&~0xFF) + i;
1120 
1121  /* PTYPE starts here */
1122  if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) {
1123  return -1;
1124  }
1125  if (get_bits1(&s->gb) != 0) {
1126  av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n");
1127  return -1; /* H.263 id */
1128  }
1129  skip_bits1(&s->gb); /* split screen off */
1130  skip_bits1(&s->gb); /* camera off */
1131  skip_bits1(&s->gb); /* freeze picture release off */
1132 
1133  format = get_bits(&s->gb, 3);
1134  /*
1135  0 forbidden
1136  1 sub-QCIF
1137  10 QCIF
1138  7 extended PTYPE (PLUSPTYPE)
1139  */
1140 
1141  if (format != 7 && format != 6) {
1142  s->h263_plus = 0;
1143  /* H.263v1 */
1144  width = ff_h263_format[format][0];
1146  if (!width)
1147  return -1;
1148 
1149  s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);
1150 
1151  s->h263_long_vectors = get_bits1(&s->gb);
1152 
1153  if (get_bits1(&s->gb) != 0) {
1154  av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");
1155  return -1; /* SAC: off */
1156  }
1157  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1158 
1159  s->pb_frame = get_bits1(&s->gb);
1160  s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1161  skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1162 
1163  s->width = width;
1164  s->height = height;
1165  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1166  s->avctx->framerate = (AVRational){ 30000, 1001 };
1167  } else {
1168  int ufep;
1169 
1170  /* H.263v2 */
1171  s->h263_plus = 1;
1172  ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
1173 
1174  /* ufep other than 0 and 1 are reserved */
1175  if (ufep == 1) {
1176  /* OPPTYPE */
1177  format = get_bits(&s->gb, 3);
1178  ff_dlog(s->avctx, "ufep=1, format: %d\n", format);
1179  s->custom_pcf= get_bits1(&s->gb);
1180  s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */
1181  if (get_bits1(&s->gb) != 0) {
1182  av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
1183  }
1184  s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
1185  s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1186  s->loop_filter= get_bits1(&s->gb);
1187  if(s->avctx->lowres)
1188  s->loop_filter = 0;
1189 
1190  s->h263_slice_structured= get_bits1(&s->gb);
1191  if (get_bits1(&s->gb) != 0) {
1192  av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
1193  }
1194  if (get_bits1(&s->gb) != 0) {
1195  av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
1196  }
1197  s->alt_inter_vlc= get_bits1(&s->gb);
1198  s->modified_quant= get_bits1(&s->gb);
1199  if(s->modified_quant)
1200  s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1201 
1202  skip_bits(&s->gb, 1); /* Prevent start code emulation */
1203 
1204  skip_bits(&s->gb, 3); /* Reserved */
1205  } else if (ufep != 0) {
1206  av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
1207  return -1;
1208  }
1209 
1210  /* MPPTYPE */
1211  s->pict_type = get_bits(&s->gb, 3);
1212  switch(s->pict_type){
1213  case 0: s->pict_type= AV_PICTURE_TYPE_I;break;
1214  case 1: s->pict_type= AV_PICTURE_TYPE_P;break;
1215  case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;
1216  case 3: s->pict_type= AV_PICTURE_TYPE_B;break;
1217  case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO
1218  default:
1219  return -1;
1220  }
1221  skip_bits(&s->gb, 2);
1222  s->no_rounding = get_bits1(&s->gb);
1223  skip_bits(&s->gb, 4);
1224 
1225  /* Get the picture dimensions */
1226  if (ufep) {
1227  if (format == 6) {
1228  /* Custom Picture Format (CPFMT) */
1229  int aspect_ratio_info = get_bits(&s->gb, 4);
1230  ff_dlog(s->avctx, "aspect: %d\n", aspect_ratio_info);
1231  /* aspect ratios:
1232  0 - forbidden
1233  1 - 1:1
1234  2 - 12:11 (CIF 4:3)
1235  3 - 10:11 (525-type 4:3)
1236  4 - 16:11 (CIF 16:9)
1237  5 - 40:33 (525-type 16:9)
1238  6-14 - reserved
1239  */
1240  width = (get_bits(&s->gb, 9) + 1) * 4;
1241  check_marker(s->avctx, &s->gb, "in dimensions");
1242  height = get_bits(&s->gb, 9) * 4;
1243  ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
1244  if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
1245  /* expected dimensions */
1246  s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
1247  s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
1248  }else{
1249  s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info];
1250  }
1251  } else {
1252  width = ff_h263_format[format][0];
1254  s->avctx->sample_aspect_ratio= (AVRational){12,11};
1255  }
1256  s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;
1257  if ((width == 0) || (height == 0))
1258  return -1;
1259  s->width = width;
1260  s->height = height;
1261 
1262  if(s->custom_pcf){
1263  int gcd;
1264  s->avctx->framerate.num = 1800000;
1265  s->avctx->framerate.den = 1000 + get_bits1(&s->gb);
1266  s->avctx->framerate.den *= get_bits(&s->gb, 7);
1267  if(s->avctx->framerate.den == 0){
1268  av_log(s, AV_LOG_ERROR, "zero framerate\n");
1269  return -1;
1270  }
1271  gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num);
1272  s->avctx->framerate.den /= gcd;
1273  s->avctx->framerate.num /= gcd;
1274  }else{
1275  s->avctx->framerate = (AVRational){ 30000, 1001 };
1276  }
1277  }
1278 
1279  if(s->custom_pcf){
1280  skip_bits(&s->gb, 2); //extended Temporal reference
1281  }
1282 
1283  if (ufep) {
1284  if (s->umvplus) {
1285  if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1286  skip_bits1(&s->gb);
1287  }
1288  if(s->h263_slice_structured){
1289  if (get_bits1(&s->gb) != 0) {
1290  av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
1291  }
1292  if (get_bits1(&s->gb) != 0) {
1293  av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
1294  }
1295  }
1296  if (s->pict_type == AV_PICTURE_TYPE_B) {
1297  skip_bits(&s->gb, 4); //ELNUM
1298  if (ufep == 1) {
1299  skip_bits(&s->gb, 4); // RLNUM
1300  }
1301  }
1302  }
1303 
1304  s->qscale = get_bits(&s->gb, 5);
1305  }
1306 
1307  if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0)
1308  return ret;
1309 
1310  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1311  if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb))
1312  return AVERROR_INVALIDDATA;
1313  }
1314 
1315  s->mb_width = (s->width + 15) / 16;
1316  s->mb_height = (s->height + 15) / 16;
1317  s->mb_num = s->mb_width * s->mb_height;
1318 
1319  if (s->pb_frame) {
1320  skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */
1321  if (s->custom_pcf)
1322  skip_bits(&s->gb, 2); //extended Temporal reference
1323  skip_bits(&s->gb, 2); /* Quantization information for B-pictures */
1324  }
1325 
1326  if (s->pict_type!=AV_PICTURE_TYPE_B) {
1327  s->time = s->picture_number;
1328  s->pp_time = s->time - s->last_non_b_time;
1329  s->last_non_b_time = s->time;
1330  }else{
1331  s->time = s->picture_number;
1332  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
1333  if (s->pp_time <=s->pb_time ||
1334  s->pp_time <= s->pp_time - s->pb_time ||
1335  s->pp_time <= 0){
1336  s->pp_time = 2;
1337  s->pb_time = 1;
1338  }
1340  }
1341 
1342  /* PEI */
1343  if (skip_1stop_8data_bits(&s->gb) < 0)
1344  return AVERROR_INVALIDDATA;
1345 
1346  if(s->h263_slice_structured){
1347  if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) {
1348  return -1;
1349  }
1350 
1352 
1353  if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) {
1354  return -1;
1355  }
1356  }
1357  s->f_code = 1;
1358 
1359  if (s->pict_type == AV_PICTURE_TYPE_B)
1360  s->low_delay = 0;
1361 
1362  if(s->h263_aic){
1363  s->y_dc_scale_table=
1364  s->c_dc_scale_table= ff_aic_dc_scale_table;
1365  }else{
1366  s->y_dc_scale_table=
1367  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1368  }
1369 
1371  if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
1372  int i,j;
1373  for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1374  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1375  for(i=0; i<13; i++){
1376  for(j=0; j<3; j++){
1377  int v= get_bits(&s->gb, 8);
1378  v |= get_sbits(&s->gb, 8) * (1 << 8);
1379  av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
1380  }
1381  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1382  }
1383  for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1384  }
1385 
1386  return 0;
1387 }
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:77
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:55
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:267
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:205
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:495
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
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:266
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:265
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:39
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:42
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:56
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
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:1397
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:264
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:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:228
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:108
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:87
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:59
val
static double val(void *priv, double ch)
Definition: aeval.c:78
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:479
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:89
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:205
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: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:48
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:188
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: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:260
ff_mpeg1_dc_scale_table
static const uint8_t *const ff_mpeg1_dc_scale_table
Definition: mpegvideodata.h:32
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:320
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
cbpc_b_vlc
static VLCElem cbpc_b_vlc[8]
Definition: ituh263dec.c:107
tab_size
#define tab_size
Definition: ituh263dec.c:720
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:156
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:45
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:876
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:58
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1090
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:652
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:268
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:73
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:476
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
shift
static int shift(int a, int b)
Definition: bonk.c:261
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_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:50
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:165
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
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:413
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:72
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: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
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:57
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:233
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:371
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:695
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:36
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:83
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:606
mpeg4videodefs.h
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:477
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:561
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: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:371
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:700
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:259
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
mpeg4video.h
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
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:270
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
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
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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:478
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:387
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
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:141
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:263
imgutils.h
MB_TYPE_DIRECT2
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:47
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:35
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
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
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:61
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263dec.h:37
h263.h