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