2 * ITU H263 bitstream decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
5 * Copyright (c) 2001 Juan J. Sierralta P
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #define UNCHECKED_BITSTREAM_READER 1
33 #include "libavutil/attributes.h"
34 #include "libavutil/internal.h"
35 #include "libavutil/mathematics.h"
37 #include "mpegvideo.h"
40 #include "mpegutils.h"
43 #include "mpeg4video.h"
45 // The defines below define the number of bits that are read at once for
46 // reading vlc values. Changing these may improve speed and data cache needs
47 // be aware though that decreasing them may need the number of stages that is
48 // passed to get_vlc* to be increased.
50 #define H263_MBTYPE_B_VLC_BITS 6
51 #define CBPC_B_VLC_BITS 3
53 static const int h263_mb_type_b_map
[15]= {
54 MB_TYPE_DIRECT2
| MB_TYPE_L0L1
,
55 MB_TYPE_DIRECT2
| MB_TYPE_L0L1
| MB_TYPE_CBP
,
56 MB_TYPE_DIRECT2
| MB_TYPE_L0L1
| MB_TYPE_CBP
| MB_TYPE_QUANT
,
57 MB_TYPE_L0
| MB_TYPE_16x16
,
58 MB_TYPE_L0
| MB_TYPE_CBP
| MB_TYPE_16x16
,
59 MB_TYPE_L0
| MB_TYPE_CBP
| MB_TYPE_QUANT
| MB_TYPE_16x16
,
60 MB_TYPE_L1
| MB_TYPE_16x16
,
61 MB_TYPE_L1
| MB_TYPE_CBP
| MB_TYPE_16x16
,
62 MB_TYPE_L1
| MB_TYPE_CBP
| MB_TYPE_QUANT
| MB_TYPE_16x16
,
63 MB_TYPE_L0L1
| MB_TYPE_16x16
,
64 MB_TYPE_L0L1
| MB_TYPE_CBP
| MB_TYPE_16x16
,
65 MB_TYPE_L0L1
| MB_TYPE_CBP
| MB_TYPE_QUANT
| MB_TYPE_16x16
,
67 MB_TYPE_INTRA4x4
| MB_TYPE_CBP
,
68 MB_TYPE_INTRA4x4
| MB_TYPE_CBP
| MB_TYPE_QUANT
,
71 void ff_h263_show_pict_info(MpegEncContext
*s
){
72 if(s
->avctx
->debug
&FF_DEBUG_PICT_INFO
){
73 av_log(s
->avctx
, AV_LOG_DEBUG
, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
74 s
->qscale
, av_get_picture_type_char(s
->pict_type
),
75 s
->gb
.size_in_bits
, 1-s
->no_rounding
,
77 s
->umvplus
? " UMV" : "",
78 s
->h263_long_vectors
? " LONG" : "",
79 s
->h263_plus
? " +" : "",
80 s
->h263_aic
? " AIC" : "",
81 s
->alt_inter_vlc
? " AIV" : "",
82 s
->modified_quant
? " MQ" : "",
83 s
->loop_filter
? " LOOP" : "",
84 s
->h263_slice_structured
? " SS" : "",
85 s
->avctx
->framerate
.num
, s
->avctx
->framerate
.den
90 /***********************************************/
93 VLC ff_h263_intra_MCBPC_vlc
;
94 VLC ff_h263_inter_MCBPC_vlc
;
97 static VLC h263_mbtype_b_vlc
;
98 static VLC cbpc_b_vlc
;
102 /* XXX: find a better solution to handle static init */
103 av_cold
void ff_h263_decode_init_vlc(void)
105 static volatile int done
= 0;
108 INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc
, INTRA_MCBPC_VLC_BITS
, 9,
109 ff_h263_intra_MCBPC_bits
, 1, 1,
110 ff_h263_intra_MCBPC_code
, 1, 1, 72);
111 INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc
, INTER_MCBPC_VLC_BITS
, 28,
112 ff_h263_inter_MCBPC_bits
, 1, 1,
113 ff_h263_inter_MCBPC_code
, 1, 1, 198);
114 INIT_VLC_STATIC(&ff_h263_cbpy_vlc
, CBPY_VLC_BITS
, 16,
115 &ff_h263_cbpy_tab
[0][1], 2, 1,
116 &ff_h263_cbpy_tab
[0][0], 2, 1, 64);
117 INIT_VLC_STATIC(&mv_vlc
, MV_VLC_BITS
, 33,
118 &ff_mvtab
[0][1], 2, 1,
119 &ff_mvtab
[0][0], 2, 1, 538);
120 ff_init_rl(&ff_h263_rl_inter
, ff_h263_static_rl_table_store
[0]);
121 ff_init_rl(&ff_rl_intra_aic
, ff_h263_static_rl_table_store
[1]);
122 INIT_VLC_RL(ff_h263_rl_inter
, 554);
123 INIT_VLC_RL(ff_rl_intra_aic
, 554);
124 INIT_VLC_STATIC(&h263_mbtype_b_vlc
, H263_MBTYPE_B_VLC_BITS
, 15,
125 &ff_h263_mbtype_b_tab
[0][1], 2, 1,
126 &ff_h263_mbtype_b_tab
[0][0], 2, 1, 80);
127 INIT_VLC_STATIC(&cbpc_b_vlc
, CBPC_B_VLC_BITS
, 4,
128 &ff_cbpc_b_tab
[0][1], 2, 1,
129 &ff_cbpc_b_tab
[0][0], 2, 1, 8);
134 int ff_h263_decode_mba(MpegEncContext
*s
)
139 if(s
->mb_num
-1 <= ff_mba_max
[i
]) break;
141 mb_pos
= get_bits(&s
->gb
, ff_mba_length
[i
]);
142 s
->mb_x
= mb_pos
% s
->mb_width
;
143 s
->mb_y
= mb_pos
/ s
->mb_width
;
149 * Decode the group of blocks header or slice header.
150 * @return <0 if an error occurred
152 static int h263_decode_gob_header(MpegEncContext
*s
)
154 unsigned int val
, gob_number
;
157 /* Check for GOB Start Code */
158 val
= show_bits(&s
->gb
, 16);
162 /* We have a GBSC probably with GSTUFF */
163 skip_bits(&s
->gb
, 16); /* Drop the zeros */
164 left
= get_bits_left(&s
->gb
);
165 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
166 for(;left
>13; left
--){
167 if(get_bits1(&s
->gb
)) break; /* Seek the '1' bit */
172 if(s
->h263_slice_structured
){
173 if(get_bits1(&s
->gb
)==0)
176 ff_h263_decode_mba(s
);
179 if(get_bits1(&s
->gb
)==0)
182 s
->qscale
= get_bits(&s
->gb
, 5); /* SQUANT */
183 if(get_bits1(&s
->gb
)==0)
185 skip_bits(&s
->gb
, 2); /* GFID */
187 gob_number
= get_bits(&s
->gb
, 5); /* GN */
189 s
->mb_y
= s
->gob_index
* gob_number
;
190 skip_bits(&s
->gb
, 2); /* GFID */
191 s
->qscale
= get_bits(&s
->gb
, 5); /* GQUANT */
194 if(s
->mb_y
>= s
->mb_height
)
204 * Decode the group of blocks / video packet header.
205 * @return bit position of the resync_marker, or <0 if none was found
207 int ff_h263_resync(MpegEncContext
*s
){
210 if(s
->codec_id
==AV_CODEC_ID_MPEG4
){
212 align_get_bits(&s
->gb
);
215 if(show_bits(&s
->gb
, 16)==0){
216 pos
= get_bits_count(&s
->gb
);
217 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==AV_CODEC_ID_MPEG4
)
218 ret
= ff_mpeg4_decode_video_packet_header(s
->avctx
->priv_data
);
220 ret
= h263_decode_gob_header(s
);
224 //OK, it's not where it is supposed to be ...
225 s
->gb
= s
->last_resync_gb
;
226 align_get_bits(&s
->gb
);
227 left
= get_bits_left(&s
->gb
);
229 for(;left
>16+1+5+5; left
-=8){
230 if(show_bits(&s
->gb
, 16)==0){
231 GetBitContext bak
= s
->gb
;
233 pos
= get_bits_count(&s
->gb
);
234 if(CONFIG_MPEG4_DECODER
&& s
->codec_id
==AV_CODEC_ID_MPEG4
)
235 ret
= ff_mpeg4_decode_video_packet_header(s
->avctx
->priv_data
);
237 ret
= h263_decode_gob_header(s
);
243 skip_bits(&s
->gb
, 8);
249 int ff_h263_decode_motion(MpegEncContext
* s
, int pred
, int f_code
)
251 int code
, val
, sign
, shift
;
252 code
= get_vlc2(&s
->gb
, mv_vlc
.table
, MV_VLC_BITS
, 2);
259 sign
= get_bits1(&s
->gb
);
263 val
= (val
- 1) << shift
;
264 val
|= get_bits(&s
->gb
, shift
);
271 /* modulo decoding */
272 if (!s
->h263_long_vectors
) {
273 val
= sign_extend(val
, 5 + f_code
);
275 /* horrible h263 long vector mode */
276 if (pred
< -31 && val
< -63)
278 if (pred
> 32 && val
> 63)
286 /* Decode RVLC of H.263+ UMV */
287 static int h263p_decode_umotion(MpegEncContext
* s
, int pred
)
291 if (get_bits1(&s
->gb
)) /* Motion difference = 0 */
294 code
= 2 + get_bits1(&s
->gb
);
296 while (get_bits1(&s
->gb
))
299 code
+= get_bits1(&s
->gb
);
304 code
= (sign
) ? (pred
- code
) : (pred
+ code
);
305 av_dlog(s
->avctx
,"H.263+ UMV Motion = %d\n", code
);
311 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
313 static void preview_obmc(MpegEncContext
*s
){
314 GetBitContext gb
= s
->gb
;
316 int cbpc
, i
, pred_x
, pred_y
, mx
, my
;
318 const int xy
= s
->mb_x
+ 1 + s
->mb_y
* s
->mb_stride
;
319 const int stride
= s
->b8_stride
*2;
322 s
->block_index
[i
]+= 2;
324 s
->block_index
[i
]+= 1;
327 av_assert2(s
->pict_type
== AV_PICTURE_TYPE_P
);
330 if (get_bits1(&s
->gb
)) {
332 mot_val
= s
->current_picture
.motion_val
[0][s
->block_index
[0]];
333 mot_val
[0 ]= mot_val
[2 ]=
334 mot_val
[0+stride
]= mot_val
[2+stride
]= 0;
335 mot_val
[1 ]= mot_val
[3 ]=
336 mot_val
[1+stride
]= mot_val
[3+stride
]= 0;
338 s
->current_picture
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_L0
;
341 cbpc
= get_vlc2(&s
->gb
, ff_h263_inter_MCBPC_vlc
.table
, INTER_MCBPC_VLC_BITS
, 2);
345 s
->current_picture
.mb_type
[xy
] = MB_TYPE_INTRA
;
347 get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
349 if(s
->modified_quant
){
350 if(get_bits1(&s
->gb
)) skip_bits(&s
->gb
, 1);
351 else skip_bits(&s
->gb
, 5);
353 skip_bits(&s
->gb
, 2);
356 if ((cbpc
& 16) == 0) {
357 s
->current_picture
.mb_type
[xy
] = MB_TYPE_16x16
| MB_TYPE_L0
;
358 /* 16x16 motion prediction */
359 mot_val
= ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
361 mx
= h263p_decode_umotion(s
, pred_x
);
363 mx
= ff_h263_decode_motion(s
, pred_x
, 1);
366 my
= h263p_decode_umotion(s
, pred_y
);
368 my
= ff_h263_decode_motion(s
, pred_y
, 1);
370 mot_val
[0 ]= mot_val
[2 ]=
371 mot_val
[0+stride
]= mot_val
[2+stride
]= mx
;
372 mot_val
[1 ]= mot_val
[3 ]=
373 mot_val
[1+stride
]= mot_val
[3+stride
]= my
;
375 s
->current_picture
.mb_type
[xy
] = MB_TYPE_8x8
| MB_TYPE_L0
;
377 mot_val
= ff_h263_pred_motion(s
, i
, 0, &pred_x
, &pred_y
);
379 mx
= h263p_decode_umotion(s
, pred_x
);
381 mx
= ff_h263_decode_motion(s
, pred_x
, 1);
384 my
= h263p_decode_umotion(s
, pred_y
);
386 my
= ff_h263_decode_motion(s
, pred_y
, 1);
387 if (s
->umvplus
&& (mx
- pred_x
) == 1 && (my
- pred_y
) == 1)
388 skip_bits1(&s
->gb
); /* Bit stuffing to prevent PSC */
397 s
->block_index
[i
]-= 2;
399 s
->block_index
[i
]-= 1;
405 static void h263_decode_dquant(MpegEncContext
*s
){
406 static const int8_t quant_tab
[4] = { -1, -2, 1, 2 };
408 if(s
->modified_quant
){
409 if(get_bits1(&s
->gb
))
410 s
->qscale
= ff_modified_quant_tab
[get_bits1(&s
->gb
)][ s
->qscale
];
412 s
->qscale
= get_bits(&s
->gb
, 5);
414 s
->qscale
+= quant_tab
[get_bits(&s
->gb
, 2)];
415 ff_set_qscale(s
, s
->qscale
);
418 static int h263_decode_block(MpegEncContext
* s
, int16_t * block
,
421 int level
, i
, j
, run
;
422 RLTable
*rl
= &ff_h263_rl_inter
;
423 const uint8_t *scan_table
;
424 GetBitContext gb
= s
->gb
;
426 scan_table
= s
->intra_scantable
.permutated
;
427 if (s
->h263_aic
&& s
->mb_intra
) {
428 rl
= &ff_rl_intra_aic
;
432 scan_table
= s
->intra_v_scantable
.permutated
; /* left */
434 scan_table
= s
->intra_h_scantable
.permutated
; /* top */
436 } else if (s
->mb_intra
) {
438 if(s
->codec_id
== AV_CODEC_ID_RV10
){
439 #if CONFIG_RV10_DECODER
440 if (s
->rv10_version
== 3 && s
->pict_type
== AV_PICTURE_TYPE_I
) {
442 component
= (n
<= 3 ? 0 : n
- 4 + 1);
443 level
= s
->last_dc
[component
];
444 if (s
->rv10_first_dc_coded
[component
]) {
445 diff
= ff_rv_decode_dc(s
, n
);
449 level
= level
& 0xff; /* handle wrap round */
450 s
->last_dc
[component
] = level
;
452 s
->rv10_first_dc_coded
[component
] = 1;
455 level
= get_bits(&s
->gb
, 8);
461 level
= get_bits(&s
->gb
, 8);
462 if((level
&0x7F) == 0){
463 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal dc %d at %d %d\n", level
, s
->mb_x
, s
->mb_y
);
464 if(s
->err_recognition
& (AV_EF_BITSTREAM
|AV_EF_COMPLIANT
))
476 if (s
->mb_intra
&& s
->h263_aic
)
478 s
->block_last_index
[n
] = i
- 1;
483 OPEN_READER(re
, &s
->gb
);
484 i
--; // offset by -1 to allow direct indexing of scan_table
486 UPDATE_CACHE(re
, &s
->gb
);
487 GET_RL_VLC(level
, run
, re
, &s
->gb
, rl
->rl_vlc
[0], TEX_VLC_BITS
, 2, 0);
490 CLOSE_READER(re
, &s
->gb
);
491 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal ac vlc code at %dx%d\n", s
->mb_x
, s
->mb_y
);
495 if (CONFIG_FLV_DECODER
&& s
->h263_flv
> 1) {
496 int is11
= SHOW_UBITS(re
, &s
->gb
, 1);
497 SKIP_CACHE(re
, &s
->gb
, 1);
498 run
= SHOW_UBITS(re
, &s
->gb
, 7) + 1;
500 SKIP_COUNTER(re
, &s
->gb
, 1 + 7);
501 UPDATE_CACHE(re
, &s
->gb
);
502 level
= SHOW_SBITS(re
, &s
->gb
, 11);
503 SKIP_COUNTER(re
, &s
->gb
, 11);
505 SKIP_CACHE(re
, &s
->gb
, 7);
506 level
= SHOW_SBITS(re
, &s
->gb
, 7);
507 SKIP_COUNTER(re
, &s
->gb
, 1 + 7 + 7);
510 run
= SHOW_UBITS(re
, &s
->gb
, 7) + 1;
511 SKIP_CACHE(re
, &s
->gb
, 7);
512 level
= (int8_t)SHOW_UBITS(re
, &s
->gb
, 8);
513 SKIP_COUNTER(re
, &s
->gb
, 7 + 8);
515 UPDATE_CACHE(re
, &s
->gb
);
516 if (s
->codec_id
== AV_CODEC_ID_RV10
) {
517 /* XXX: should patch encoder too */
518 level
= SHOW_SBITS(re
, &s
->gb
, 12);
519 SKIP_COUNTER(re
, &s
->gb
, 12);
521 level
= SHOW_UBITS(re
, &s
->gb
, 5);
522 SKIP_CACHE(re
, &s
->gb
, 5);
523 level
|= SHOW_SBITS(re
, &s
->gb
, 6)<<5;
524 SKIP_COUNTER(re
, &s
->gb
, 5 + 6);
529 if (SHOW_UBITS(re
, &s
->gb
, 1))
531 SKIP_COUNTER(re
, &s
->gb
, 1);
535 CLOSE_READER(re
, &s
->gb
);
536 // redo update without last flag, revert -1 offset
537 i
= i
- run
+ ((run
-1)&63) + 1;
539 // only last marker, no overrun
540 block
[scan_table
[i
]] = level
;
543 if(s
->alt_inter_vlc
&& rl
== &ff_h263_rl_inter
&& !s
->mb_intra
){
544 //Looks like a hack but no, it's the way it is supposed to work ...
545 rl
= &ff_rl_intra_aic
;
548 s
->bdsp
.clear_block(block
);
551 av_log(s
->avctx
, AV_LOG_ERROR
, "run overflow at %dx%d i:%d\n", s
->mb_x
, s
->mb_y
, s
->mb_intra
);
559 if (s
->mb_intra
&& s
->h263_aic
) {
560 ff_h263_pred_acdc(s
, block
, n
);
563 s
->block_last_index
[n
] = i
;
567 static int h263_skip_b_part(MpegEncContext
*s
, int cbp
)
569 LOCAL_ALIGNED_16(int16_t, dblock
, [64]);
573 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
574 * but real value should be restored in order to be used later (in OBMC condition)
577 memcpy(bli
, s
->block_last_index
, sizeof(bli
));
579 for (i
= 0; i
< 6; i
++) {
580 if (h263_decode_block(s
, dblock
, i
, cbp
&32) < 0)
585 memcpy(s
->block_last_index
, bli
, sizeof(bli
));
589 static int h263_get_modb(GetBitContext
*gb
, int pb_frame
, int *cbpb
)
593 if (pb_frame
< 3) { // h.263 Annex G and i263 PB-frame
595 if (pb_frame
== 2 && c
)
597 } else { // h.263 Annex M improved PB-frame
598 mv
= get_unary(gb
, 0, 4) + 1;
603 *cbpb
= get_bits(gb
, 6);
607 int ff_h263_decode_mb(MpegEncContext
*s
,
608 int16_t block
[6][64])
610 int cbpc
, cbpy
, i
, cbp
, pred_x
, pred_y
, mx
, my
, dquant
;
612 const int xy
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
613 int cbpb
= 0, pb_mv_count
= 0;
615 av_assert2(!s
->h263_pred
);
617 if (s
->pict_type
== AV_PICTURE_TYPE_P
) {
619 if (get_bits1(&s
->gb
)) {
623 s
->block_last_index
[i
] = -1;
624 s
->mv_dir
= MV_DIR_FORWARD
;
625 s
->mv_type
= MV_TYPE_16X16
;
626 s
->current_picture
.mb_type
[xy
] = MB_TYPE_SKIP
| MB_TYPE_16x16
| MB_TYPE_L0
;
629 s
->mb_skipped
= !(s
->obmc
| s
->loop_filter
);
632 cbpc
= get_vlc2(&s
->gb
, ff_h263_inter_MCBPC_vlc
.table
, INTER_MCBPC_VLC_BITS
, 2);
634 av_log(s
->avctx
, AV_LOG_ERROR
, "cbpc damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
639 s
->bdsp
.clear_blocks(s
->block
[0]);
642 s
->mb_intra
= ((cbpc
& 4) != 0);
643 if (s
->mb_intra
) goto intra
;
645 if(s
->pb_frame
&& get_bits1(&s
->gb
))
646 pb_mv_count
= h263_get_modb(&s
->gb
, s
->pb_frame
, &cbpb
);
647 cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
649 if(s
->alt_inter_vlc
==0 || (cbpc
& 3)!=3)
652 cbp
= (cbpc
& 3) | (cbpy
<< 2);
654 h263_decode_dquant(s
);
657 s
->mv_dir
= MV_DIR_FORWARD
;
658 if ((cbpc
& 16) == 0) {
659 s
->current_picture
.mb_type
[xy
] = MB_TYPE_16x16
| MB_TYPE_L0
;
660 /* 16x16 motion prediction */
661 s
->mv_type
= MV_TYPE_16X16
;
662 ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
664 mx
= h263p_decode_umotion(s
, pred_x
);
666 mx
= ff_h263_decode_motion(s
, pred_x
, 1);
672 my
= h263p_decode_umotion(s
, pred_y
);
674 my
= ff_h263_decode_motion(s
, pred_y
, 1);
681 if (s
->umvplus
&& (mx
- pred_x
) == 1 && (my
- pred_y
) == 1)
682 skip_bits1(&s
->gb
); /* Bit stuffing to prevent PSC */
684 s
->current_picture
.mb_type
[xy
] = MB_TYPE_8x8
| MB_TYPE_L0
;
685 s
->mv_type
= MV_TYPE_8X8
;
687 mot_val
= ff_h263_pred_motion(s
, i
, 0, &pred_x
, &pred_y
);
689 mx
= h263p_decode_umotion(s
, pred_x
);
691 mx
= ff_h263_decode_motion(s
, pred_x
, 1);
696 my
= h263p_decode_umotion(s
, pred_y
);
698 my
= ff_h263_decode_motion(s
, pred_y
, 1);
703 if (s
->umvplus
&& (mx
- pred_x
) == 1 && (my
- pred_y
) == 1)
704 skip_bits1(&s
->gb
); /* Bit stuffing to prevent PSC */
709 } else if(s
->pict_type
==AV_PICTURE_TYPE_B
) {
711 const int stride
= s
->b8_stride
;
712 int16_t *mot_val0
= s
->current_picture
.motion_val
[0][2 * (s
->mb_x
+ s
->mb_y
* stride
)];
713 int16_t *mot_val1
= s
->current_picture
.motion_val
[1][2 * (s
->mb_x
+ s
->mb_y
* stride
)];
714 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
717 mot_val0
[0 ]= mot_val0
[2 ]= mot_val0
[0+2*stride
]= mot_val0
[2+2*stride
]=
718 mot_val0
[1 ]= mot_val0
[3 ]= mot_val0
[1+2*stride
]= mot_val0
[3+2*stride
]=
719 mot_val1
[0 ]= mot_val1
[2 ]= mot_val1
[0+2*stride
]= mot_val1
[2+2*stride
]=
720 mot_val1
[1 ]= mot_val1
[3 ]= mot_val1
[1+2*stride
]= mot_val1
[3+2*stride
]= 0;
723 mb_type
= get_vlc2(&s
->gb
, h263_mbtype_b_vlc
.table
, H263_MBTYPE_B_VLC_BITS
, 2);
725 av_log(s
->avctx
, AV_LOG_ERROR
, "b mb_type damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
729 mb_type
= h263_mb_type_b_map
[ mb_type
];
732 s
->mb_intra
= IS_INTRA(mb_type
);
733 if(HAS_CBP(mb_type
)){
734 s
->bdsp
.clear_blocks(s
->block
[0]);
735 cbpc
= get_vlc2(&s
->gb
, cbpc_b_vlc
.table
, CBPC_B_VLC_BITS
, 1);
737 dquant
= IS_QUANT(mb_type
);
741 cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
744 av_log(s
->avctx
, AV_LOG_ERROR
, "b cbpy damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
748 if(s
->alt_inter_vlc
==0 || (cbpc
& 3)!=3)
751 cbp
= (cbpc
& 3) | (cbpy
<< 2);
755 av_assert2(!s
->mb_intra
);
757 if(IS_QUANT(mb_type
)){
758 h263_decode_dquant(s
);
761 if(IS_DIRECT(mb_type
)){
762 s
->mv_dir
= MV_DIR_FORWARD
| MV_DIR_BACKWARD
| MV_DIRECT
;
763 mb_type
|= ff_mpeg4_set_direct_mv(s
, 0, 0);
766 s
->mv_type
= MV_TYPE_16X16
;
769 if(USES_LIST(mb_type
, 0)){
770 int16_t *mot_val
= ff_h263_pred_motion(s
, 0, 0, &mx
, &my
);
771 s
->mv_dir
= MV_DIR_FORWARD
;
773 mx
= ff_h263_decode_motion(s
, mx
, 1);
774 my
= ff_h263_decode_motion(s
, my
, 1);
778 mot_val
[0 ]= mot_val
[2 ]= mot_val
[0+2*stride
]= mot_val
[2+2*stride
]= mx
;
779 mot_val
[1 ]= mot_val
[3 ]= mot_val
[1+2*stride
]= mot_val
[3+2*stride
]= my
;
782 if(USES_LIST(mb_type
, 1)){
783 int16_t *mot_val
= ff_h263_pred_motion(s
, 0, 1, &mx
, &my
);
784 s
->mv_dir
|= MV_DIR_BACKWARD
;
786 mx
= ff_h263_decode_motion(s
, mx
, 1);
787 my
= ff_h263_decode_motion(s
, my
, 1);
791 mot_val
[0 ]= mot_val
[2 ]= mot_val
[0+2*stride
]= mot_val
[2+2*stride
]= mx
;
792 mot_val
[1 ]= mot_val
[3 ]= mot_val
[1+2*stride
]= mot_val
[3+2*stride
]= my
;
796 s
->current_picture
.mb_type
[xy
] = mb_type
;
797 } else { /* I-Frame */
799 cbpc
= get_vlc2(&s
->gb
, ff_h263_intra_MCBPC_vlc
.table
, INTRA_MCBPC_VLC_BITS
, 2);
801 av_log(s
->avctx
, AV_LOG_ERROR
, "I cbpc damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
806 s
->bdsp
.clear_blocks(s
->block
[0]);
811 s
->current_picture
.mb_type
[xy
] = MB_TYPE_INTRA
;
813 s
->ac_pred
= get_bits1(&s
->gb
);
815 s
->current_picture
.mb_type
[xy
] = MB_TYPE_INTRA
| MB_TYPE_ACPRED
;
817 s
->h263_aic_dir
= get_bits1(&s
->gb
);
822 if(s
->pb_frame
&& get_bits1(&s
->gb
))
823 pb_mv_count
= h263_get_modb(&s
->gb
, s
->pb_frame
, &cbpb
);
824 cbpy
= get_vlc2(&s
->gb
, ff_h263_cbpy_vlc
.table
, CBPY_VLC_BITS
, 1);
826 av_log(s
->avctx
, AV_LOG_ERROR
, "I cbpy damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
829 cbp
= (cbpc
& 3) | (cbpy
<< 2);
831 h263_decode_dquant(s
);
834 pb_mv_count
+= !!s
->pb_frame
;
837 while(pb_mv_count
--){
838 ff_h263_decode_motion(s
, 0, 1);
839 ff_h263_decode_motion(s
, 0, 1);
842 /* decode each block */
843 for (i
= 0; i
< 6; i
++) {
844 if (h263_decode_block(s
, block
[i
], i
, cbp
&32) < 0)
849 if(s
->pb_frame
&& h263_skip_b_part(s
, cbpb
) < 0)
851 if(s
->obmc
&& !s
->mb_intra
){
852 if(s
->pict_type
== AV_PICTURE_TYPE_P
&& s
->mb_x
+1<s
->mb_width
&& s
->mb_num_left
!= 1)
857 /* per-MB end of slice check */
859 int v
= show_bits(&s
->gb
, 16);
861 if (get_bits_left(&s
->gb
) < 16) {
862 v
>>= 16 - get_bits_left(&s
->gb
);
872 /* most is hardcoded. should extend to handle all h263 streams */
873 int ff_h263_decode_picture_header(MpegEncContext
*s
)
875 int format
, width
, height
, i
;
878 align_get_bits(&s
->gb
);
880 if (show_bits(&s
->gb
, 2) == 2 && s
->avctx
->frame_number
== 0) {
881 av_log(s
->avctx
, AV_LOG_WARNING
, "Header looks like RTP instead of H.263\n");
884 startcode
= get_bits(&s
->gb
, 22-8);
886 for(i
= get_bits_left(&s
->gb
); i
>24; i
-=8) {
887 startcode
= ((startcode
<< 8) | get_bits(&s
->gb
, 8)) & 0x003FFFFF;
889 if(startcode
== 0x20)
893 if (startcode
!= 0x20) {
894 av_log(s
->avctx
, AV_LOG_ERROR
, "Bad picture start code\n");
897 /* temporal reference */
898 i
= get_bits(&s
->gb
, 8); /* picture timestamp */
899 if( (s
->picture_number
&~0xFF)+i
< s
->picture_number
)
901 s
->picture_number
= (s
->picture_number
&~0xFF) + i
;
903 /* PTYPE starts here */
904 if (get_bits1(&s
->gb
) != 1) {
906 av_log(s
->avctx
, AV_LOG_ERROR
, "Bad marker\n");
909 if (get_bits1(&s
->gb
) != 0) {
910 av_log(s
->avctx
, AV_LOG_ERROR
, "Bad H263 id\n");
911 return -1; /* h263 id */
913 skip_bits1(&s
->gb
); /* split screen off */
914 skip_bits1(&s
->gb
); /* camera off */
915 skip_bits1(&s
->gb
); /* freeze picture release off */
917 format
= get_bits(&s
->gb
, 3);
922 7 extended PTYPE (PLUSPTYPE)
925 if (format
!= 7 && format
!= 6) {
928 width
= ff_h263_format
[format
][0];
929 height
= ff_h263_format
[format
][1];
933 s
->pict_type
= AV_PICTURE_TYPE_I
+ get_bits1(&s
->gb
);
935 s
->h263_long_vectors
= get_bits1(&s
->gb
);
937 if (get_bits1(&s
->gb
) != 0) {
938 av_log(s
->avctx
, AV_LOG_ERROR
, "H263 SAC not supported\n");
939 return -1; /* SAC: off */
941 s
->obmc
= get_bits1(&s
->gb
); /* Advanced prediction mode */
942 s
->unrestricted_mv
= s
->h263_long_vectors
|| s
->obmc
;
944 s
->pb_frame
= get_bits1(&s
->gb
);
945 s
->chroma_qscale
= s
->qscale
= get_bits(&s
->gb
, 5);
946 skip_bits1(&s
->gb
); /* Continuous Presence Multipoint mode: off */
950 s
->avctx
->sample_aspect_ratio
= (AVRational
){12,11};
951 s
->avctx
->framerate
= (AVRational
){ 30000, 1001 };
957 ufep
= get_bits(&s
->gb
, 3); /* Update Full Extended PTYPE */
959 /* ufep other than 0 and 1 are reserved */
962 format
= get_bits(&s
->gb
, 3);
963 av_dlog(s
->avctx
, "ufep=1, format: %d\n", format
);
964 s
->custom_pcf
= get_bits1(&s
->gb
);
965 s
->umvplus
= get_bits1(&s
->gb
); /* Unrestricted Motion Vector */
966 if (get_bits1(&s
->gb
) != 0) {
967 av_log(s
->avctx
, AV_LOG_ERROR
, "Syntax-based Arithmetic Coding (SAC) not supported\n");
969 s
->obmc
= get_bits1(&s
->gb
); /* Advanced prediction mode */
970 s
->h263_aic
= get_bits1(&s
->gb
); /* Advanced Intra Coding (AIC) */
971 s
->loop_filter
= get_bits1(&s
->gb
);
972 s
->unrestricted_mv
= s
->umvplus
|| s
->obmc
|| s
->loop_filter
;
976 s
->h263_slice_structured
= get_bits1(&s
->gb
);
977 if (get_bits1(&s
->gb
) != 0) {
978 av_log(s
->avctx
, AV_LOG_ERROR
, "Reference Picture Selection not supported\n");
980 if (get_bits1(&s
->gb
) != 0) {
981 av_log(s
->avctx
, AV_LOG_ERROR
, "Independent Segment Decoding not supported\n");
983 s
->alt_inter_vlc
= get_bits1(&s
->gb
);
984 s
->modified_quant
= get_bits1(&s
->gb
);
985 if(s
->modified_quant
)
986 s
->chroma_qscale_table
= ff_h263_chroma_qscale_table
;
988 skip_bits(&s
->gb
, 1); /* Prevent start code emulation */
990 skip_bits(&s
->gb
, 3); /* Reserved */
991 } else if (ufep
!= 0) {
992 av_log(s
->avctx
, AV_LOG_ERROR
, "Bad UFEP type (%d)\n", ufep
);
997 s
->pict_type
= get_bits(&s
->gb
, 3);
998 switch(s
->pict_type
){
999 case 0: s
->pict_type
= AV_PICTURE_TYPE_I
;break;
1000 case 1: s
->pict_type
= AV_PICTURE_TYPE_P
;break;
1001 case 2: s
->pict_type
= AV_PICTURE_TYPE_P
;s
->pb_frame
= 3;break;
1002 case 3: s
->pict_type
= AV_PICTURE_TYPE_B
;break;
1003 case 7: s
->pict_type
= AV_PICTURE_TYPE_I
;break; //ZYGO
1007 skip_bits(&s
->gb
, 2);
1008 s
->no_rounding
= get_bits1(&s
->gb
);
1009 skip_bits(&s
->gb
, 4);
1011 /* Get the picture dimensions */
1014 /* Custom Picture Format (CPFMT) */
1015 s
->aspect_ratio_info
= get_bits(&s
->gb
, 4);
1016 av_dlog(s
->avctx
, "aspect: %d\n", s
->aspect_ratio_info
);
1021 3 - 10:11 (525-type 4:3)
1022 4 - 16:11 (CIF 16:9)
1023 5 - 40:33 (525-type 16:9)
1026 width
= (get_bits(&s
->gb
, 9) + 1) * 4;
1028 height
= get_bits(&s
->gb
, 9) * 4;
1029 av_dlog(s
->avctx
, "\nH.263+ Custom picture: %dx%d\n",width
,height
);
1030 if (s
->aspect_ratio_info
== FF_ASPECT_EXTENDED
) {
1031 /* aspected dimensions */
1032 s
->avctx
->sample_aspect_ratio
.num
= get_bits(&s
->gb
, 8);
1033 s
->avctx
->sample_aspect_ratio
.den
= get_bits(&s
->gb
, 8);
1035 s
->avctx
->sample_aspect_ratio
= ff_h263_pixel_aspect
[s
->aspect_ratio_info
];
1038 width
= ff_h263_format
[format
][0];
1039 height
= ff_h263_format
[format
][1];
1040 s
->avctx
->sample_aspect_ratio
= (AVRational
){12,11};
1042 s
->avctx
->sample_aspect_ratio
.den
<<= s
->ehc_mode
;
1043 if ((width
== 0) || (height
== 0))
1050 s
->avctx
->framerate
.num
= 1800000;
1051 s
->avctx
->framerate
.den
= 1000 + get_bits1(&s
->gb
);
1052 s
->avctx
->framerate
.den
*= get_bits(&s
->gb
, 7);
1053 if(s
->avctx
->framerate
.den
== 0){
1054 av_log(s
, AV_LOG_ERROR
, "zero framerate\n");
1057 gcd
= av_gcd(s
->avctx
->framerate
.den
, s
->avctx
->framerate
.num
);
1058 s
->avctx
->framerate
.den
/= gcd
;
1059 s
->avctx
->framerate
.num
/= gcd
;
1061 s
->avctx
->framerate
= (AVRational
){ 30000, 1001 };
1066 skip_bits(&s
->gb
, 2); //extended Temporal reference
1071 if(get_bits1(&s
->gb
)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
1074 if(s
->h263_slice_structured
){
1075 if (get_bits1(&s
->gb
) != 0) {
1076 av_log(s
->avctx
, AV_LOG_ERROR
, "rectangular slices not supported\n");
1078 if (get_bits1(&s
->gb
) != 0) {
1079 av_log(s
->avctx
, AV_LOG_ERROR
, "unordered slices not supported\n");
1084 s
->qscale
= get_bits(&s
->gb
, 5);
1087 if (s
->width
== 0 || s
->height
== 0) {
1088 av_log(s
->avctx
, AV_LOG_ERROR
, "dimensions 0\n");
1091 s
->mb_width
= (s
->width
+ 15) / 16;
1092 s
->mb_height
= (s
->height
+ 15) / 16;
1093 s
->mb_num
= s
->mb_width
* s
->mb_height
;
1096 skip_bits(&s
->gb
, 3); /* Temporal reference for B-pictures */
1098 skip_bits(&s
->gb
, 2); //extended Temporal reference
1099 skip_bits(&s
->gb
, 2); /* Quantization information for B-pictures */
1102 if (s
->pict_type
!=AV_PICTURE_TYPE_B
) {
1103 s
->time
= s
->picture_number
;
1104 s
->pp_time
= s
->time
- s
->last_non_b_time
;
1105 s
->last_non_b_time
= s
->time
;
1107 s
->time
= s
->picture_number
;
1108 s
->pb_time
= s
->pp_time
- (s
->last_non_b_time
- s
->time
);
1109 if (s
->pp_time
<=s
->pb_time
||
1110 s
->pp_time
<= s
->pp_time
- s
->pb_time
||
1115 ff_mpeg4_init_direct_mv(s
);
1119 if (skip_1stop_8data_bits(&s
->gb
) < 0)
1120 return AVERROR_INVALIDDATA
;
1122 if(s
->h263_slice_structured
){
1123 if (get_bits1(&s
->gb
) != 1) {
1124 av_log(s
->avctx
, AV_LOG_ERROR
, "SEPB1 marker missing\n");
1128 ff_h263_decode_mba(s
);
1130 if (get_bits1(&s
->gb
) != 1) {
1131 av_log(s
->avctx
, AV_LOG_ERROR
, "SEPB2 marker missing\n");
1138 s
->y_dc_scale_table
=
1139 s
->c_dc_scale_table
= ff_aic_dc_scale_table
;
1141 s
->y_dc_scale_table
=
1142 s
->c_dc_scale_table
= ff_mpeg1_dc_scale_table
;
1145 ff_h263_show_pict_info(s
);
1146 if (s
->pict_type
== AV_PICTURE_TYPE_I
&& s
->codec_tag
== AV_RL32("ZYGO") && get_bits_left(&s
->gb
) >= 85 + 13*3*16 + 50){
1148 for(i
=0; i
<85; i
++) av_log(s
->avctx
, AV_LOG_DEBUG
, "%d", get_bits1(&s
->gb
));
1149 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
1150 for(i
=0; i
<13; i
++){
1152 int v
= get_bits(&s
->gb
, 8);
1153 v
|= get_sbits(&s
->gb
, 8)<<8;
1154 av_log(s
->avctx
, AV_LOG_DEBUG
, " %5d", v
);
1156 av_log(s
->avctx
, AV_LOG_DEBUG
, "\n");
1158 for(i
=0; i
<50; i
++) av_log(s
->avctx
, AV_LOG_DEBUG
, "%d", get_bits1(&s
->gb
));