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,
73  ff_h261_mtype_map, 2, 2, 0);
75  &ff_h261_mv_tab[0][1], 2, 1,
76  &ff_h261_mv_tab[0][0], 2, 1, 0);
78  &ff_h261_cbp_tab[0][1], 2, 1,
79  &ff_h261_cbp_tab[0][0], 2, 1, 0);
81 }
82 
84 {
85  static AVOnce init_static_once = AV_ONCE_INIT;
86  H261DecContext *const h = avctx->priv_data;
87  MpegEncContext *const s = &h->s;
88  int ret;
89 
90  avctx->framerate = (AVRational) { 30000, 1001 };
91 
92  s->private_ctx = &h->common;
93  // set defaults
94  ret = ff_mpv_decode_init(s, avctx);
95  if (ret < 0)
96  return ret;
97 
98  s->out_format = FMT_H261;
99  s->low_delay = 1;
100  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
101 
102  ff_thread_once(&init_static_once, h261_decode_init_static);
103 
104  return 0;
105 }
106 
107 static inline void h261_init_dest(MpegEncContext *s)
108 {
109  const unsigned block_size = 8 >> s->avctx->lowres;
111  s->dest[0] += 2 * block_size;
112  s->dest[1] += block_size;
113  s->dest[2] += block_size;
114 }
115 
116 /**
117  * Decode the group of blocks header or slice header.
118  * @return <0 if an error occurred
119  */
121 {
122  unsigned int val;
123  MpegEncContext *const s = &h->s;
124 
125  if (!h->gob_start_code_skipped) {
126  /* Check for GOB Start Code */
127  val = show_bits(&s->gb, 15);
128  if (val)
129  return -1;
130 
131  /* We have a GBSC */
132  skip_bits(&s->gb, 16);
133  }
134 
135  h->gob_start_code_skipped = 0;
136 
137  h->gob_number = get_bits(&s->gb, 4); /* GN */
138  s->qscale = get_bits(&s->gb, 5); /* GQUANT */
139 
140  /* Check if gob_number is valid */
141  if (s->mb_height == 18) { // CIF
142  if ((h->gob_number <= 0) || (h->gob_number > 12))
143  return -1;
144  } else { // QCIF
145  if ((h->gob_number != 1) && (h->gob_number != 3) &&
146  (h->gob_number != 5))
147  return -1;
148  }
149 
150  /* GEI */
151  if (skip_1stop_8data_bits(&s->gb) < 0)
152  return AVERROR_INVALIDDATA;
153 
154  if (s->qscale == 0) {
155  av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
156  if (s->avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
157  return -1;
158  }
159 
160  /* For the first transmitted macroblock in a GOB, MBA is the absolute
161  * address. For subsequent macroblocks, MBA is the difference between
162  * the absolute addresses of the macroblock and the last transmitted
163  * macroblock. */
164  h->current_mba = 0;
165  h->mba_diff = 0;
166 
167  return 0;
168 }
169 
170 /**
171  * Decode skipped macroblocks.
172  * @return 0
173  */
174 static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2)
175 {
176  MpegEncContext *const s = &h->s;
177  int i;
178 
179  s->mb_intra = 0;
180 
181  for (i = mba1; i < mba2; i++) {
182  int j, xy;
183 
184  s->mb_x = ((h->gob_number - 1) % 2) * 11 + i % 11;
185  s->mb_y = ((h->gob_number - 1) / 2) * 3 + i / 11;
186  xy = s->mb_x + s->mb_y * s->mb_stride;
187  h261_init_dest(s);
188 
189  for (j = 0; j < 6; j++)
190  s->block_last_index[j] = -1;
191 
192  s->mv_dir = MV_DIR_FORWARD;
193  s->mv_type = MV_TYPE_16X16;
194  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
195  s->mv[0][0][0] = 0;
196  s->mv[0][0][1] = 0;
197  s->mb_skipped = 1;
198  h->common.mtype &= ~MB_TYPE_H261_FIL;
199 
200  if (s->cur_pic.motion_val[0]) {
201  int b_stride = 2*s->mb_width + 1;
202  int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
203  s->cur_pic.motion_val[0][b_xy][0] = s->mv[0][0][0];
204  s->cur_pic.motion_val[0][b_xy][1] = s->mv[0][0][1];
205  }
206 
207  ff_mpv_reconstruct_mb(s, s->block);
208  }
209 
210  return 0;
211 }
212 
213 static int decode_mv_component(GetBitContext *gb, int v)
214 {
215  int mv_diff = get_vlc2(gb, h261_mv_vlc, H261_MV_VLC_BITS, 2);
216 
217  /* check if mv_diff is valid */
218  if (mv_diff < 0)
219  return v;
220 
221  if (mv_diff && get_bits1(gb))
222  mv_diff = -mv_diff;
223 
224  v += mv_diff;
225  if (v <= -16)
226  v += 32;
227  else if (v >= 16)
228  v -= 32;
229 
230  return v;
231 }
232 
233 /**
234  * Decode a macroblock.
235  * @return <0 if an error occurred
236  */
237 static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded)
238 {
239  MpegEncContext *const s = &h->s;
240  int level, i, j, run;
241  const RLTable *rl = &ff_h261_rl_tcoeff;
242  const uint8_t *scan_table;
243  const int qmul = s->qscale << 1, qadd = (s->qscale - 1) | 1;
244 
245  /* For the variable length encoding there are two code tables, one being
246  * used for the first transmitted LEVEL in INTER, INTER + MC and
247  * INTER + MC + FIL blocks, the second for all other LEVELs except the
248  * first one in INTRA blocks which is fixed length coded with 8 bits.
249  * NOTE: The two code tables only differ in one VLC so we handle that
250  * manually. */
251  scan_table = s->intra_scantable.permutated;
252  if (s->mb_intra) {
253  /* DC coef */
254  level = get_bits(&s->gb, 8);
255  // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
256  if ((level & 0x7F) == 0) {
257  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
258  level, s->mb_x, s->mb_y);
259  return -1;
260  }
261  /* The code 1000 0000 is not used, the reconstruction level of 1024
262  * being coded as 1111 1111. */
263  if (level == 255)
264  level = 128;
265  block[0] = level * s->y_dc_scale;
266  i = 1;
267  } else if (coded) {
268  // Run Level Code
269  // EOB Not possible for first level when cbp is available (that's why the table is different)
270  // 0 1 1s
271  // * * 0*
272  int check = show_bits(&s->gb, 2);
273  i = 0;
274  if (check & 0x2) {
275  skip_bits(&s->gb, 2);
276  block[0] = qmul + qadd;
277  block[0] *= (check & 0x1) ? -1 : 1;
278  i = 1;
279  }
280  } else {
281  i = 0;
282  }
283  if (!coded) {
284  s->block_last_index[n] = i - 1;
285  return 0;
286  }
287  {
288  OPEN_READER(re, &s->gb);
289  i--; // offset by -1 to allow direct indexing of scan_table
290  for (;;) {
291  UPDATE_CACHE(re, &s->gb);
292  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TCOEFF_VLC_BITS, 2, 0);
293  if (run == 66) {
294  if (level) {
295  CLOSE_READER(re, &s->gb);
296  av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
297  s->mb_x, s->mb_y);
298  return -1;
299  }
300  /* escape */
301  /* The remaining combinations of (run, level) are encoded with a
302  * 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits
303  * level. */
304  run = SHOW_UBITS(re, &s->gb, 6) + 1;
305  SKIP_CACHE(re, &s->gb, 6);
306  level = SHOW_SBITS(re, &s->gb, 8);
307  if (level > 0)
308  level = level * qmul + qadd;
309  else if (level < 0)
310  level = level * qmul - qadd;
311  SKIP_COUNTER(re, &s->gb, 6 + 8);
312  } else if (level == 0) {
313  break;
314  } else {
315  level = level * qmul + qadd;
316  if (SHOW_UBITS(re, &s->gb, 1))
317  level = -level;
318  SKIP_COUNTER(re, &s->gb, 1);
319  }
320  i += run;
321  if (i >= 64) {
322  CLOSE_READER(re, &s->gb);
323  av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
324  s->mb_x, s->mb_y);
325  return -1;
326  }
327  j = scan_table[i];
328  block[j] = level;
329  }
330  CLOSE_READER(re, &s->gb);
331  }
332  s->block_last_index[n] = i;
333  return 0;
334 }
335 
337 {
338  MpegEncContext *const s = &h->s;
339  H261Context *const com = &h->common;
340  int i, cbp, xy;
341 
342  cbp = 63;
343  // Read mba
344  do {
345  h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc,
346  H261_MBA_VLC_BITS, 2);
347 
348  /* Check for slice end */
349  /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
350  if (h->mba_diff == MBA_STARTCODE) { // start code
351  h->gob_start_code_skipped = 1;
352  return SLICE_END;
353  }
354  } while (h->mba_diff == MBA_STUFFING); // stuffing
355 
356  if (h->mba_diff < 0) {
357  if (get_bits_left(&s->gb) <= 7)
358  return SLICE_END;
359 
360  av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
361  return SLICE_ERROR;
362  }
363 
364  h->mba_diff += 1;
365  h->current_mba += h->mba_diff;
366 
367  if (h->current_mba > MBA_STUFFING)
368  return SLICE_ERROR;
369 
370  s->mb_x = ((h->gob_number - 1) % 2) * 11 + ((h->current_mba - 1) % 11);
371  s->mb_y = ((h->gob_number - 1) / 2) * 3 + ((h->current_mba - 1) / 11);
372  xy = s->mb_x + s->mb_y * s->mb_stride;
373  h261_init_dest(s);
374 
375  // Read mtype
377  if (com->mtype < 0) {
378  av_log(s->avctx, AV_LOG_ERROR, "Invalid mtype index\n");
379  return SLICE_ERROR;
380  }
381 
382  // Read mquant
383  if (IS_QUANT(com->mtype))
384  ff_set_qscale(s, get_bits(&s->gb, 5));
385 
386  s->mb_intra = IS_INTRA4x4(com->mtype);
387 
388  // Read mv
389  if (IS_16X16(com->mtype)) {
390  /* Motion vector data is included for all MC macroblocks. MVD is
391  * obtained from the macroblock vector by subtracting the vector
392  * of the preceding macroblock. For this calculation the vector
393  * of the preceding macroblock is regarded as zero in the
394  * following three situations:
395  * 1) evaluating MVD for macroblocks 1, 12 and 23;
396  * 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
397  * 3) MTYPE of the previous macroblock was not MC. */
398  if ((h->current_mba == 1) || (h->current_mba == 12) ||
399  (h->current_mba == 23) || (h->mba_diff != 1)) {
400  h->current_mv_x = 0;
401  h->current_mv_y = 0;
402  }
403 
404  h->current_mv_x = decode_mv_component(&s->gb, h->current_mv_x);
405  h->current_mv_y = decode_mv_component(&s->gb, h->current_mv_y);
406  } else {
407  h->current_mv_x = 0;
408  h->current_mv_y = 0;
409  }
410 
411  // Read cbp
412  if (HAS_CBP(com->mtype))
413  cbp = get_vlc2(&s->gb, h261_cbp_vlc, H261_CBP_VLC_BITS, 1) + 1;
414 
415  if (s->mb_intra) {
416  s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
417  goto intra;
418  }
419 
420  //set motion vectors
421  s->mv_dir = MV_DIR_FORWARD;
422  s->mv_type = MV_TYPE_16X16;
423  s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
424  s->mv[0][0][0] = h->current_mv_x * 2; // gets divided by 2 in motion compensation
425  s->mv[0][0][1] = h->current_mv_y * 2;
426 
427  if (s->cur_pic.motion_val[0]) {
428  int b_stride = 2*s->mb_width + 1;
429  int b_xy = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
430  s->cur_pic.motion_val[0][b_xy][0] = s->mv[0][0][0];
431  s->cur_pic.motion_val[0][b_xy][1] = s->mv[0][0][1];
432  }
433 
434 intra:
435  /* decode each block */
436  if (s->mb_intra || HAS_CBP(com->mtype)) {
437  s->bdsp.clear_blocks(s->block[0]);
438  for (i = 0; i < 6; i++) {
439  if (h261_decode_block(h, s->block[i], i, cbp & 32) < 0)
440  return SLICE_ERROR;
441  cbp += cbp;
442  }
443  } else {
444  for (i = 0; i < 6; i++)
445  s->block_last_index[i] = -1;
446  }
447 
448  ff_mpv_reconstruct_mb(s, s->block);
449 
450  return SLICE_OK;
451 }
452 
453 /**
454  * Decode the H.261 picture header.
455  * @return <0 if no startcode found
456  */
458 {
459  MpegEncContext *const s = &h->s;
460  int format, i;
461  uint32_t startcode = 0;
462 
463  for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
464  startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
465 
466  if (startcode == 0x10)
467  break;
468  }
469 
470  if (startcode != 0x10) {
471  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
472  return -1;
473  }
474 
475  /* temporal reference */
476  skip_bits(&s->gb, 5); /* picture timestamp */
477 
478  /* PTYPE starts here */
479  skip_bits1(&s->gb); /* split screen off */
480  skip_bits1(&s->gb); /* camera off */
481  skip_bits1(&s->gb); /* freeze picture release off */
482 
483  format = get_bits1(&s->gb);
484 
485  // only 2 formats possible
486  if (format == 0) { // QCIF
487  s->width = 176;
488  s->height = 144;
489  } else { // CIF
490  s->width = 352;
491  s->height = 288;
492  }
493 
494  skip_bits1(&s->gb); /* still image mode off */
495  skip_bits1(&s->gb); /* Reserved */
496 
497  /* PEI */
498  if (skip_1stop_8data_bits(&s->gb) < 0)
499  return AVERROR_INVALIDDATA;
500 
501  /* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
502  * frame, the codec crashes if it does not contain all I-blocks
503  * (e.g. when a packet is lost). */
504  s->pict_type = AV_PICTURE_TYPE_P;
505 
506  h->gob_number = 0;
507  return 0;
508 }
509 
511 {
512  MpegEncContext *const s = &h->s;
513 
514  ff_set_qscale(s, s->qscale);
515 
516  /* decode mb's */
517  while (h->current_mba <= MBA_STUFFING) {
518  int ret;
519  /* DCT & quantize */
520  ret = h261_decode_mb(h);
521  if (ret < 0) {
522  if (ret == SLICE_END) {
523  h261_decode_mb_skipped(h, h->current_mba, 33);
524  return 0;
525  }
526  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n",
527  s->mb_x + s->mb_y * s->mb_stride);
528  return -1;
529  }
530 
532  h->current_mba - h->mba_diff,
533  h->current_mba - 1);
534  }
535 
536  return -1;
537 }
538 
539 /**
540  * returns the number of bytes consumed for building the current frame
541  */
542 static int get_consumed_bytes(MpegEncContext *s, int buf_size)
543 {
544  int pos = get_bits_count(&s->gb) >> 3;
545  if (pos == 0)
546  pos = 1; // avoid infinite loops (i doubt that is needed but ...)
547  if (pos + 10 > buf_size)
548  pos = buf_size; // oops ;)
549 
550  return pos;
551 }
552 
553 static int h261_decode_frame(AVCodecContext *avctx, AVFrame *pict,
554  int *got_frame, AVPacket *avpkt)
555 {
556  H261DecContext *const h = avctx->priv_data;
557  const uint8_t *buf = avpkt->data;
558  int buf_size = avpkt->size;
559  MpegEncContext *s = &h->s;
560  int ret;
561 
562  ff_dlog(avctx, "*****frame %"PRId64" size=%d\n", avctx->frame_num, buf_size);
563  ff_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
564 
565  h->gob_start_code_skipped = 0;
566 
567  init_get_bits(&s->gb, buf, buf_size * 8);
568 
570 
571  /* skip if the header was thrashed */
572  if (ret < 0) {
573  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
574  return -1;
575  }
576 
577  if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
579  }
580 
581  if (!s->context_initialized) {
582  if ((ret = ff_mpv_common_init(s)) < 0)
583  return ret;
584 
585  ret = ff_set_dimensions(avctx, s->width, s->height);
586  if (ret < 0)
587  return ret;
588  }
589 
590  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
591  (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
592  avctx->skip_frame >= AVDISCARD_ALL)
593  return buf_size;
594 
595  if (ff_mpv_frame_start(s, avctx) < 0)
596  return -1;
597 
599 
600  /* decode each macroblock */
601  s->mb_x = 0;
602  s->mb_y = 0;
603 
604  while (h->gob_number < (s->mb_height == 18 ? 12 : 5)) {
605  if (h261_decode_gob_header(h) < 0)
606  break;
608  }
610 
611  av_assert0(s->pict_type == s->cur_pic.ptr->f->pict_type);
612 
613  if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)
614  return ret;
615  ff_print_debug_info(s, s->cur_pic.ptr, pict);
616 
617  *got_frame = 1;
618 
619  return get_consumed_bytes(s, buf_size);
620 }
621 
623  .p.name = "h261",
624  CODEC_LONG_NAME("H.261"),
625  .p.type = AVMEDIA_TYPE_VIDEO,
626  .p.id = AV_CODEC_ID_H261,
627  .priv_data_size = sizeof(H261DecContext),
630  .close = ff_mpv_decode_close,
631  .p.capabilities = AV_CODEC_CAP_DR1,
632  .p.max_lowres = 3,
633 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:687
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:70
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:265
H261_MV_VLC_BITS
#define H261_MV_VLC_BITS
Definition: h261dec.c:41
level
uint8_t level
Definition: svq3.c:205
MBA_STARTCODE
#define MBA_STARTCODE
Definition: h261dec.c:45
h261_decode_mb
static int h261_decode_mb(H261DecContext *h)
Definition: h261dec.c:336
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
H261Context::mtype
int mtype
Definition: h261.h:39
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:389
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:539
H261_MBA_VLC_BITS
#define H261_MBA_VLC_BITS
Definition: h261dec.c:39
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:42
FFCodec
Definition: codec_internal.h:127
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:820
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
FMT_H261
@ FMT_H261
Definition: mpegvideo.h:64
h261_decode_picture_header
static int h261_decode_picture_header(H261DecContext *h)
Decode the H.261 picture header.
Definition: h261dec.c:457
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:120
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:542
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
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_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:910
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:1830
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
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:482
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:88
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:774
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:209
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:93
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:83
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
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:237
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:49
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
decode.h
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:296
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
run
uint8_t run
Definition: svq3.c:204
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:853
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:220
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
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:400
codec_internal.h
VLCElem
Definition: vlc.h:32
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
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:344
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:174
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:81
H261Context
H261Context.
Definition: h261.h:38
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:107
h261_decode_frame
static int h261_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h261dec.c:553
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:403
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:256
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:86
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:663
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:258
avcodec.h
ff_h261_decoder
const FFCodec ff_h261_decoder
Definition: h261dec.c:622
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:2041
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:480
ff_mpv_decode_init
int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:46
h261_mba_vlc
static VLCElem h261_mba_vlc[540]
Definition: h261dec.c:47
pos
unsigned int pos
Definition: spdifenc.c:414
h261_mv_vlc
static VLCElem h261_mv_vlc[144]
Definition: h261dec.c:49
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:700
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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
ff_h261_mtype_map
const uint16_t ff_h261_mtype_map[10]
Definition: h261data.c:75
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:270
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:395
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
h261_decode_gob
static int h261_decode_gob(H261DecContext *h)
Definition: h261dec.c:510
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:481
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:261
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
decode_mv_component
static int decode_mv_component(GetBitContext *gb, int v)
Definition: h261dec.c:213
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:2070
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:217
ff_h261_mba_bits
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
H261DecContext
Definition: h261dec.c:52
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:50
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
ff_mpv_decode_close
int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:163
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:65
MB_TYPE_H261_FIL
#define MB_TYPE_H261_FIL
Definition: h261.h:42