FFmpeg
h261dec.c
Go to the documentation of this file.
1 /*
2  * H.261 decoder
3  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4  * Copyright (c) 2004 Maarten Daniels
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * H.261 decoder.
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/thread.h"
30 #include "avcodec.h"
31 #include "codec_internal.h"
32 #include "decode.h"
33 #include "mpeg_er.h"
34 #include "mpegutils.h"
35 #include "mpegvideo.h"
36 #include "mpegvideodec.h"
37 #include "h261.h"
38 
39 #define H261_MBA_VLC_BITS 8
40 #define H261_MTYPE_VLC_BITS 6
41 #define H261_MV_VLC_BITS 7
42 #define H261_CBP_VLC_BITS 9
43 #define TCOEFF_VLC_BITS 9
44 #define MBA_STUFFING 33
45 #define MBA_STARTCODE 34
46 
47 static VLCElem h261_mba_vlc[540];
49 static VLCElem h261_mv_vlc[144];
50 static VLCElem h261_cbp_vlc[512];
51 
52 typedef struct H261DecContext {
54 
56 
58  int mba_diff;
62  int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
64 
66 {
68  ff_h261_mba_bits, 1, 1,
69  ff_h261_mba_code, 1, 1, 0);
71  ff_h261_mtype_bits, 1, 1,
72  ff_h261_mtype_code, 1, 1, 0);
74  &ff_h261_mv_tab[0][1], 2, 1,
75  &ff_h261_mv_tab[0][0], 2, 1, 0);
77  &ff_h261_cbp_tab[0][1], 2, 1,
78  &ff_h261_cbp_tab[0][0], 2, 1, 0);
80 }
81 
83 {
84  static AVOnce init_static_once = AV_ONCE_INIT;
85  H261DecContext *const h = avctx->priv_data;
86  MpegEncContext *const s = &h->s;
87 
88  s->private_ctx = &h->common;
89  // set defaults
90  ff_mpv_decode_init(s, avctx);
91 
92  s->out_format = FMT_H261;
93  s->low_delay = 1;
94  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
95 
96  h->gob_start_code_skipped = 0;
97 
98  ff_thread_once(&init_static_once, h261_decode_init_static);
99 
100  return 0;
101 }
102 
103 static inline void h261_init_dest(MpegEncContext *s)
104 {
105  const unsigned block_size = 8 >> s->avctx->lowres;
107  s->dest[0] += 2 * block_size;
108  s->dest[1] += block_size;
109  s->dest[2] += block_size;
110 }
111 
112 /**
113  * Decode the group of blocks header or slice header.
114  * @return <0 if an error occurred
115  */
117 {
118  unsigned int val;
119  MpegEncContext *const s = &h->s;
120 
121  if (!h->gob_start_code_skipped) {
122  /* Check for GOB Start Code */
123  val = show_bits(&s->gb, 15);
124  if (val)
125  return -1;
126 
127  /* We have a GBSC */
128  skip_bits(&s->gb, 16);
129  }
130 
131  h->gob_start_code_skipped = 0;
132 
133  h->gob_number = get_bits(&s->gb, 4); /* GN */
134  s->qscale = get_bits(&s->gb, 5); /* GQUANT */
135 
136  /* Check if gob_number is valid */
137  if (s->mb_height == 18) { // CIF
138  if ((h->gob_number <= 0) || (h->gob_number > 12))
139  return -1;
140  } else { // QCIF
141  if ((h->gob_number != 1) && (h->gob_number != 3) &&
142  (h->gob_number != 5))
143  return -1;
144  }
145 
146  /* GEI */
147  if (skip_1stop_8data_bits(&s->gb) < 0)
148  return AVERROR_INVALIDDATA;
149 
150  if (s->qscale == 0) {
151  av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
152  if (s->avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
153  return -1;
154  }
155 
156  /* For the first transmitted macroblock in a GOB, MBA is the absolute
157  * address. For subsequent macroblocks, MBA is the difference between
158  * the absolute addresses of the macroblock and the last transmitted
159  * macroblock. */
160  h->current_mba = 0;
161  h->mba_diff = 0;
162 
163  return 0;
164 }
165 
166 /**
167  * Decode the group of blocks / video packet header.
168  * @return <0 if no resync found
169  */
171 {
172  MpegEncContext *const s = &h->s;
173  int left, ret;
174 
175  if (h->gob_start_code_skipped) {
177  if (ret >= 0)
178  return 0;
179  } else {
180  if (show_bits(&s->gb, 15) == 0) {
182  if (ret >= 0)
183  return 0;
184  }
185  // OK, it is not where it is supposed to be ...
186  s->gb = s->last_resync_gb;
187  align_get_bits(&s->gb);
188  left = get_bits_left(&s->gb);
189 
190  for (; left > 15 + 1 + 4 + 5; left -= 8) {
191  if (show_bits(&s->gb, 15) == 0) {
192  GetBitContext bak = s->gb;
193 
195  if (ret >= 0)
196  return 0;
197 
198  s->gb = bak;
199  }
200  skip_bits(&s->gb, 8);
201  }
202  }
203 
204  return -1;
205 }
206 
207 /**
208  * Decode skipped macroblocks.
209  * @return 0
210  */
211 static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2)
212 {
213  MpegEncContext *const s = &h->s;
214  int i;
215 
216  s->mb_intra = 0;
217 
218  for (i = mba1; i < mba2; i++) {
219  int j, xy;
220 
221  s->mb_x = ((h->gob_number - 1) % 2) * 11 + i % 11;
222  s->mb_y = ((h->gob_number - 1) / 2) * 3 + i / 11;
223  xy = s->mb_x + s->mb_y * s->mb_stride;
224  h261_init_dest(s);
225 
226  for (j = 0; j < 6; j++)
227  s->block_last_index[j] = -1;
228 
229  s->mv_dir = MV_DIR_FORWARD;
230  s->mv_type = MV_TYPE_16X16;
231  s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
232  s->mv[0][0][0] = 0;
233  s->mv[0][0][1] = 0;
234  s->mb_skipped = 1;
235  h->common.mtype &= ~MB_TYPE_H261_FIL;
236 
237  if (s->current_picture.motion_val[0]) {
238  int b_stride = 2*s->mb_width + 1;
239  int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
240  s->current_picture.motion_val[0][b_xy][0] = s->mv[0][0][0];
241  s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];
242  }
243 
244  ff_mpv_reconstruct_mb(s, s->block);
245  }
246 
247  return 0;
248 }
249 
250 static const int mvmap[17] = {
251  0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
252 };
253 
254 static int decode_mv_component(GetBitContext *gb, int v)
255 {
256  int mv_diff = get_vlc2(gb, h261_mv_vlc, H261_MV_VLC_BITS, 2);
257 
258  /* check if mv_diff is valid */
259  if (mv_diff < 0)
260  return v;
261 
262  mv_diff = mvmap[mv_diff];
263 
264  if (mv_diff && !get_bits1(gb))
265  mv_diff = -mv_diff;
266 
267  v += mv_diff;
268  if (v <= -16)
269  v += 32;
270  else if (v >= 16)
271  v -= 32;
272 
273  return v;
274 }
275 
276 /**
277  * Decode a macroblock.
278  * @return <0 if an error occurred
279  */
280 static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded)
281 {
282  MpegEncContext *const s = &h->s;
283  int level, i, j, run;
284  RLTable *rl = &ff_h261_rl_tcoeff;
285  const uint8_t *scan_table;
286 
287  /* For the variable length encoding there are two code tables, one being
288  * used for the first transmitted LEVEL in INTER, INTER + MC and
289  * INTER + MC + FIL blocks, the second for all other LEVELs except the
290  * first one in INTRA blocks which is fixed length coded with 8 bits.
291  * NOTE: The two code tables only differ in one VLC so we handle that
292  * manually. */
293  scan_table = s->intra_scantable.permutated;
294  if (s->mb_intra) {
295  /* DC coef */
296  level = get_bits(&s->gb, 8);
297  // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
298  if ((level & 0x7F) == 0) {
299  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
300  level, s->mb_x, s->mb_y);
301  return -1;
302  }
303  /* The code 1000 0000 is not used, the reconstruction level of 1024
304  * being coded as 1111 1111. */
305  if (level == 255)
306  level = 128;
307  block[0] = level;
308  i = 1;
309  } else if (coded) {
310  // Run Level Code
311  // EOB Not possible for first level when cbp is available (that's why the table is different)
312  // 0 1 1s
313  // * * 0*
314  int check = show_bits(&s->gb, 2);
315  i = 0;
316  if (check & 0x2) {
317  skip_bits(&s->gb, 2);
318  block[0] = (check & 0x1) ? -1 : 1;
319  i = 1;
320  }
321  } else {
322  i = 0;
323  }
324  if (!coded) {
325  s->block_last_index[n] = i - 1;
326  return 0;
327  }
328  {
329  OPEN_READER(re, &s->gb);
330  i--; // offset by -1 to allow direct indexing of scan_table
331  for (;;) {
332  UPDATE_CACHE(re, &s->gb);
333  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TCOEFF_VLC_BITS, 2, 0);
334  if (run == 66) {
335  if (level) {
336  CLOSE_READER(re, &s->gb);
337  av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
338  s->mb_x, s->mb_y);
339  return -1;
340  }
341  /* escape */
342  /* The remaining combinations of (run, level) are encoded with a
343  * 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits
344  * level. */
345  run = SHOW_UBITS(re, &s->gb, 6) + 1;
346  SKIP_CACHE(re, &s->gb, 6);
347  level = SHOW_SBITS(re, &s->gb, 8);
348  SKIP_COUNTER(re, &s->gb, 6 + 8);
349  } else if (level == 0) {
350  break;
351  } else {
352  if (SHOW_UBITS(re, &s->gb, 1))
353  level = -level;
354  SKIP_COUNTER(re, &s->gb, 1);
355  }
356  i += run;
357  if (i >= 64) {
358  CLOSE_READER(re, &s->gb);
359  av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
360  s->mb_x, s->mb_y);
361  return -1;
362  }
363  j = scan_table[i];
364  block[j] = level;
365  }
366  CLOSE_READER(re, &s->gb);
367  }
368  s->block_last_index[n] = i;
369  return 0;
370 }
371 
373 {
374  MpegEncContext *const s = &h->s;
375  H261Context *const com = &h->common;
376  int i, cbp, xy;
377 
378  cbp = 63;
379  // Read mba
380  do {
381  h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc,
382  H261_MBA_VLC_BITS, 2);
383 
384  /* Check for slice end */
385  /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
386  if (h->mba_diff == MBA_STARTCODE) { // start code
387  h->gob_start_code_skipped = 1;
388  return SLICE_END;
389  }
390  } while (h->mba_diff == MBA_STUFFING); // stuffing
391 
392  if (h->mba_diff < 0) {
393  if (get_bits_left(&s->gb) <= 7)
394  return SLICE_END;
395 
396  av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
397  return SLICE_ERROR;
398  }
399 
400  h->mba_diff += 1;
401  h->current_mba += h->mba_diff;
402 
403  if (h->current_mba > MBA_STUFFING)
404  return SLICE_ERROR;
405 
406  s->mb_x = ((h->gob_number - 1) % 2) * 11 + ((h->current_mba - 1) % 11);
407  s->mb_y = ((h->gob_number - 1) / 2) * 3 + ((h->current_mba - 1) / 11);
408  xy = s->mb_x + s->mb_y * s->mb_stride;
409  h261_init_dest(s);
410 
411  // Read mtype
413  if (com->mtype < 0) {
414  av_log(s->avctx, AV_LOG_ERROR, "Invalid mtype index %d\n",
415  com->mtype);
416  return SLICE_ERROR;
417  }
419  com->mtype = ff_h261_mtype_map[com->mtype];
420 
421  // Read mquant
422  if (IS_QUANT(com->mtype))
423  ff_set_qscale(s, get_bits(&s->gb, 5));
424 
425  s->mb_intra = IS_INTRA4x4(com->mtype);
426 
427  // Read mv
428  if (IS_16X16(com->mtype)) {
429  /* Motion vector data is included for all MC macroblocks. MVD is
430  * obtained from the macroblock vector by subtracting the vector
431  * of the preceding macroblock. For this calculation the vector
432  * of the preceding macroblock is regarded as zero in the
433  * following three situations:
434  * 1) evaluating MVD for macroblocks 1, 12 and 23;
435  * 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
436  * 3) MTYPE of the previous macroblock was not MC. */
437  if ((h->current_mba == 1) || (h->current_mba == 12) ||
438  (h->current_mba == 23) || (h->mba_diff != 1)) {
439  h->current_mv_x = 0;
440  h->current_mv_y = 0;
441  }
442 
443  h->current_mv_x = decode_mv_component(&s->gb, h->current_mv_x);
444  h->current_mv_y = decode_mv_component(&s->gb, h->current_mv_y);
445  } else {
446  h->current_mv_x = 0;
447  h->current_mv_y = 0;
448  }
449 
450  // Read cbp
451  if (HAS_CBP(com->mtype))
452  cbp = get_vlc2(&s->gb, h261_cbp_vlc, H261_CBP_VLC_BITS, 1) + 1;
453 
454  if (s->mb_intra) {
455  s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
456  goto intra;
457  }
458 
459  //set motion vectors
460  s->mv_dir = MV_DIR_FORWARD;
461  s->mv_type = MV_TYPE_16X16;
462  s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
463  s->mv[0][0][0] = h->current_mv_x * 2; // gets divided by 2 in motion compensation
464  s->mv[0][0][1] = h->current_mv_y * 2;
465 
466  if (s->current_picture.motion_val[0]) {
467  int b_stride = 2*s->mb_width + 1;
468  int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
469  s->current_picture.motion_val[0][b_xy][0] = s->mv[0][0][0];
470  s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];
471  }
472 
473 intra:
474  /* decode each block */
475  if (s->mb_intra || HAS_CBP(com->mtype)) {
476  s->bdsp.clear_blocks(s->block[0]);
477  for (i = 0; i < 6; i++) {
478  if (h261_decode_block(h, s->block[i], i, cbp & 32) < 0)
479  return SLICE_ERROR;
480  cbp += cbp;
481  }
482  } else {
483  for (i = 0; i < 6; i++)
484  s->block_last_index[i] = -1;
485  }
486 
487  ff_mpv_reconstruct_mb(s, s->block);
488 
489  return SLICE_OK;
490 }
491 
492 /**
493  * Decode the H.261 picture header.
494  * @return <0 if no startcode found
495  */
497 {
498  MpegEncContext *const s = &h->s;
499  int format, i;
500  uint32_t startcode = 0;
501 
502  for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
503  startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
504 
505  if (startcode == 0x10)
506  break;
507  }
508 
509  if (startcode != 0x10) {
510  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
511  return -1;
512  }
513 
514  /* temporal reference */
515  skip_bits(&s->gb, 5); /* picture timestamp */
516 
517  s->avctx->framerate = (AVRational) { 30000, 1001 };
518 
519  /* PTYPE starts here */
520  skip_bits1(&s->gb); /* split screen off */
521  skip_bits1(&s->gb); /* camera off */
522  skip_bits1(&s->gb); /* freeze picture release off */
523 
524  format = get_bits1(&s->gb);
525 
526  // only 2 formats possible
527  if (format == 0) { // QCIF
528  s->width = 176;
529  s->height = 144;
530  } else { // CIF
531  s->width = 352;
532  s->height = 288;
533  }
534 
535  skip_bits1(&s->gb); /* still image mode off */
536  skip_bits1(&s->gb); /* Reserved */
537 
538  /* PEI */
539  if (skip_1stop_8data_bits(&s->gb) < 0)
540  return AVERROR_INVALIDDATA;
541 
542  /* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
543  * frame, the codec crashes if it does not contain all I-blocks
544  * (e.g. when a packet is lost). */
545  s->pict_type = AV_PICTURE_TYPE_P;
546 
547  h->gob_number = 0;
548  return 0;
549 }
550 
552 {
553  MpegEncContext *const s = &h->s;
554 
555  ff_set_qscale(s, s->qscale);
556 
557  /* decode mb's */
558  while (h->current_mba <= MBA_STUFFING) {
559  int ret;
560  /* DCT & quantize */
561  ret = h261_decode_mb(h);
562  if (ret < 0) {
563  if (ret == SLICE_END) {
564  h261_decode_mb_skipped(h, h->current_mba, 33);
565  return 0;
566  }
567  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n",
568  s->mb_x + s->mb_y * s->mb_stride);
569  return -1;
570  }
571 
573  h->current_mba - h->mba_diff,
574  h->current_mba - 1);
575  }
576 
577  return -1;
578 }
579 
580 /**
581  * returns the number of bytes consumed for building the current frame
582  */
583 static int get_consumed_bytes(MpegEncContext *s, int buf_size)
584 {
585  int pos = get_bits_count(&s->gb) >> 3;
586  if (pos == 0)
587  pos = 1; // avoid infinite loops (i doubt that is needed but ...)
588  if (pos + 10 > buf_size)
589  pos = buf_size; // oops ;)
590 
591  return pos;
592 }
593 
594 static int h261_decode_frame(AVCodecContext *avctx, AVFrame *pict,
595  int *got_frame, AVPacket *avpkt)
596 {
597  H261DecContext *const h = avctx->priv_data;
598  const uint8_t *buf = avpkt->data;
599  int buf_size = avpkt->size;
600  MpegEncContext *s = &h->s;
601  int ret;
602 
603  ff_dlog(avctx, "*****frame %"PRId64" size=%d\n", avctx->frame_num, buf_size);
604  ff_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
605 
606  h->gob_start_code_skipped = 0;
607 
608  init_get_bits(&s->gb, buf, buf_size * 8);
609 
611 
612  /* skip if the header was thrashed */
613  if (ret < 0) {
614  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
615  return -1;
616  }
617 
618  if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
620  }
621 
622  if (!s->context_initialized) {
623  if ((ret = ff_mpv_common_init(s)) < 0)
624  return ret;
625 
626  ret = ff_set_dimensions(avctx, s->width, s->height);
627  if (ret < 0)
628  return ret;
629  }
630 
631  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
632  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
633  avctx->skip_frame >= AVDISCARD_ALL)
634  return buf_size;
635 
636  if (ff_mpv_frame_start(s, avctx) < 0)
637  return -1;
638 
640 
641  /* decode each macroblock */
642  s->mb_x = 0;
643  s->mb_y = 0;
644 
645  while (h->gob_number < (s->mb_height == 18 ? 12 : 5)) {
646  if (h261_resync(h) < 0)
647  break;
649  }
651 
652  av_assert0(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
653  av_assert0(s->current_picture.f->pict_type == s->pict_type);
654 
655  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
656  return ret;
657  ff_print_debug_info(s, s->current_picture_ptr, pict);
658 
659  *got_frame = 1;
660 
661  return get_consumed_bytes(s, buf_size);
662 }
663 
665 {
666  H261DecContext *const h = avctx->priv_data;
667  MpegEncContext *s = &h->s;
668 
670  return 0;
671 }
672 
674  .p.name = "h261",
675  CODEC_LONG_NAME("H.261"),
676  .p.type = AVMEDIA_TYPE_VIDEO,
677  .p.id = AV_CODEC_ID_H261,
678  .priv_data_size = sizeof(H261DecContext),
680  .close = h261_decode_end,
682  .p.capabilities = AV_CODEC_CAP_DR1,
683  .p.max_lowres = 3,
684 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:681
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:68
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:60
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:261
H261_MV_VLC_BITS
#define H261_MV_VLC_BITS
Definition: h261dec.c:41
level
uint8_t level
Definition: svq3.c:204
MBA_STARTCODE
#define MBA_STARTCODE
Definition: h261dec.c:45
h261_decode_mb
static int h261_decode_mb(H261DecContext *h)
Definition: h261dec.c:372
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
H261Context::mtype
int mtype
Definition: h261.h:38
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
thread.h
H261_CBP_VLC_BITS
#define H261_CBP_VLC_BITS
Definition: h261dec.c:42
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
h261_cbp_vlc
static VLCElem h261_cbp_vlc[512]
Definition: h261dec.c:50
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
h261_decode_init_static
static av_cold void h261_decode_init_static(void)
Definition: h261dec.c:65
H261DecContext::current_mv_x
int current_mv_x
Definition: h261dec.c:59
AVPacket::data
uint8_t * data
Definition: packet.h:522
H261_MBA_VLC_BITS
#define H261_MBA_VLC_BITS
Definition: h261dec.c:39
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:47
FFCodec
Definition: codec_internal.h:127
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:845
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
h261_decode_picture_header
static int h261_decode_picture_header(H261DecContext *h)
Decode the H.261 picture header.
Definition: h261dec.c:496
mpegutils.h
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
h261_decode_gob_header
static int h261_decode_gob_header(H261DecContext *h)
Decode the group of blocks header or slice header.
Definition: h261dec.c:116
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:55
get_consumed_bytes
static int get_consumed_bytes(MpegEncContext *s, int buf_size)
returns the number of bytes consumed for building the current frame
Definition: h261dec.c:583
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
MBA_STUFFING
#define MBA_STUFFING
Definition: h261dec.c:44
ff_h261_mtype_map
const int ff_h261_mtype_map[10]
Definition: h261data.c:75
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:1008
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:228
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1819
h261.h
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
h261_resync
static int h261_resync(H261DecContext *h)
Decode the group of blocks / video packet header.
Definition: h261dec.c:170
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:498
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:473
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:94
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:782
avassert.h
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
check
#define check(x, y, S, v)
Definition: motion_est_template.c:405
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:188
h261_decode_init
static av_cold int h261_decode_init(AVCodecContext *avctx)
Definition: h261dec.c:82
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
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
h261_decode_block
static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded)
Decode a macroblock.
Definition: h261dec.c:280
ff_h261_mba_code
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:47
FMT_H261
@ FMT_H261
Definition: mpegutils.h:118
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
decode.h
h261_decode_end
static av_cold int h261_decode_end(AVCodecContext *avctx)
Definition: h261dec.c:664
ff_h261_mv_tab
const uint8_t ff_h261_mv_tab[17][2]
Definition: h261data.c:89
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
run
uint8_t run
Definition: svq3.c:203
H261DecContext::common
H261Context common
Definition: h261dec.c:55
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
H261DecContext::current_mv_y
int current_mv_y
Definition: h261dec.c:60
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:878
H261DecContext::gob_start_code_skipped
int gob_start_code_skipped
Definition: h261dec.c:62
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
h261_mtype_vlc
static VLCElem h261_mtype_vlc[80]
Definition: h261dec.c:48
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:523
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:312
codec_internal.h
VLCElem
Definition: vlc.h:32
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:55
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo_dec.c:295
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
h261_decode_mb_skipped
static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2)
Decode skipped macroblocks.
Definition: h261dec.c:211
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:79
H261Context
H261Context.
Definition: h261.h:37
H261_MTYPE_VLC_BITS
#define H261_MTYPE_VLC_BITS
Definition: h261dec.c:40
h261_init_dest
static void h261_init_dest(MpegEncContext *s)
Definition: h261dec.c:103
h261_decode_frame
static int h261_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h261dec.c:594
mvmap
static const int mvmap[17]
Definition: h261dec.c:250
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:233
ff_h261_cbp_tab
const uint8_t ff_h261_cbp_tab[63][2]
Definition: h261data.c:95
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:45
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:88
ff_h261_mtype_code
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
H261DecContext::current_mba
int current_mba
Definition: h261dec.c:57
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
ff_h261_decoder
const FFCodec ff_h261_decoder
Definition: h261dec.c:673
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:606
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2030
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:471
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
h261_mba_vlc
static VLCElem h261_mba_vlc[540]
Definition: h261dec.c:47
pos
unsigned int pos
Definition: spdifenc.c:413
h261_mv_vlc
static VLCElem h261_mv_vlc[144]
Definition: h261dec.c:49
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
ff_h261_rl_tcoeff
RLTable ff_h261_rl_tcoeff
Definition: h261data.c:150
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:699
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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
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:267
H261DecContext::mba_diff
int mba_diff
Definition: h261dec.c:58
ff_h261_mtype_bits
const uint8_t ff_h261_mtype_bits[10]
Definition: h261data.c:69
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:490
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
h261_decode_gob
static int h261_decode_gob(H261DecContext *h)
Definition: h261dec.c:551
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
H261DecContext::gob_number
int gob_number
Definition: h261dec.c:61
SLICE_ERROR
#define SLICE_ERROR
Definition: mpegvideo.h:472
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:257
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
decode_mv_component
static int decode_mv_component(GetBitContext *gb, int v)
Definition: h261dec.c:254
mpeg_er.h
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:215
ff_h261_mba_bits
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
H261DecContext
Definition: h261dec.c:52
TCOEFF_VLC_BITS
#define TCOEFF_VLC_BITS
Definition: h261dec.c:43
H261DecContext::s
MpegEncContext s
Definition: h261dec.c:53
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:66
MB_TYPE_H261_FIL
#define MB_TYPE_H261_FIL
Definition: h261.h:41