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