Commit | Line | Data |
---|---|---|
fc53b6af MN |
1 | /* |
2 | * ITU H263 bitstream decoder | |
3 | * Copyright (c) 2000,2001 Fabrice Bellard | |
4 | * H263+ support. | |
5 | * Copyright (c) 2001 Juan J. Sierralta P | |
6 | * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> | |
7 | * | |
2912e87a | 8 | * This file is part of Libav. |
fc53b6af | 9 | * |
2912e87a | 10 | * Libav is free software; you can redistribute it and/or |
fc53b6af MN |
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. | |
14 | * | |
2912e87a | 15 | * Libav is distributed in the hope that it will be useful, |
fc53b6af MN |
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. | |
19 | * | |
20 | * You should have received a copy of the GNU Lesser General Public | |
2912e87a | 21 | * License along with Libav; if not, write to the Free Software |
fc53b6af MN |
22 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
23 | */ | |
24 | ||
25 | /** | |
ba87f080 | 26 | * @file |
fc53b6af MN |
27 | * h263 decoder. |
28 | */ | |
29 | ||
fc53b6af MN |
30 | #include <limits.h> |
31 | ||
6fee1b90 | 32 | #include "libavutil/attributes.h" |
0a49a62f | 33 | #include "libavutil/imgutils.h" |
218aefce | 34 | #include "libavutil/internal.h" |
0ebcdf5c | 35 | #include "libavutil/mathematics.h" |
fc53b6af MN |
36 | #include "avcodec.h" |
37 | #include "mpegvideo.h" | |
38 | #include "h263.h" | |
e3d0f49a | 39 | #include "h263data.h" |
6a85dfc8 | 40 | #include "internal.h" |
fc53b6af | 41 | #include "mathops.h" |
e0c16e4e | 42 | #include "mpegutils.h" |
fc53b6af MN |
43 | #include "unary.h" |
44 | #include "flv.h" | |
e7af52a6 | 45 | #include "rv10.h" |
fc53b6af | 46 | #include "mpeg4video.h" |
378a0008 | 47 | #include "mpegvideodata.h" |
fc53b6af | 48 | |
fc53b6af MN |
49 | // The defines below define the number of bits that are read at once for |
50 | // reading vlc values. Changing these may improve speed and data cache needs | |
51 | // be aware though that decreasing them may need the number of stages that is | |
52 | // passed to get_vlc* to be increased. | |
53 | #define MV_VLC_BITS 9 | |
54 | #define H263_MBTYPE_B_VLC_BITS 6 | |
55 | #define CBPC_B_VLC_BITS 3 | |
56 | ||
57 | static const int h263_mb_type_b_map[15]= { | |
58 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1, | |
59 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP, | |
60 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT, | |
61 | MB_TYPE_L0 | MB_TYPE_16x16, | |
62 | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_16x16, | |
63 | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, | |
64 | MB_TYPE_L1 | MB_TYPE_16x16, | |
65 | MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_16x16, | |
66 | MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, | |
67 | MB_TYPE_L0L1 | MB_TYPE_16x16, | |
68 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_16x16, | |
69 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, | |
70 | 0, //stuffing | |
71 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP, | |
72 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT, | |
73 | }; | |
74 | ||
75 | void ff_h263_show_pict_info(MpegEncContext *s){ | |
76 | if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
77 | 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", | |
6209669d | 78 | s->qscale, av_get_picture_type_char(s->pict_type), |
fc53b6af MN |
79 | s->gb.size_in_bits, 1-s->no_rounding, |
80 | s->obmc ? " AP" : "", | |
81 | s->umvplus ? " UMV" : "", | |
82 | s->h263_long_vectors ? " LONG" : "", | |
83 | s->h263_plus ? " +" : "", | |
84 | s->h263_aic ? " AIC" : "", | |
85 | s->alt_inter_vlc ? " AIV" : "", | |
86 | s->modified_quant ? " MQ" : "", | |
87 | s->loop_filter ? " LOOP" : "", | |
88 | s->h263_slice_structured ? " SS" : "", | |
7ea1b347 | 89 | s->avctx->framerate.num, s->avctx->framerate.den |
fc53b6af MN |
90 | ); |
91 | } | |
92 | } | |
93 | ||
94 | /***********************************************/ | |
95 | /* decoding */ | |
96 | ||
97 | VLC ff_h263_intra_MCBPC_vlc; | |
98 | VLC ff_h263_inter_MCBPC_vlc; | |
99 | VLC ff_h263_cbpy_vlc; | |
100 | static VLC mv_vlc; | |
101 | static VLC h263_mbtype_b_vlc; | |
102 | static VLC cbpc_b_vlc; | |
103 | ||
104 | /* init vlcs */ | |
105 | ||
106 | /* XXX: find a better solution to handle static init */ | |
6fee1b90 | 107 | av_cold void ff_h263_decode_init_vlc(void) |
fc53b6af MN |
108 | { |
109 | static int done = 0; | |
110 | ||
111 | if (!done) { | |
112 | done = 1; | |
113 | ||
114 | INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, | |
115 | ff_h263_intra_MCBPC_bits, 1, 1, | |
116 | ff_h263_intra_MCBPC_code, 1, 1, 72); | |
117 | INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
118 | ff_h263_inter_MCBPC_bits, 1, 1, | |
119 | ff_h263_inter_MCBPC_code, 1, 1, 198); | |
120 | INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16, | |
121 | &ff_h263_cbpy_tab[0][1], 2, 1, | |
122 | &ff_h263_cbpy_tab[0][0], 2, 1, 64); | |
123 | INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
ddce8953 MS |
124 | &ff_mvtab[0][1], 2, 1, |
125 | &ff_mvtab[0][0], 2, 1, 538); | |
6f57375d AK |
126 | ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]); |
127 | ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]); | |
fc53b6af | 128 | INIT_VLC_RL(ff_h263_rl_inter, 554); |
ddce8953 | 129 | INIT_VLC_RL(ff_rl_intra_aic, 554); |
fc53b6af | 130 | INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
ddce8953 MS |
131 | &ff_h263_mbtype_b_tab[0][1], 2, 1, |
132 | &ff_h263_mbtype_b_tab[0][0], 2, 1, 80); | |
fc53b6af | 133 | INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
ddce8953 MS |
134 | &ff_cbpc_b_tab[0][1], 2, 1, |
135 | &ff_cbpc_b_tab[0][0], 2, 1, 8); | |
fc53b6af MN |
136 | } |
137 | } | |
138 | ||
139 | int ff_h263_decode_mba(MpegEncContext *s) | |
140 | { | |
141 | int i, mb_pos; | |
142 | ||
6f4cd33e LB |
143 | for (i = 0; i < 6; i++) |
144 | if (s->mb_num - 1 <= ff_mba_max[i]) | |
145 | break; | |
146 | mb_pos = get_bits(&s->gb, ff_mba_length[i]); | |
147 | s->mb_x = mb_pos % s->mb_width; | |
148 | s->mb_y = mb_pos / s->mb_width; | |
fc53b6af MN |
149 | |
150 | return mb_pos; | |
151 | } | |
152 | ||
153 | /** | |
58c42af7 | 154 | * Decode the group of blocks header or slice header. |
fc53b6af MN |
155 | * @return <0 if an error occurred |
156 | */ | |
157 | static int h263_decode_gob_header(MpegEncContext *s) | |
158 | { | |
e65ab9d9 | 159 | unsigned int val, gob_number; |
fc53b6af MN |
160 | int left; |
161 | ||
162 | /* Check for GOB Start Code */ | |
163 | val = show_bits(&s->gb, 16); | |
164 | if(val) | |
165 | return -1; | |
166 | ||
167 | /* We have a GBSC probably with GSTUFF */ | |
168 | skip_bits(&s->gb, 16); /* Drop the zeros */ | |
169 | left= get_bits_left(&s->gb); | |
170 | //MN: we must check the bits left or we might end in a infinite loop (or segfault) | |
171 | for(;left>13; left--){ | |
172 | if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ | |
173 | } | |
174 | if(left<=13) | |
175 | return -1; | |
176 | ||
177 | if(s->h263_slice_structured){ | |
178 | if(get_bits1(&s->gb)==0) | |
179 | return -1; | |
180 | ||
181 | ff_h263_decode_mba(s); | |
182 | ||
183 | if(s->mb_num > 1583) | |
184 | if(get_bits1(&s->gb)==0) | |
185 | return -1; | |
186 | ||
187 | s->qscale = get_bits(&s->gb, 5); /* SQUANT */ | |
188 | if(get_bits1(&s->gb)==0) | |
189 | return -1; | |
e65ab9d9 | 190 | skip_bits(&s->gb, 2); /* GFID */ |
fc53b6af MN |
191 | }else{ |
192 | gob_number = get_bits(&s->gb, 5); /* GN */ | |
193 | s->mb_x= 0; | |
194 | s->mb_y= s->gob_index* gob_number; | |
e65ab9d9 | 195 | skip_bits(&s->gb, 2); /* GFID */ |
fc53b6af MN |
196 | s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
197 | } | |
198 | ||
199 | if(s->mb_y >= s->mb_height) | |
200 | return -1; | |
201 | ||
202 | if(s->qscale==0) | |
203 | return -1; | |
204 | ||
205 | return 0; | |
206 | } | |
207 | ||
208 | /** | |
58c42af7 | 209 | * Find the next resync_marker. |
fc53b6af MN |
210 | * @param p pointer to buffer to scan |
211 | * @param end pointer to the end of the buffer | |
212 | * @return pointer to the next resync_marker, or end if none was found | |
213 | */ | |
214 | const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end) | |
215 | { | |
216 | assert(p < end); | |
217 | ||
218 | end-=2; | |
219 | p++; | |
220 | for(;p<end; p+=2){ | |
221 | if(!*p){ | |
222 | if (!p[-1] && p[1]) return p - 1; | |
223 | else if(!p[ 1] && p[2]) return p; | |
224 | } | |
225 | } | |
226 | return end+2; | |
227 | } | |
228 | ||
229 | /** | |
58c42af7 | 230 | * Decode the group of blocks / video packet header. |
fc53b6af MN |
231 | * @return bit position of the resync_marker, or <0 if none was found |
232 | */ | |
233 | int ff_h263_resync(MpegEncContext *s){ | |
234 | int left, pos, ret; | |
235 | ||
36ef5369 | 236 | if(s->codec_id==AV_CODEC_ID_MPEG4){ |
fc53b6af MN |
237 | skip_bits1(&s->gb); |
238 | align_get_bits(&s->gb); | |
239 | } | |
240 | ||
241 | if(show_bits(&s->gb, 16)==0){ | |
242 | pos= get_bits_count(&s->gb); | |
36ef5369 | 243 | if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) |
ee8af2dd | 244 | ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); |
fc53b6af MN |
245 | else |
246 | ret= h263_decode_gob_header(s); | |
247 | if(ret>=0) | |
248 | return pos; | |
249 | } | |
250 | //OK, it's not where it is supposed to be ... | |
251 | s->gb= s->last_resync_gb; | |
252 | align_get_bits(&s->gb); | |
253 | left= get_bits_left(&s->gb); | |
254 | ||
255 | for(;left>16+1+5+5; left-=8){ | |
256 | if(show_bits(&s->gb, 16)==0){ | |
257 | GetBitContext bak= s->gb; | |
258 | ||
259 | pos= get_bits_count(&s->gb); | |
36ef5369 | 260 | if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) |
ee8af2dd | 261 | ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data); |
fc53b6af MN |
262 | else |
263 | ret= h263_decode_gob_header(s); | |
264 | if(ret>=0) | |
265 | return pos; | |
266 | ||
267 | s->gb= bak; | |
268 | } | |
269 | skip_bits(&s->gb, 8); | |
270 | } | |
271 | ||
272 | return -1; | |
273 | } | |
274 | ||
ddce8953 | 275 | int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
fc53b6af | 276 | { |
aa498fef | 277 | int code, val, sign, shift; |
fc53b6af MN |
278 | code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
279 | ||
280 | if (code == 0) | |
281 | return pred; | |
282 | if (code < 0) | |
283 | return 0xffff; | |
284 | ||
285 | sign = get_bits1(&s->gb); | |
286 | shift = f_code - 1; | |
287 | val = code; | |
288 | if (shift) { | |
289 | val = (val - 1) << shift; | |
290 | val |= get_bits(&s->gb, shift); | |
291 | val++; | |
292 | } | |
293 | if (sign) | |
294 | val = -val; | |
295 | val += pred; | |
296 | ||
297 | /* modulo decoding */ | |
298 | if (!s->h263_long_vectors) { | |
aa498fef | 299 | val = sign_extend(val, 5 + f_code); |
fc53b6af MN |
300 | } else { |
301 | /* horrible h263 long vector mode */ | |
302 | if (pred < -31 && val < -63) | |
303 | val += 64; | |
304 | if (pred > 32 && val > 63) | |
305 | val -= 64; | |
306 | ||
307 | } | |
308 | return val; | |
309 | } | |
310 | ||
311 | ||
58c42af7 | 312 | /* Decode RVLC of H.263+ UMV */ |
fc53b6af MN |
313 | static int h263p_decode_umotion(MpegEncContext * s, int pred) |
314 | { | |
315 | int code = 0, sign; | |
316 | ||
317 | if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
318 | return pred; | |
319 | ||
320 | code = 2 + get_bits1(&s->gb); | |
321 | ||
322 | while (get_bits1(&s->gb)) | |
323 | { | |
324 | code <<= 1; | |
325 | code += get_bits1(&s->gb); | |
326 | } | |
327 | sign = code & 1; | |
328 | code >>= 1; | |
329 | ||
330 | code = (sign) ? (pred - code) : (pred + code); | |
6a85dfc8 | 331 | ff_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code); |
fc53b6af MN |
332 | return code; |
333 | ||
334 | } | |
335 | ||
336 | /** | |
337 | * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
338 | */ | |
339 | static void preview_obmc(MpegEncContext *s){ | |
340 | GetBitContext gb= s->gb; | |
341 | ||
342 | int cbpc, i, pred_x, pred_y, mx, my; | |
343 | int16_t *mot_val; | |
344 | const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
345 | const int stride= s->b8_stride*2; | |
346 | ||
347 | for(i=0; i<4; i++) | |
348 | s->block_index[i]+= 2; | |
349 | for(i=4; i<6; i++) | |
350 | s->block_index[i]+= 1; | |
351 | s->mb_x++; | |
352 | ||
975a1447 | 353 | assert(s->pict_type == AV_PICTURE_TYPE_P); |
fc53b6af MN |
354 | |
355 | do{ | |
356 | if (get_bits1(&s->gb)) { | |
357 | /* skip mb */ | |
759001c5 | 358 | mot_val = s->current_picture.motion_val[0][s->block_index[0]]; |
fc53b6af MN |
359 | mot_val[0 ]= mot_val[2 ]= |
360 | mot_val[0+stride]= mot_val[2+stride]= 0; | |
361 | mot_val[1 ]= mot_val[3 ]= | |
362 | mot_val[1+stride]= mot_val[3+stride]= 0; | |
363 | ||
759001c5 | 364 | s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
fc53b6af MN |
365 | goto end; |
366 | } | |
367 | cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
368 | }while(cbpc == 20); | |
369 | ||
370 | if(cbpc & 4){ | |
759001c5 | 371 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA; |
fc53b6af MN |
372 | }else{ |
373 | get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
374 | if (cbpc & 8) { | |
375 | if(s->modified_quant){ | |
376 | if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
377 | else skip_bits(&s->gb, 5); | |
378 | }else | |
379 | skip_bits(&s->gb, 2); | |
380 | } | |
381 | ||
382 | if ((cbpc & 16) == 0) { | |
759001c5 | 383 | s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0; |
fc53b6af | 384 | /* 16x16 motion prediction */ |
ddce8953 | 385 | mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
fc53b6af MN |
386 | if (s->umvplus) |
387 | mx = h263p_decode_umotion(s, pred_x); | |
388 | else | |
ddce8953 | 389 | mx = ff_h263_decode_motion(s, pred_x, 1); |
fc53b6af MN |
390 | |
391 | if (s->umvplus) | |
392 | my = h263p_decode_umotion(s, pred_y); | |
393 | else | |
ddce8953 | 394 | my = ff_h263_decode_motion(s, pred_y, 1); |
fc53b6af MN |
395 | |
396 | mot_val[0 ]= mot_val[2 ]= | |
397 | mot_val[0+stride]= mot_val[2+stride]= mx; | |
398 | mot_val[1 ]= mot_val[3 ]= | |
399 | mot_val[1+stride]= mot_val[3+stride]= my; | |
400 | } else { | |
759001c5 | 401 | s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; |
fc53b6af | 402 | for(i=0;i<4;i++) { |
ddce8953 | 403 | mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
fc53b6af MN |
404 | if (s->umvplus) |
405 | mx = h263p_decode_umotion(s, pred_x); | |
406 | else | |
ddce8953 | 407 | mx = ff_h263_decode_motion(s, pred_x, 1); |
fc53b6af MN |
408 | |
409 | if (s->umvplus) | |
410 | my = h263p_decode_umotion(s, pred_y); | |
411 | else | |
ddce8953 | 412 | my = ff_h263_decode_motion(s, pred_y, 1); |
fc53b6af MN |
413 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
414 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
415 | mot_val[0] = mx; | |
416 | mot_val[1] = my; | |
417 | } | |
418 | } | |
419 | } | |
420 | end: | |
421 | ||
422 | for(i=0; i<4; i++) | |
423 | s->block_index[i]-= 2; | |
424 | for(i=4; i<6; i++) | |
425 | s->block_index[i]-= 1; | |
426 | s->mb_x--; | |
427 | ||
428 | s->gb= gb; | |
429 | } | |
430 | ||
431 | static void h263_decode_dquant(MpegEncContext *s){ | |
432 | static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
433 | ||
434 | if(s->modified_quant){ | |
435 | if(get_bits1(&s->gb)) | |
ddce8953 | 436 | s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; |
fc53b6af MN |
437 | else |
438 | s->qscale= get_bits(&s->gb, 5); | |
439 | }else | |
440 | s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
441 | ff_set_qscale(s, s->qscale); | |
442 | } | |
443 | ||
88bd7fdc | 444 | static int h263_decode_block(MpegEncContext * s, int16_t * block, |
fc53b6af MN |
445 | int n, int coded) |
446 | { | |
447 | int code, level, i, j, last, run; | |
448 | RLTable *rl = &ff_h263_rl_inter; | |
449 | const uint8_t *scan_table; | |
450 | GetBitContext gb= s->gb; | |
451 | ||
452 | scan_table = s->intra_scantable.permutated; | |
453 | if (s->h263_aic && s->mb_intra) { | |
ddce8953 | 454 | rl = &ff_rl_intra_aic; |
fc53b6af MN |
455 | i = 0; |
456 | if (s->ac_pred) { | |
457 | if (s->h263_aic_dir) | |
458 | scan_table = s->intra_v_scantable.permutated; /* left */ | |
459 | else | |
460 | scan_table = s->intra_h_scantable.permutated; /* top */ | |
461 | } | |
462 | } else if (s->mb_intra) { | |
463 | /* DC coef */ | |
c01ccccb | 464 | if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) { |
975a1447 | 465 | if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) { |
fc53b6af MN |
466 | int component, diff; |
467 | component = (n <= 3 ? 0 : n - 4 + 1); | |
468 | level = s->last_dc[component]; | |
469 | if (s->rv10_first_dc_coded[component]) { | |
6c28d657 | 470 | diff = ff_rv_decode_dc(s, n); |
fc53b6af MN |
471 | if (diff == 0xffff) |
472 | return -1; | |
473 | level += diff; | |
474 | level = level & 0xff; /* handle wrap round */ | |
475 | s->last_dc[component] = level; | |
476 | } else { | |
477 | s->rv10_first_dc_coded[component] = 1; | |
478 | } | |
479 | } else { | |
480 | level = get_bits(&s->gb, 8); | |
481 | if (level == 255) | |
482 | level = 128; | |
483 | } | |
fc53b6af MN |
484 | }else{ |
485 | level = get_bits(&s->gb, 8); | |
486 | if((level&0x7F) == 0){ | |
487 | av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); | |
9c1db92a | 488 | if (s->avctx->err_recognition & AV_EF_BITSTREAM) |
fc53b6af MN |
489 | return -1; |
490 | } | |
491 | if (level == 255) | |
492 | level = 128; | |
493 | } | |
494 | block[0] = level; | |
495 | i = 1; | |
496 | } else { | |
497 | i = 0; | |
498 | } | |
499 | if (!coded) { | |
500 | if (s->mb_intra && s->h263_aic) | |
501 | goto not_coded; | |
502 | s->block_last_index[n] = i - 1; | |
503 | return 0; | |
504 | } | |
505 | retry: | |
506 | for(;;) { | |
507 | code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); | |
508 | if (code < 0){ | |
509 | av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); | |
510 | return -1; | |
511 | } | |
512 | if (code == rl->n) { | |
513 | /* escape */ | |
514 | if (CONFIG_FLV_DECODER && s->h263_flv > 1) { | |
515 | ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last); | |
516 | } else { | |
517 | last = get_bits1(&s->gb); | |
518 | run = get_bits(&s->gb, 6); | |
519 | level = (int8_t)get_bits(&s->gb, 8); | |
520 | if(level == -128){ | |
36ef5369 | 521 | if (s->codec_id == AV_CODEC_ID_RV10) { |
fc53b6af MN |
522 | /* XXX: should patch encoder too */ |
523 | level = get_sbits(&s->gb, 12); | |
524 | }else{ | |
525 | level = get_bits(&s->gb, 5); | |
526 | level |= get_sbits(&s->gb, 6)<<5; | |
527 | } | |
528 | } | |
529 | } | |
530 | } else { | |
531 | run = rl->table_run[code]; | |
532 | level = rl->table_level[code]; | |
533 | last = code >= rl->last; | |
534 | if (get_bits1(&s->gb)) | |
535 | level = -level; | |
536 | } | |
537 | i += run; | |
538 | if (i >= 64){ | |
539 | if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){ | |
540 | //Looks like a hack but no, it's the way it is supposed to work ... | |
ddce8953 | 541 | rl = &ff_rl_intra_aic; |
fc53b6af MN |
542 | i = 0; |
543 | s->gb= gb; | |
e74433a8 | 544 | s->bdsp.clear_block(block); |
fc53b6af MN |
545 | goto retry; |
546 | } | |
547 | av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); | |
548 | return -1; | |
549 | } | |
550 | j = scan_table[i]; | |
551 | block[j] = level; | |
552 | if (last) | |
553 | break; | |
554 | i++; | |
555 | } | |
556 | not_coded: | |
557 | if (s->mb_intra && s->h263_aic) { | |
ddce8953 | 558 | ff_h263_pred_acdc(s, block, n); |
fc53b6af MN |
559 | i = 63; |
560 | } | |
561 | s->block_last_index[n] = i; | |
562 | return 0; | |
563 | } | |
564 | ||
565 | static int h263_skip_b_part(MpegEncContext *s, int cbp) | |
566 | { | |
88bd7fdc | 567 | LOCAL_ALIGNED_16(int16_t, dblock, [64]); |
fc53b6af MN |
568 | int i, mbi; |
569 | ||
570 | /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly | |
571 | * but real value should be restored in order to be used later (in OBMC condition) | |
572 | */ | |
573 | mbi = s->mb_intra; | |
574 | s->mb_intra = 0; | |
575 | for (i = 0; i < 6; i++) { | |
576 | if (h263_decode_block(s, dblock, i, cbp&32) < 0) | |
577 | return -1; | |
578 | cbp+=cbp; | |
579 | } | |
580 | s->mb_intra = mbi; | |
581 | return 0; | |
582 | } | |
583 | ||
584 | static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) | |
585 | { | |
586 | int c, mv = 1; | |
587 | ||
588 | if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame | |
589 | c = get_bits1(gb); | |
590 | if (pb_frame == 2 && c) | |
591 | mv = !get_bits1(gb); | |
592 | } else { // h.263 Annex M improved PB-frame | |
593 | mv = get_unary(gb, 0, 4) + 1; | |
594 | c = mv & 1; | |
595 | mv = !!(mv & 2); | |
596 | } | |
597 | if(c) | |
598 | *cbpb = get_bits(gb, 6); | |
599 | return mv; | |
600 | } | |
601 | ||
602 | int ff_h263_decode_mb(MpegEncContext *s, | |
88bd7fdc | 603 | int16_t block[6][64]) |
fc53b6af MN |
604 | { |
605 | int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
606 | int16_t *mot_val; | |
607 | const int xy= s->mb_x + s->mb_y * s->mb_stride; | |
608 | int cbpb = 0, pb_mv_count = 0; | |
609 | ||
610 | assert(!s->h263_pred); | |
611 | ||
975a1447 | 612 | if (s->pict_type == AV_PICTURE_TYPE_P) { |
fc53b6af MN |
613 | do{ |
614 | if (get_bits1(&s->gb)) { | |
615 | /* skip mb */ | |
616 | s->mb_intra = 0; | |
617 | for(i=0;i<6;i++) | |
618 | s->block_last_index[i] = -1; | |
619 | s->mv_dir = MV_DIR_FORWARD; | |
620 | s->mv_type = MV_TYPE_16X16; | |
759001c5 | 621 | s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
fc53b6af MN |
622 | s->mv[0][0][0] = 0; |
623 | s->mv[0][0][1] = 0; | |
624 | s->mb_skipped = !(s->obmc | s->loop_filter); | |
625 | goto end; | |
626 | } | |
627 | cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
628 | if (cbpc < 0){ | |
629 | av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
630 | return -1; | |
631 | } | |
632 | }while(cbpc == 20); | |
633 | ||
e74433a8 | 634 | s->bdsp.clear_blocks(s->block[0]); |
fc53b6af MN |
635 | |
636 | dquant = cbpc & 8; | |
637 | s->mb_intra = ((cbpc & 4) != 0); | |
638 | if (s->mb_intra) goto intra; | |
639 | ||
640 | if(s->pb_frame && get_bits1(&s->gb)) | |
641 | pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); | |
642 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
643 | ||
644 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
645 | cbpy ^= 0xF; | |
646 | ||
647 | cbp = (cbpc & 3) | (cbpy << 2); | |
648 | if (dquant) { | |
649 | h263_decode_dquant(s); | |
650 | } | |
651 | ||
652 | s->mv_dir = MV_DIR_FORWARD; | |
653 | if ((cbpc & 16) == 0) { | |
759001c5 | 654 | s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0; |
fc53b6af MN |
655 | /* 16x16 motion prediction */ |
656 | s->mv_type = MV_TYPE_16X16; | |
ddce8953 | 657 | ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
fc53b6af MN |
658 | if (s->umvplus) |
659 | mx = h263p_decode_umotion(s, pred_x); | |
660 | else | |
ddce8953 | 661 | mx = ff_h263_decode_motion(s, pred_x, 1); |
fc53b6af MN |
662 | |
663 | if (mx >= 0xffff) | |
664 | return -1; | |
665 | ||
666 | if (s->umvplus) | |
667 | my = h263p_decode_umotion(s, pred_y); | |
668 | else | |
ddce8953 | 669 | my = ff_h263_decode_motion(s, pred_y, 1); |
fc53b6af MN |
670 | |
671 | if (my >= 0xffff) | |
672 | return -1; | |
673 | s->mv[0][0][0] = mx; | |
674 | s->mv[0][0][1] = my; | |
675 | ||
676 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
677 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
678 | } else { | |
759001c5 | 679 | s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; |
fc53b6af MN |
680 | s->mv_type = MV_TYPE_8X8; |
681 | for(i=0;i<4;i++) { | |
ddce8953 | 682 | mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
fc53b6af MN |
683 | if (s->umvplus) |
684 | mx = h263p_decode_umotion(s, pred_x); | |
685 | else | |
ddce8953 | 686 | mx = ff_h263_decode_motion(s, pred_x, 1); |
fc53b6af MN |
687 | if (mx >= 0xffff) |
688 | return -1; | |
689 | ||
690 | if (s->umvplus) | |
691 | my = h263p_decode_umotion(s, pred_y); | |
692 | else | |
ddce8953 | 693 | my = ff_h263_decode_motion(s, pred_y, 1); |
fc53b6af MN |
694 | if (my >= 0xffff) |
695 | return -1; | |
696 | s->mv[0][i][0] = mx; | |
697 | s->mv[0][i][1] = my; | |
698 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
699 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
700 | mot_val[0] = mx; | |
701 | mot_val[1] = my; | |
702 | } | |
703 | } | |
975a1447 | 704 | } else if(s->pict_type==AV_PICTURE_TYPE_B) { |
fc53b6af MN |
705 | int mb_type; |
706 | const int stride= s->b8_stride; | |
759001c5 AK |
707 | int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)]; |
708 | int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)]; | |
fc53b6af MN |
709 | // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
710 | ||
711 | //FIXME ugly | |
712 | mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
713 | mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
714 | mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
715 | mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; | |
716 | ||
717 | do{ | |
718 | mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
719 | if (mb_type < 0){ | |
720 | av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
721 | return -1; | |
722 | } | |
723 | ||
724 | mb_type= h263_mb_type_b_map[ mb_type ]; | |
725 | }while(!mb_type); | |
726 | ||
727 | s->mb_intra = IS_INTRA(mb_type); | |
728 | if(HAS_CBP(mb_type)){ | |
e74433a8 | 729 | s->bdsp.clear_blocks(s->block[0]); |
fc53b6af MN |
730 | cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
731 | if(s->mb_intra){ | |
732 | dquant = IS_QUANT(mb_type); | |
733 | goto intra; | |
734 | } | |
735 | ||
736 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
737 | ||
738 | if (cbpy < 0){ | |
739 | av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
740 | return -1; | |
741 | } | |
742 | ||
743 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
744 | cbpy ^= 0xF; | |
745 | ||
746 | cbp = (cbpc & 3) | (cbpy << 2); | |
747 | }else | |
748 | cbp=0; | |
749 | ||
750 | assert(!s->mb_intra); | |
751 | ||
752 | if(IS_QUANT(mb_type)){ | |
753 | h263_decode_dquant(s); | |
754 | } | |
755 | ||
756 | if(IS_DIRECT(mb_type)){ | |
95144403 KC |
757 | if (!s->pp_time) |
758 | return AVERROR_INVALIDDATA; | |
fc53b6af MN |
759 | s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
760 | mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
761 | }else{ | |
762 | s->mv_dir = 0; | |
763 | s->mv_type= MV_TYPE_16X16; | |
764 | //FIXME UMV | |
765 | ||
766 | if(USES_LIST(mb_type, 0)){ | |
ddce8953 | 767 | int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &mx, &my); |
fc53b6af MN |
768 | s->mv_dir = MV_DIR_FORWARD; |
769 | ||
ddce8953 MS |
770 | mx = ff_h263_decode_motion(s, mx, 1); |
771 | my = ff_h263_decode_motion(s, my, 1); | |
fc53b6af MN |
772 | |
773 | s->mv[0][0][0] = mx; | |
774 | s->mv[0][0][1] = my; | |
775 | mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; | |
776 | mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
777 | } | |
778 | ||
779 | if(USES_LIST(mb_type, 1)){ | |
ddce8953 | 780 | int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &mx, &my); |
fc53b6af MN |
781 | s->mv_dir |= MV_DIR_BACKWARD; |
782 | ||
ddce8953 MS |
783 | mx = ff_h263_decode_motion(s, mx, 1); |
784 | my = ff_h263_decode_motion(s, my, 1); | |
fc53b6af MN |
785 | |
786 | s->mv[1][0][0] = mx; | |
787 | s->mv[1][0][1] = my; | |
788 | mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; | |
789 | mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
790 | } | |
791 | } | |
792 | ||
759001c5 | 793 | s->current_picture.mb_type[xy] = mb_type; |
fc53b6af MN |
794 | } else { /* I-Frame */ |
795 | do{ | |
796 | cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
797 | if (cbpc < 0){ | |
798 | av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
799 | return -1; | |
800 | } | |
801 | }while(cbpc == 8); | |
802 | ||
e74433a8 | 803 | s->bdsp.clear_blocks(s->block[0]); |
fc53b6af MN |
804 | |
805 | dquant = cbpc & 4; | |
806 | s->mb_intra = 1; | |
807 | intra: | |
759001c5 | 808 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA; |
fc53b6af MN |
809 | if (s->h263_aic) { |
810 | s->ac_pred = get_bits1(&s->gb); | |
811 | if(s->ac_pred){ | |
759001c5 | 812 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; |
fc53b6af MN |
813 | |
814 | s->h263_aic_dir = get_bits1(&s->gb); | |
815 | } | |
816 | }else | |
817 | s->ac_pred = 0; | |
818 | ||
819 | if(s->pb_frame && get_bits1(&s->gb)) | |
820 | pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); | |
821 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
822 | if(cbpy<0){ | |
823 | av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
824 | return -1; | |
825 | } | |
826 | cbp = (cbpc & 3) | (cbpy << 2); | |
827 | if (dquant) { | |
828 | h263_decode_dquant(s); | |
829 | } | |
830 | ||
831 | pb_mv_count += !!s->pb_frame; | |
832 | } | |
833 | ||
834 | while(pb_mv_count--){ | |
ddce8953 MS |
835 | ff_h263_decode_motion(s, 0, 1); |
836 | ff_h263_decode_motion(s, 0, 1); | |
fc53b6af MN |
837 | } |
838 | ||
839 | /* decode each block */ | |
840 | for (i = 0; i < 6; i++) { | |
841 | if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
842 | return -1; | |
843 | cbp+=cbp; | |
844 | } | |
845 | ||
846 | if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) | |
847 | return -1; | |
848 | if(s->obmc && !s->mb_intra){ | |
975a1447 | 849 | if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |
fc53b6af MN |
850 | preview_obmc(s); |
851 | } | |
852 | end: | |
853 | ||
854 | /* per-MB end of slice check */ | |
855 | { | |
856 | int v= show_bits(&s->gb, 16); | |
857 | ||
3574a85c AC |
858 | if (get_bits_left(&s->gb) < 16) { |
859 | v >>= 16 - get_bits_left(&s->gb); | |
fc53b6af MN |
860 | } |
861 | ||
862 | if(v==0) | |
863 | return SLICE_END; | |
864 | } | |
865 | ||
866 | return SLICE_OK; | |
867 | } | |
868 | ||
869 | /* most is hardcoded. should extend to handle all h263 streams */ | |
ddce8953 | 870 | int ff_h263_decode_picture_header(MpegEncContext *s) |
fc53b6af | 871 | { |
0a49a62f | 872 | int format, width, height, i, ret; |
fc53b6af MN |
873 | uint32_t startcode; |
874 | ||
875 | align_get_bits(&s->gb); | |
876 | ||
877 | startcode= get_bits(&s->gb, 22-8); | |
878 | ||
879 | for(i= get_bits_left(&s->gb); i>24; i-=8) { | |
880 | startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; | |
881 | ||
882 | if(startcode == 0x20) | |
883 | break; | |
884 | } | |
885 | ||
886 | if (startcode != 0x20) { | |
887 | av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); | |
888 | return -1; | |
889 | } | |
890 | /* temporal reference */ | |
891 | i = get_bits(&s->gb, 8); /* picture timestamp */ | |
892 | if( (s->picture_number&~0xFF)+i < s->picture_number) | |
893 | i+= 256; | |
fc53b6af MN |
894 | s->picture_number= (s->picture_number&~0xFF) + i; |
895 | ||
896 | /* PTYPE starts here */ | |
897 | if (get_bits1(&s->gb) != 1) { | |
898 | /* marker */ | |
899 | av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); | |
900 | return -1; | |
901 | } | |
902 | if (get_bits1(&s->gb) != 0) { | |
903 | av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); | |
904 | return -1; /* h263 id */ | |
905 | } | |
906 | skip_bits1(&s->gb); /* split screen off */ | |
907 | skip_bits1(&s->gb); /* camera off */ | |
908 | skip_bits1(&s->gb); /* freeze picture release off */ | |
909 | ||
910 | format = get_bits(&s->gb, 3); | |
911 | /* | |
912 | 0 forbidden | |
913 | 1 sub-QCIF | |
914 | 10 QCIF | |
915 | 7 extended PTYPE (PLUSPTYPE) | |
916 | */ | |
917 | ||
918 | if (format != 7 && format != 6) { | |
919 | s->h263_plus = 0; | |
920 | /* H.263v1 */ | |
ddce8953 MS |
921 | width = ff_h263_format[format][0]; |
922 | height = ff_h263_format[format][1]; | |
fc53b6af | 923 | |
975a1447 | 924 | s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); |
fc53b6af MN |
925 | |
926 | s->h263_long_vectors = get_bits1(&s->gb); | |
927 | ||
928 | if (get_bits1(&s->gb) != 0) { | |
929 | av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); | |
930 | return -1; /* SAC: off */ | |
931 | } | |
932 | s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ | |
933 | s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
934 | ||
935 | s->pb_frame = get_bits1(&s->gb); | |
936 | s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); | |
937 | skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ | |
938 | ||
939 | s->width = width; | |
940 | s->height = height; | |
941 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; | |
7ea1b347 | 942 | s->avctx->framerate = (AVRational){ 30000, 1001 }; |
fc53b6af MN |
943 | } else { |
944 | int ufep; | |
945 | ||
946 | /* H.263v2 */ | |
947 | s->h263_plus = 1; | |
948 | ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
949 | ||
950 | /* ufep other than 0 and 1 are reserved */ | |
951 | if (ufep == 1) { | |
952 | /* OPPTYPE */ | |
953 | format = get_bits(&s->gb, 3); | |
6a85dfc8 | 954 | ff_dlog(s->avctx, "ufep=1, format: %d\n", format); |
fc53b6af MN |
955 | s->custom_pcf= get_bits1(&s->gb); |
956 | s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ | |
957 | if (get_bits1(&s->gb) != 0) { | |
958 | av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
959 | } | |
960 | s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ | |
961 | s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
962 | s->loop_filter= get_bits1(&s->gb); | |
963 | s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
964 | ||
965 | s->h263_slice_structured= get_bits1(&s->gb); | |
966 | if (get_bits1(&s->gb) != 0) { | |
967 | av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); | |
968 | } | |
969 | if (get_bits1(&s->gb) != 0) { | |
970 | av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); | |
971 | } | |
972 | s->alt_inter_vlc= get_bits1(&s->gb); | |
973 | s->modified_quant= get_bits1(&s->gb); | |
974 | if(s->modified_quant) | |
975 | s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
976 | ||
977 | skip_bits(&s->gb, 1); /* Prevent start code emulation */ | |
978 | ||
979 | skip_bits(&s->gb, 3); /* Reserved */ | |
980 | } else if (ufep != 0) { | |
981 | av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); | |
982 | return -1; | |
983 | } | |
984 | ||
985 | /* MPPTYPE */ | |
986 | s->pict_type = get_bits(&s->gb, 3); | |
987 | switch(s->pict_type){ | |
975a1447 SS |
988 | case 0: s->pict_type= AV_PICTURE_TYPE_I;break; |
989 | case 1: s->pict_type= AV_PICTURE_TYPE_P;break; | |
990 | case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break; | |
991 | case 3: s->pict_type= AV_PICTURE_TYPE_B;break; | |
992 | case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO | |
fc53b6af MN |
993 | default: |
994 | return -1; | |
995 | } | |
996 | skip_bits(&s->gb, 2); | |
997 | s->no_rounding = get_bits1(&s->gb); | |
998 | skip_bits(&s->gb, 4); | |
999 | ||
1000 | /* Get the picture dimensions */ | |
1001 | if (ufep) { | |
1002 | if (format == 6) { | |
1003 | /* Custom Picture Format (CPFMT) */ | |
1004 | s->aspect_ratio_info = get_bits(&s->gb, 4); | |
6a85dfc8 | 1005 | ff_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
fc53b6af MN |
1006 | /* aspect ratios: |
1007 | 0 - forbidden | |
1008 | 1 - 1:1 | |
1009 | 2 - 12:11 (CIF 4:3) | |
1010 | 3 - 10:11 (525-type 4:3) | |
1011 | 4 - 16:11 (CIF 16:9) | |
1012 | 5 - 40:33 (525-type 16:9) | |
1013 | 6-14 - reserved | |
1014 | */ | |
1015 | width = (get_bits(&s->gb, 9) + 1) * 4; | |
1016 | skip_bits1(&s->gb); | |
1017 | height = get_bits(&s->gb, 9) * 4; | |
6a85dfc8 | 1018 | ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); |
fc53b6af MN |
1019 | if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
1020 | /* aspected dimensions */ | |
1021 | s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); | |
1022 | s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
1023 | }else{ | |
1024 | s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; | |
1025 | } | |
1026 | } else { | |
ddce8953 MS |
1027 | width = ff_h263_format[format][0]; |
1028 | height = ff_h263_format[format][1]; | |
fc53b6af MN |
1029 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
1030 | } | |
1031 | if ((width == 0) || (height == 0)) | |
1032 | return -1; | |
1033 | s->width = width; | |
1034 | s->height = height; | |
1035 | ||
1036 | if(s->custom_pcf){ | |
1037 | int gcd; | |
7ea1b347 AK |
1038 | s->avctx->framerate.num = 1800000; |
1039 | s->avctx->framerate.den = 1000 + get_bits1(&s->gb); | |
1040 | s->avctx->framerate.den *= get_bits(&s->gb, 7); | |
1041 | if(s->avctx->framerate.den == 0){ | |
fc53b6af MN |
1042 | av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
1043 | return -1; | |
1044 | } | |
7ea1b347 AK |
1045 | gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num); |
1046 | s->avctx->framerate.den /= gcd; | |
1047 | s->avctx->framerate.num /= gcd; | |
fc53b6af | 1048 | }else{ |
7ea1b347 | 1049 | s->avctx->framerate = (AVRational){ 30000, 1001 }; |
fc53b6af MN |
1050 | } |
1051 | } | |
1052 | ||
1053 | if(s->custom_pcf){ | |
1054 | skip_bits(&s->gb, 2); //extended Temporal reference | |
1055 | } | |
1056 | ||
1057 | if (ufep) { | |
1058 | if (s->umvplus) { | |
1059 | if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
1060 | skip_bits1(&s->gb); | |
1061 | } | |
1062 | if(s->h263_slice_structured){ | |
1063 | if (get_bits1(&s->gb) != 0) { | |
1064 | av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
1065 | } | |
1066 | if (get_bits1(&s->gb) != 0) { | |
1067 | av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
1068 | } | |
1069 | } | |
1070 | } | |
1071 | ||
1072 | s->qscale = get_bits(&s->gb, 5); | |
1073 | } | |
1074 | ||
0a49a62f LB |
1075 | if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0) |
1076 | return ret; | |
1077 | ||
fc53b6af MN |
1078 | s->mb_width = (s->width + 15) / 16; |
1079 | s->mb_height = (s->height + 15) / 16; | |
1080 | s->mb_num = s->mb_width * s->mb_height; | |
1081 | ||
1082 | if (s->pb_frame) { | |
1083 | skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
1084 | if (s->custom_pcf) | |
1085 | skip_bits(&s->gb, 2); //extended Temporal reference | |
1086 | skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
1087 | } | |
1088 | ||
1f05dcba MN |
1089 | if (s->pict_type!=AV_PICTURE_TYPE_B) { |
1090 | s->time = s->picture_number; | |
1091 | s->pp_time = s->time - s->last_non_b_time; | |
1092 | s->last_non_b_time = s->time; | |
1093 | }else{ | |
1094 | s->time = s->picture_number; | |
1095 | s->pb_time = s->pp_time - (s->last_non_b_time - s->time); | |
1096 | if (s->pp_time <=s->pb_time || | |
1097 | s->pp_time <= s->pp_time - s->pb_time || | |
1098 | s->pp_time <= 0){ | |
1099 | s->pp_time = 2; | |
1100 | s->pb_time = 1; | |
1101 | } | |
1102 | ff_mpeg4_init_direct_mv(s); | |
1103 | } | |
1104 | ||
fc53b6af MN |
1105 | /* PEI */ |
1106 | while (get_bits1(&s->gb) != 0) { | |
1107 | skip_bits(&s->gb, 8); | |
1108 | } | |
1109 | ||
1110 | if(s->h263_slice_structured){ | |
1111 | if (get_bits1(&s->gb) != 1) { | |
1112 | av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
1113 | return -1; | |
1114 | } | |
1115 | ||
1116 | ff_h263_decode_mba(s); | |
1117 | ||
1118 | if (get_bits1(&s->gb) != 1) { | |
1119 | av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
1120 | return -1; | |
1121 | } | |
1122 | } | |
1123 | s->f_code = 1; | |
1124 | ||
1125 | if(s->h263_aic){ | |
1126 | s->y_dc_scale_table= | |
1127 | s->c_dc_scale_table= ff_aic_dc_scale_table; | |
1128 | }else{ | |
1129 | s->y_dc_scale_table= | |
1130 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
1131 | } | |
1132 | ||
1133 | ff_h263_show_pict_info(s); | |
975a1447 | 1134 | if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO")){ |
fc53b6af MN |
1135 | int i,j; |
1136 | for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
1137 | av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
1138 | for(i=0; i<13; i++){ | |
1139 | for(j=0; j<3; j++){ | |
1140 | int v= get_bits(&s->gb, 8); | |
1141 | v |= get_sbits(&s->gb, 8)<<8; | |
1142 | av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); | |
1143 | } | |
1144 | av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
1145 | } | |
1146 | for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
1147 | } | |
1148 | ||
1149 | return 0; | |
1150 | } |