h261dec.c
Go to the documentation of this file.
1 /*
2  * H261 decoder
3  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4  * Copyright (c) 2004 Maarten Daniels
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include "dsputil.h"
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "h263.h"
32 #include "h261.h"
33 #include "h261data.h"
34 
35 #define H261_MBA_VLC_BITS 9
36 #define H261_MTYPE_VLC_BITS 6
37 #define H261_MV_VLC_BITS 7
38 #define H261_CBP_VLC_BITS 9
39 #define TCOEFF_VLC_BITS 9
40 #define MBA_STUFFING 33
41 #define MBA_STARTCODE 34
42 
43 extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
44 
49 
50 static int h261_decode_block(H261Context * h, DCTELEM * block, int n, int coded);
51 
53  static int done = 0;
54 
55  if(!done){
56  done = 1;
57  INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
58  h261_mba_bits, 1, 1,
59  h261_mba_code, 1, 1, 662);
60  INIT_VLC_STATIC(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
61  h261_mtype_bits, 1, 1,
62  h261_mtype_code, 1, 1, 80);
63  INIT_VLC_STATIC(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
64  &h261_mv_tab[0][1], 2, 1,
65  &h261_mv_tab[0][0], 2, 1, 144);
66  INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
67  &h261_cbp_tab[0][1], 2, 1,
68  &h261_cbp_tab[0][0], 2, 1, 512);
71  }
72 }
73 
75  H261Context *h= avctx->priv_data;
76  MpegEncContext * const s = &h->s;
77 
78  // set defaults
80  s->avctx = avctx;
81 
82  s->width = s->avctx->coded_width;
83  s->height = s->avctx->coded_height;
84  s->codec_id = s->avctx->codec->id;
85 
86  s->out_format = FMT_H261;
87  s->low_delay= 1;
88  avctx->pix_fmt= PIX_FMT_YUV420P;
89 
90  s->codec_id= avctx->codec->id;
91 
93 
95 
96  return 0;
97 }
98 
104  unsigned int val;
105  MpegEncContext * const s = &h->s;
106 
107  if ( !h->gob_start_code_skipped ){
108  /* Check for GOB Start Code */
109  val = show_bits(&s->gb, 15);
110  if(val)
111  return -1;
112 
113  /* We have a GBSC */
114  skip_bits(&s->gb, 16);
115  }
116 
117  h->gob_start_code_skipped = 0;
118 
119  h->gob_number = get_bits(&s->gb, 4); /* GN */
120  s->qscale = get_bits(&s->gb, 5); /* GQUANT */
121 
122  /* Check if gob_number is valid */
123  if (s->mb_height==18){ //cif
124  if ((h->gob_number<=0) || (h->gob_number>12))
125  return -1;
126  }
127  else{ //qcif
128  if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
129  return -1;
130  }
131 
132  /* GEI */
133  while (get_bits1(&s->gb) != 0) {
134  skip_bits(&s->gb, 8);
135  }
136 
137  if(s->qscale==0) {
138  av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
140  return -1;
141  }
142 
143  // For the first transmitted macroblock in a GOB, MBA is the absolute address. For
144  // subsequent macroblocks, MBA is the difference between the absolute addresses of
145  // the macroblock and the last transmitted macroblock.
146  h->current_mba = 0;
147  h->mba_diff = 0;
148 
149  return 0;
150 }
151 
157  MpegEncContext * const s = &h->s;
158  int left, ret;
159 
160  if ( h->gob_start_code_skipped ){
161  ret= h261_decode_gob_header(h);
162  if(ret>=0)
163  return 0;
164  }
165  else{
166  if(show_bits(&s->gb, 15)==0){
167  ret= h261_decode_gob_header(h);
168  if(ret>=0)
169  return 0;
170  }
171  //OK, it is not where it is supposed to be ...
172  s->gb= s->last_resync_gb;
173  align_get_bits(&s->gb);
174  left= get_bits_left(&s->gb);
175 
176  for(;left>15+1+4+5; left-=8){
177  if(show_bits(&s->gb, 15)==0){
178  GetBitContext bak= s->gb;
179 
180  ret= h261_decode_gob_header(h);
181  if(ret>=0)
182  return 0;
183 
184  s->gb= bak;
185  }
186  skip_bits(&s->gb, 8);
187  }
188  }
189 
190  return -1;
191 }
192 
197 static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
198 {
199  MpegEncContext * const s = &h->s;
200  int i;
201 
202  s->mb_intra = 0;
203 
204  for(i=mba1; i<mba2; i++){
205  int j, xy;
206 
207  s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
208  s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
209  xy = s->mb_x + s->mb_y * s->mb_stride;
212 
213  for(j=0;j<6;j++)
214  s->block_last_index[j] = -1;
215 
216  s->mv_dir = MV_DIR_FORWARD;
217  s->mv_type = MV_TYPE_16X16;
219  s->mv[0][0][0] = 0;
220  s->mv[0][0][1] = 0;
221  s->mb_skipped = 1;
222  h->mtype &= ~MB_TYPE_H261_FIL;
223 
224  MPV_decode_mb(s, s->block);
225  }
226 
227  return 0;
228 }
229 
230 static int decode_mv_component(GetBitContext *gb, int v){
231  int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
232 
233  /* check if mv_diff is valid */
234  if ( mv_diff < 0 )
235  return v;
236 
237  mv_diff = mvmap[mv_diff];
238 
239  if(mv_diff && !get_bits1(gb))
240  mv_diff= -mv_diff;
241 
242  v += mv_diff;
243  if (v <=-16) v+= 32;
244  else if(v >= 16) v-= 32;
245 
246  return v;
247 }
248 
250  MpegEncContext * const s = &h->s;
251  int i, cbp, xy;
252 
253  cbp = 63;
254  // Read mba
255  do{
256  h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
257 
258  /* Check for slice end */
259  /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
260  if (h->mba_diff == MBA_STARTCODE){ // start code
261  h->gob_start_code_skipped = 1;
262  return SLICE_END;
263  }
264  }
265  while( h->mba_diff == MBA_STUFFING ); // stuffing
266 
267  if ( h->mba_diff < 0 ){
268  if (get_bits_left(&s->gb) <= 7)
269  return SLICE_END;
270 
271  av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
272  return SLICE_ERROR;
273  }
274 
275  h->mba_diff += 1;
276  h->current_mba += h->mba_diff;
277 
278  if ( h->current_mba > MBA_STUFFING )
279  return SLICE_ERROR;
280 
281  s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
282  s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
283  xy = s->mb_x + s->mb_y * s->mb_stride;
286 
287  // Read mtype
288  h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
289  h->mtype = h261_mtype_map[h->mtype];
290 
291  // Read mquant
292  if ( IS_QUANT ( h->mtype ) ){
293  ff_set_qscale(s, get_bits(&s->gb, 5));
294  }
295 
296  s->mb_intra = IS_INTRA4x4(h->mtype);
297 
298  // Read mv
299  if ( IS_16X16 ( h->mtype ) ){
300  // Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
301  // vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
302  // following three situations:
303  // 1) evaluating MVD for macroblocks 1, 12 and 23;
304  // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
305  // 3) MTYPE of the previous macroblock was not MC.
306  if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
307  ( h->mba_diff != 1))
308  {
309  h->current_mv_x = 0;
310  h->current_mv_y = 0;
311  }
312 
315  }else{
316  h->current_mv_x = 0;
317  h->current_mv_y = 0;
318  }
319 
320  // Read cbp
321  if ( HAS_CBP( h->mtype ) ){
322  cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
323  }
324 
325  if(s->mb_intra){
327  goto intra;
328  }
329 
330  //set motion vectors
331  s->mv_dir = MV_DIR_FORWARD;
332  s->mv_type = MV_TYPE_16X16;
334  s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
335  s->mv[0][0][1] = h->current_mv_y * 2;
336 
337 intra:
338  /* decode each block */
339  if(s->mb_intra || HAS_CBP(h->mtype)){
340  s->dsp.clear_blocks(s->block[0]);
341  for (i = 0; i < 6; i++) {
342  if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
343  return SLICE_ERROR;
344  }
345  cbp+=cbp;
346  }
347  }else{
348  for (i = 0; i < 6; i++)
349  s->block_last_index[i]= -1;
350  }
351 
352  MPV_decode_mb(s, s->block);
353 
354  return SLICE_OK;
355 }
356 
362  int n, int coded)
363 {
364  MpegEncContext * const s = &h->s;
365  int code, level, i, j, run;
366  RLTable *rl = &h261_rl_tcoeff;
367  const uint8_t *scan_table;
368 
369  // For the variable length encoding there are two code tables, one being used for
370  // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
371  // for all other LEVELs except the first one in INTRA blocks which is fixed length
372  // coded with 8 bits.
373  // NOTE: the two code tables only differ in one VLC so we handle that manually.
374  scan_table = s->intra_scantable.permutated;
375  if (s->mb_intra){
376  /* DC coef */
377  level = get_bits(&s->gb, 8);
378  // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
379  if((level&0x7F) == 0){
380  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
381  return -1;
382  }
383  // The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
384  if (level == 255)
385  level = 128;
386  block[0] = level;
387  i = 1;
388  }else if(coded){
389  // Run Level Code
390  // EOB Not possible for first level when cbp is available (that's why the table is different)
391  // 0 1 1s
392  // * * 0*
393  int check = show_bits(&s->gb, 2);
394  i = 0;
395  if ( check & 0x2 ){
396  skip_bits(&s->gb, 2);
397  block[0] = ( check & 0x1 ) ? -1 : 1;
398  i = 1;
399  }
400  }else{
401  i = 0;
402  }
403  if(!coded){
404  s->block_last_index[n] = i - 1;
405  return 0;
406  }
407  for(;;){
408  code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
409  if (code < 0){
410  av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
411  return -1;
412  }
413  if (code == rl->n) {
414  /* escape */
415  // The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
416  run = get_bits(&s->gb, 6);
417  level = get_sbits(&s->gb, 8);
418  }else if(code == 0){
419  break;
420  }else{
421  run = rl->table_run[code];
422  level = rl->table_level[code];
423  if (get_bits1(&s->gb))
424  level = -level;
425  }
426  i += run;
427  if (i >= 64){
428  av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
429  return -1;
430  }
431  j = scan_table[i];
432  block[j] = level;
433  i++;
434  }
435  s->block_last_index[n] = i-1;
436  return 0;
437 }
438 
444  MpegEncContext * const s = &h->s;
445  int format, i;
446  uint32_t startcode= 0;
447 
448  for(i= get_bits_left(&s->gb); i>24; i-=1){
449  startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
450 
451  if(startcode == 0x10)
452  break;
453  }
454 
455  if (startcode != 0x10){
456  av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
457  return -1;
458  }
459 
460  /* temporal reference */
461  i= get_bits(&s->gb, 5); /* picture timestamp */
462  if(i < (s->picture_number&31))
463  i += 32;
464  s->picture_number = (s->picture_number&~31) + i;
465 
466  s->avctx->time_base= (AVRational){1001, 30000};
468 
469 
470  /* PTYPE starts here */
471  skip_bits1(&s->gb); /* split screen off */
472  skip_bits1(&s->gb); /* camera off */
473  skip_bits1(&s->gb); /* freeze picture release off */
474 
475  format = get_bits1(&s->gb);
476 
477  //only 2 formats possible
478  if (format == 0){//QCIF
479  s->width = 176;
480  s->height = 144;
481  s->mb_width = 11;
482  s->mb_height = 9;
483  }else{//CIF
484  s->width = 352;
485  s->height = 288;
486  s->mb_width = 22;
487  s->mb_height = 18;
488  }
489 
490  s->mb_num = s->mb_width * s->mb_height;
491 
492  skip_bits1(&s->gb); /* still image mode off */
493  skip_bits1(&s->gb); /* Reserved */
494 
495  /* PEI */
496  while (get_bits1(&s->gb) != 0){
497  skip_bits(&s->gb, 8);
498  }
499 
500  // h261 has no I-FRAMES, but if we pass AV_PICTURE_TYPE_I for the first frame, the codec crashes if it does
501  // not contain all I-blocks (e.g. when a packet is lost)
503 
504  h->gob_number = 0;
505  return 0;
506 }
507 
509  MpegEncContext * const s = &h->s;
510 
511  ff_set_qscale(s, s->qscale);
512 
513  /* decode mb's */
514  while(h->current_mba <= MBA_STUFFING)
515  {
516  int ret;
517  /* DCT & quantize */
518  ret= h261_decode_mb(h);
519  if(ret<0){
520  if(ret==SLICE_END){
522  return 0;
523  }
524  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
525  return -1;
526  }
527 
529  }
530 
531  return -1;
532 }
533 
537 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
538  int pos= get_bits_count(&s->gb)>>3;
539  if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
540  if(pos+10>buf_size) pos=buf_size; // oops ;)
541 
542  return pos;
543 }
544 
546  void *data, int *data_size,
547  AVPacket *avpkt)
548 {
549  const uint8_t *buf = avpkt->data;
550  int buf_size = avpkt->size;
551  H261Context *h= avctx->priv_data;
552  MpegEncContext *s = &h->s;
553  int ret;
554  AVFrame *pict = data;
555 
556  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
557  av_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
558  s->flags= avctx->flags;
559  s->flags2= avctx->flags2;
560 
562 
563 retry:
564 
565  init_get_bits(&s->gb, buf, buf_size*8);
566 
567  if(!s->context_initialized){
568  if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
569  return -1;
570  }
571 
572  //we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
573  if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
574  int i= ff_find_unused_picture(s, 0);
575  if (i < 0)
576  return i;
577  s->current_picture_ptr= &s->picture[i];
578  }
579 
581 
582  /* skip if the header was thrashed */
583  if (ret < 0){
584  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
585  return -1;
586  }
587 
588  if (s->width != avctx->coded_width || s->height != avctx->coded_height){
589  ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
590  s->parse_context.buffer=0;
591  MPV_common_end(s);
592  s->parse_context= pc;
593  }
594  if (!s->context_initialized) {
595  avcodec_set_dimensions(avctx, s->width, s->height);
596 
597  goto retry;
598  }
599 
600  // for skipping the frame
603 
606  || avctx->skip_frame >= AVDISCARD_ALL)
607  return get_consumed_bytes(s, buf_size);
608 
609  if(MPV_frame_start(s, avctx) < 0)
610  return -1;
611 
613 
614  /* decode each macroblock */
615  s->mb_x=0;
616  s->mb_y=0;
617 
618  while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
619  if(ff_h261_resync(h)<0)
620  break;
621  h261_decode_gob(h);
622  }
623  MPV_frame_end(s);
624 
626 assert(s->current_picture.f.pict_type == s->pict_type);
627  *pict= *(AVFrame*)s->current_picture_ptr;
628  ff_print_debug_info(s, pict);
629 
630  *data_size = sizeof(AVFrame);
631 
632  return get_consumed_bytes(s, buf_size);
633 }
634 
636 {
637  H261Context *h= avctx->priv_data;
638  MpegEncContext *s = &h->s;
639 
640  MPV_common_end(s);
641  return 0;
642 }
643 
645  .name = "h261",
646  .type = AVMEDIA_TYPE_VIDEO,
647  .id = CODEC_ID_H261,
648  .priv_data_size = sizeof(H261Context),
652  .capabilities = CODEC_CAP_DR1,
653  .max_lowres = 3,
654  .long_name = NULL_IF_CONFIG_SMALL("H.261"),
655 };