Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | * | |
8 | * This file is part of FFmpeg. | |
9 | * | |
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. | |
14 | * | |
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. | |
19 | * | |
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 | |
23 | */ | |
24 | ||
25 | /** | |
26 | * @file | |
27 | * h263 decoder. | |
28 | */ | |
29 | ||
30 | #define UNCHECKED_BITSTREAM_READER 1 | |
31 | #include <limits.h> | |
32 | ||
33 | #include "libavutil/attributes.h" | |
34 | #include "libavutil/internal.h" | |
35 | #include "libavutil/mathematics.h" | |
36 | #include "avcodec.h" | |
37 | #include "mpegvideo.h" | |
38 | #include "h263.h" | |
39 | #include "mathops.h" | |
40 | #include "mpegutils.h" | |
41 | #include "unary.h" | |
42 | #include "flv.h" | |
43 | #include "mpeg4video.h" | |
44 | ||
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. | |
49 | #define MV_VLC_BITS 9 | |
50 | #define H263_MBTYPE_B_VLC_BITS 6 | |
51 | #define CBPC_B_VLC_BITS 3 | |
52 | ||
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, | |
66 | 0, //stuffing | |
67 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP, | |
68 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT, | |
69 | }; | |
70 | ||
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, | |
76 | s->obmc ? " AP" : "", | |
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" : "", | |
f6fa7814 | 85 | s->avctx->framerate.num, s->avctx->framerate.den |
2ba45a60 DM |
86 | ); |
87 | } | |
88 | } | |
89 | ||
90 | /***********************************************/ | |
91 | /* decoding */ | |
92 | ||
93 | VLC ff_h263_intra_MCBPC_vlc; | |
94 | VLC ff_h263_inter_MCBPC_vlc; | |
95 | VLC ff_h263_cbpy_vlc; | |
96 | static VLC mv_vlc; | |
97 | static VLC h263_mbtype_b_vlc; | |
98 | static VLC cbpc_b_vlc; | |
99 | ||
100 | /* init vlcs */ | |
101 | ||
102 | /* XXX: find a better solution to handle static init */ | |
103 | av_cold void ff_h263_decode_init_vlc(void) | |
104 | { | |
105 | static volatile int done = 0; | |
106 | ||
107 | if (!done) { | |
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); | |
130 | done = 1; | |
131 | } | |
132 | } | |
133 | ||
134 | int ff_h263_decode_mba(MpegEncContext *s) | |
135 | { | |
136 | int i, mb_pos; | |
137 | ||
138 | for(i=0; i<6; i++){ | |
139 | if(s->mb_num-1 <= ff_mba_max[i]) break; | |
140 | } | |
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; | |
144 | ||
145 | return mb_pos; | |
146 | } | |
147 | ||
148 | /** | |
149 | * Decode the group of blocks header or slice header. | |
150 | * @return <0 if an error occurred | |
151 | */ | |
152 | static int h263_decode_gob_header(MpegEncContext *s) | |
153 | { | |
154 | unsigned int val, gob_number; | |
155 | int left; | |
156 | ||
157 | /* Check for GOB Start Code */ | |
158 | val = show_bits(&s->gb, 16); | |
159 | if(val) | |
160 | return -1; | |
161 | ||
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 */ | |
168 | } | |
169 | if(left<=13) | |
170 | return -1; | |
171 | ||
172 | if(s->h263_slice_structured){ | |
173 | if(get_bits1(&s->gb)==0) | |
174 | return -1; | |
175 | ||
176 | ff_h263_decode_mba(s); | |
177 | ||
178 | if(s->mb_num > 1583) | |
179 | if(get_bits1(&s->gb)==0) | |
180 | return -1; | |
181 | ||
182 | s->qscale = get_bits(&s->gb, 5); /* SQUANT */ | |
183 | if(get_bits1(&s->gb)==0) | |
184 | return -1; | |
185 | skip_bits(&s->gb, 2); /* GFID */ | |
186 | }else{ | |
187 | gob_number = get_bits(&s->gb, 5); /* GN */ | |
188 | s->mb_x= 0; | |
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 */ | |
192 | } | |
193 | ||
194 | if(s->mb_y >= s->mb_height) | |
195 | return -1; | |
196 | ||
197 | if(s->qscale==0) | |
198 | return -1; | |
199 | ||
200 | return 0; | |
201 | } | |
202 | ||
203 | /** | |
204 | * Decode the group of blocks / video packet header. | |
205 | * @return bit position of the resync_marker, or <0 if none was found | |
206 | */ | |
207 | int ff_h263_resync(MpegEncContext *s){ | |
208 | int left, pos, ret; | |
209 | ||
210 | if(s->codec_id==AV_CODEC_ID_MPEG4){ | |
211 | skip_bits1(&s->gb); | |
212 | align_get_bits(&s->gb); | |
213 | } | |
214 | ||
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); | |
219 | else | |
220 | ret= h263_decode_gob_header(s); | |
221 | if(ret>=0) | |
222 | return pos; | |
223 | } | |
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); | |
228 | ||
229 | for(;left>16+1+5+5; left-=8){ | |
230 | if(show_bits(&s->gb, 16)==0){ | |
231 | GetBitContext bak= s->gb; | |
232 | ||
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); | |
236 | else | |
237 | ret= h263_decode_gob_header(s); | |
238 | if(ret>=0) | |
239 | return pos; | |
240 | ||
241 | s->gb= bak; | |
242 | } | |
243 | skip_bits(&s->gb, 8); | |
244 | } | |
245 | ||
246 | return -1; | |
247 | } | |
248 | ||
249 | int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) | |
250 | { | |
251 | int code, val, sign, shift; | |
252 | code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); | |
253 | ||
254 | if (code == 0) | |
255 | return pred; | |
256 | if (code < 0) | |
257 | return 0xffff; | |
258 | ||
259 | sign = get_bits1(&s->gb); | |
260 | shift = f_code - 1; | |
261 | val = code; | |
262 | if (shift) { | |
263 | val = (val - 1) << shift; | |
264 | val |= get_bits(&s->gb, shift); | |
265 | val++; | |
266 | } | |
267 | if (sign) | |
268 | val = -val; | |
269 | val += pred; | |
270 | ||
271 | /* modulo decoding */ | |
272 | if (!s->h263_long_vectors) { | |
273 | val = sign_extend(val, 5 + f_code); | |
274 | } else { | |
275 | /* horrible h263 long vector mode */ | |
276 | if (pred < -31 && val < -63) | |
277 | val += 64; | |
278 | if (pred > 32 && val > 63) | |
279 | val -= 64; | |
280 | ||
281 | } | |
282 | return val; | |
283 | } | |
284 | ||
285 | ||
286 | /* Decode RVLC of H.263+ UMV */ | |
287 | static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
288 | { | |
289 | int code = 0, sign; | |
290 | ||
291 | if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
292 | return pred; | |
293 | ||
294 | code = 2 + get_bits1(&s->gb); | |
295 | ||
296 | while (get_bits1(&s->gb)) | |
297 | { | |
298 | code <<= 1; | |
299 | code += get_bits1(&s->gb); | |
300 | } | |
301 | sign = code & 1; | |
302 | code >>= 1; | |
303 | ||
304 | code = (sign) ? (pred - code) : (pred + code); | |
305 | av_dlog(s->avctx,"H.263+ UMV Motion = %d\n", code); | |
306 | return code; | |
307 | ||
308 | } | |
309 | ||
310 | /** | |
311 | * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
312 | */ | |
313 | static void preview_obmc(MpegEncContext *s){ | |
314 | GetBitContext gb= s->gb; | |
315 | ||
316 | int cbpc, i, pred_x, pred_y, mx, my; | |
317 | int16_t *mot_val; | |
318 | const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
319 | const int stride= s->b8_stride*2; | |
320 | ||
321 | for(i=0; i<4; i++) | |
322 | s->block_index[i]+= 2; | |
323 | for(i=4; i<6; i++) | |
324 | s->block_index[i]+= 1; | |
325 | s->mb_x++; | |
326 | ||
327 | av_assert2(s->pict_type == AV_PICTURE_TYPE_P); | |
328 | ||
329 | do{ | |
330 | if (get_bits1(&s->gb)) { | |
331 | /* skip mb */ | |
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; | |
337 | ||
338 | s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
339 | goto end; | |
340 | } | |
341 | cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
342 | }while(cbpc == 20); | |
343 | ||
344 | if(cbpc & 4){ | |
345 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA; | |
346 | }else{ | |
347 | get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
348 | if (cbpc & 8) { | |
349 | if(s->modified_quant){ | |
350 | if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
351 | else skip_bits(&s->gb, 5); | |
352 | }else | |
353 | skip_bits(&s->gb, 2); | |
354 | } | |
355 | ||
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); | |
360 | if (s->umvplus) | |
361 | mx = h263p_decode_umotion(s, pred_x); | |
362 | else | |
363 | mx = ff_h263_decode_motion(s, pred_x, 1); | |
364 | ||
365 | if (s->umvplus) | |
366 | my = h263p_decode_umotion(s, pred_y); | |
367 | else | |
368 | my = ff_h263_decode_motion(s, pred_y, 1); | |
369 | ||
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; | |
374 | } else { | |
375 | s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; | |
376 | for(i=0;i<4;i++) { | |
377 | mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
378 | if (s->umvplus) | |
379 | mx = h263p_decode_umotion(s, pred_x); | |
380 | else | |
381 | mx = ff_h263_decode_motion(s, pred_x, 1); | |
382 | ||
383 | if (s->umvplus) | |
384 | my = h263p_decode_umotion(s, pred_y); | |
385 | else | |
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 */ | |
389 | mot_val[0] = mx; | |
390 | mot_val[1] = my; | |
391 | } | |
392 | } | |
393 | } | |
394 | end: | |
395 | ||
396 | for(i=0; i<4; i++) | |
397 | s->block_index[i]-= 2; | |
398 | for(i=4; i<6; i++) | |
399 | s->block_index[i]-= 1; | |
400 | s->mb_x--; | |
401 | ||
402 | s->gb= gb; | |
403 | } | |
404 | ||
405 | static void h263_decode_dquant(MpegEncContext *s){ | |
406 | static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
407 | ||
408 | if(s->modified_quant){ | |
409 | if(get_bits1(&s->gb)) | |
410 | s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
411 | else | |
412 | s->qscale= get_bits(&s->gb, 5); | |
413 | }else | |
414 | s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
415 | ff_set_qscale(s, s->qscale); | |
416 | } | |
417 | ||
418 | static int h263_decode_block(MpegEncContext * s, int16_t * block, | |
419 | int n, int coded) | |
420 | { | |
421 | int level, i, j, run; | |
422 | RLTable *rl = &ff_h263_rl_inter; | |
423 | const uint8_t *scan_table; | |
424 | GetBitContext gb= s->gb; | |
425 | ||
426 | scan_table = s->intra_scantable.permutated; | |
427 | if (s->h263_aic && s->mb_intra) { | |
428 | rl = &ff_rl_intra_aic; | |
429 | i = 0; | |
430 | if (s->ac_pred) { | |
431 | if (s->h263_aic_dir) | |
432 | scan_table = s->intra_v_scantable.permutated; /* left */ | |
433 | else | |
434 | scan_table = s->intra_h_scantable.permutated; /* top */ | |
435 | } | |
436 | } else if (s->mb_intra) { | |
437 | /* DC coef */ | |
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) { | |
441 | int component, diff; | |
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); | |
446 | if (diff == 0xffff) | |
447 | return -1; | |
448 | level += diff; | |
449 | level = level & 0xff; /* handle wrap round */ | |
450 | s->last_dc[component] = level; | |
451 | } else { | |
452 | s->rv10_first_dc_coded[component] = 1; | |
453 | } | |
454 | } else { | |
455 | level = get_bits(&s->gb, 8); | |
456 | if (level == 255) | |
457 | level = 128; | |
458 | } | |
459 | #endif | |
460 | }else{ | |
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)) | |
465 | return -1; | |
466 | } | |
467 | if (level == 255) | |
468 | level = 128; | |
469 | } | |
470 | block[0] = level; | |
471 | i = 1; | |
472 | } else { | |
473 | i = 0; | |
474 | } | |
475 | if (!coded) { | |
476 | if (s->mb_intra && s->h263_aic) | |
477 | goto not_coded; | |
478 | s->block_last_index[n] = i - 1; | |
479 | return 0; | |
480 | } | |
481 | retry: | |
482 | { | |
483 | OPEN_READER(re, &s->gb); | |
484 | i--; // offset by -1 to allow direct indexing of scan_table | |
485 | for(;;) { | |
486 | UPDATE_CACHE(re, &s->gb); | |
487 | GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); | |
488 | if (run == 66) { | |
489 | if (level){ | |
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); | |
492 | return -1; | |
493 | } | |
494 | /* escape */ | |
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; | |
499 | if (is11) { | |
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); | |
504 | } else { | |
505 | SKIP_CACHE(re, &s->gb, 7); | |
506 | level = SHOW_SBITS(re, &s->gb, 7); | |
507 | SKIP_COUNTER(re, &s->gb, 1 + 7 + 7); | |
508 | } | |
509 | } else { | |
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); | |
514 | if(level == -128){ | |
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); | |
520 | }else{ | |
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); | |
525 | } | |
526 | } | |
527 | } | |
528 | } else { | |
529 | if (SHOW_UBITS(re, &s->gb, 1)) | |
530 | level = -level; | |
531 | SKIP_COUNTER(re, &s->gb, 1); | |
532 | } | |
533 | i += run; | |
534 | if (i >= 64){ | |
535 | CLOSE_READER(re, &s->gb); | |
536 | // redo update without last flag, revert -1 offset | |
537 | i = i - run + ((run-1)&63) + 1; | |
538 | if (i < 64) { | |
539 | // only last marker, no overrun | |
540 | block[scan_table[i]] = level; | |
541 | break; | |
542 | } | |
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; | |
546 | i = 0; | |
547 | s->gb= gb; | |
548 | s->bdsp.clear_block(block); | |
549 | goto retry; | |
550 | } | |
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); | |
552 | return -1; | |
553 | } | |
554 | j = scan_table[i]; | |
555 | block[j] = level; | |
556 | } | |
557 | } | |
558 | not_coded: | |
559 | if (s->mb_intra && s->h263_aic) { | |
560 | ff_h263_pred_acdc(s, block, n); | |
561 | i = 63; | |
562 | } | |
563 | s->block_last_index[n] = i; | |
564 | return 0; | |
565 | } | |
566 | ||
567 | static int h263_skip_b_part(MpegEncContext *s, int cbp) | |
568 | { | |
569 | LOCAL_ALIGNED_16(int16_t, dblock, [64]); | |
570 | int i, mbi; | |
571 | int bli[6]; | |
572 | ||
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) | |
575 | */ | |
576 | mbi = s->mb_intra; | |
577 | memcpy(bli, s->block_last_index, sizeof(bli)); | |
578 | s->mb_intra = 0; | |
579 | for (i = 0; i < 6; i++) { | |
580 | if (h263_decode_block(s, dblock, i, cbp&32) < 0) | |
581 | return -1; | |
582 | cbp+=cbp; | |
583 | } | |
584 | s->mb_intra = mbi; | |
585 | memcpy(s->block_last_index, bli, sizeof(bli)); | |
586 | return 0; | |
587 | } | |
588 | ||
589 | static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) | |
590 | { | |
591 | int c, mv = 1; | |
592 | ||
593 | if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame | |
594 | c = get_bits1(gb); | |
595 | if (pb_frame == 2 && c) | |
596 | mv = !get_bits1(gb); | |
597 | } else { // h.263 Annex M improved PB-frame | |
598 | mv = get_unary(gb, 0, 4) + 1; | |
599 | c = mv & 1; | |
600 | mv = !!(mv & 2); | |
601 | } | |
602 | if(c) | |
603 | *cbpb = get_bits(gb, 6); | |
604 | return mv; | |
605 | } | |
606 | ||
607 | int ff_h263_decode_mb(MpegEncContext *s, | |
608 | int16_t block[6][64]) | |
609 | { | |
610 | int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
611 | int16_t *mot_val; | |
612 | const int xy= s->mb_x + s->mb_y * s->mb_stride; | |
613 | int cbpb = 0, pb_mv_count = 0; | |
614 | ||
615 | av_assert2(!s->h263_pred); | |
616 | ||
617 | if (s->pict_type == AV_PICTURE_TYPE_P) { | |
618 | do{ | |
619 | if (get_bits1(&s->gb)) { | |
620 | /* skip mb */ | |
621 | s->mb_intra = 0; | |
622 | for(i=0;i<6;i++) | |
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; | |
627 | s->mv[0][0][0] = 0; | |
628 | s->mv[0][0][1] = 0; | |
629 | s->mb_skipped = !(s->obmc | s->loop_filter); | |
630 | goto end; | |
631 | } | |
632 | cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
633 | if (cbpc < 0){ | |
634 | av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
635 | return -1; | |
636 | } | |
637 | }while(cbpc == 20); | |
638 | ||
639 | s->bdsp.clear_blocks(s->block[0]); | |
640 | ||
641 | dquant = cbpc & 8; | |
642 | s->mb_intra = ((cbpc & 4) != 0); | |
643 | if (s->mb_intra) goto intra; | |
644 | ||
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); | |
648 | ||
649 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
650 | cbpy ^= 0xF; | |
651 | ||
652 | cbp = (cbpc & 3) | (cbpy << 2); | |
653 | if (dquant) { | |
654 | h263_decode_dquant(s); | |
655 | } | |
656 | ||
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); | |
663 | if (s->umvplus) | |
664 | mx = h263p_decode_umotion(s, pred_x); | |
665 | else | |
666 | mx = ff_h263_decode_motion(s, pred_x, 1); | |
667 | ||
668 | if (mx >= 0xffff) | |
669 | return -1; | |
670 | ||
671 | if (s->umvplus) | |
672 | my = h263p_decode_umotion(s, pred_y); | |
673 | else | |
674 | my = ff_h263_decode_motion(s, pred_y, 1); | |
675 | ||
676 | if (my >= 0xffff) | |
677 | return -1; | |
678 | s->mv[0][0][0] = mx; | |
679 | s->mv[0][0][1] = my; | |
680 | ||
681 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
682 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
683 | } else { | |
684 | s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; | |
685 | s->mv_type = MV_TYPE_8X8; | |
686 | for(i=0;i<4;i++) { | |
687 | mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
688 | if (s->umvplus) | |
689 | mx = h263p_decode_umotion(s, pred_x); | |
690 | else | |
691 | mx = ff_h263_decode_motion(s, pred_x, 1); | |
692 | if (mx >= 0xffff) | |
693 | return -1; | |
694 | ||
695 | if (s->umvplus) | |
696 | my = h263p_decode_umotion(s, pred_y); | |
697 | else | |
698 | my = ff_h263_decode_motion(s, pred_y, 1); | |
699 | if (my >= 0xffff) | |
700 | return -1; | |
701 | s->mv[0][i][0] = mx; | |
702 | s->mv[0][i][1] = my; | |
703 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
704 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
705 | mot_val[0] = mx; | |
706 | mot_val[1] = my; | |
707 | } | |
708 | } | |
709 | } else if(s->pict_type==AV_PICTURE_TYPE_B) { | |
710 | int mb_type; | |
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; | |
715 | ||
716 | //FIXME ugly | |
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; | |
721 | ||
722 | do{ | |
723 | mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
724 | if (mb_type < 0){ | |
725 | av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
726 | return -1; | |
727 | } | |
728 | ||
729 | mb_type= h263_mb_type_b_map[ mb_type ]; | |
730 | }while(!mb_type); | |
731 | ||
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); | |
736 | if(s->mb_intra){ | |
737 | dquant = IS_QUANT(mb_type); | |
738 | goto intra; | |
739 | } | |
740 | ||
741 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
742 | ||
743 | if (cbpy < 0){ | |
744 | av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
745 | return -1; | |
746 | } | |
747 | ||
748 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
749 | cbpy ^= 0xF; | |
750 | ||
751 | cbp = (cbpc & 3) | (cbpy << 2); | |
752 | }else | |
753 | cbp=0; | |
754 | ||
755 | av_assert2(!s->mb_intra); | |
756 | ||
757 | if(IS_QUANT(mb_type)){ | |
758 | h263_decode_dquant(s); | |
759 | } | |
760 | ||
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); | |
764 | }else{ | |
765 | s->mv_dir = 0; | |
766 | s->mv_type= MV_TYPE_16X16; | |
767 | //FIXME UMV | |
768 | ||
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; | |
772 | ||
773 | mx = ff_h263_decode_motion(s, mx, 1); | |
774 | my = ff_h263_decode_motion(s, my, 1); | |
775 | ||
776 | s->mv[0][0][0] = mx; | |
777 | s->mv[0][0][1] = my; | |
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; | |
780 | } | |
781 | ||
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; | |
785 | ||
786 | mx = ff_h263_decode_motion(s, mx, 1); | |
787 | my = ff_h263_decode_motion(s, my, 1); | |
788 | ||
789 | s->mv[1][0][0] = mx; | |
790 | s->mv[1][0][1] = my; | |
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; | |
793 | } | |
794 | } | |
795 | ||
796 | s->current_picture.mb_type[xy] = mb_type; | |
797 | } else { /* I-Frame */ | |
798 | do{ | |
799 | cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
800 | if (cbpc < 0){ | |
801 | av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
802 | return -1; | |
803 | } | |
804 | }while(cbpc == 8); | |
805 | ||
806 | s->bdsp.clear_blocks(s->block[0]); | |
807 | ||
808 | dquant = cbpc & 4; | |
809 | s->mb_intra = 1; | |
810 | intra: | |
811 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA; | |
812 | if (s->h263_aic) { | |
813 | s->ac_pred = get_bits1(&s->gb); | |
814 | if(s->ac_pred){ | |
815 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; | |
816 | ||
817 | s->h263_aic_dir = get_bits1(&s->gb); | |
818 | } | |
819 | }else | |
820 | s->ac_pred = 0; | |
821 | ||
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); | |
825 | if(cbpy<0){ | |
826 | av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
827 | return -1; | |
828 | } | |
829 | cbp = (cbpc & 3) | (cbpy << 2); | |
830 | if (dquant) { | |
831 | h263_decode_dquant(s); | |
832 | } | |
833 | ||
834 | pb_mv_count += !!s->pb_frame; | |
835 | } | |
836 | ||
837 | while(pb_mv_count--){ | |
838 | ff_h263_decode_motion(s, 0, 1); | |
839 | ff_h263_decode_motion(s, 0, 1); | |
840 | } | |
841 | ||
842 | /* decode each block */ | |
843 | for (i = 0; i < 6; i++) { | |
844 | if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
845 | return -1; | |
846 | cbp+=cbp; | |
847 | } | |
848 | ||
849 | if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) | |
850 | return -1; | |
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) | |
853 | preview_obmc(s); | |
854 | } | |
855 | end: | |
856 | ||
857 | /* per-MB end of slice check */ | |
858 | { | |
859 | int v= show_bits(&s->gb, 16); | |
860 | ||
861 | if (get_bits_left(&s->gb) < 16) { | |
862 | v >>= 16 - get_bits_left(&s->gb); | |
863 | } | |
864 | ||
865 | if(v==0) | |
866 | return SLICE_END; | |
867 | } | |
868 | ||
869 | return SLICE_OK; | |
870 | } | |
871 | ||
872 | /* most is hardcoded. should extend to handle all h263 streams */ | |
873 | int ff_h263_decode_picture_header(MpegEncContext *s) | |
874 | { | |
875 | int format, width, height, i; | |
876 | uint32_t startcode; | |
877 | ||
878 | align_get_bits(&s->gb); | |
879 | ||
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"); | |
882 | } | |
883 | ||
884 | startcode= get_bits(&s->gb, 22-8); | |
885 | ||
886 | for(i= get_bits_left(&s->gb); i>24; i-=8) { | |
887 | startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; | |
888 | ||
889 | if(startcode == 0x20) | |
890 | break; | |
891 | } | |
892 | ||
893 | if (startcode != 0x20) { | |
894 | av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); | |
895 | return -1; | |
896 | } | |
897 | /* temporal reference */ | |
898 | i = get_bits(&s->gb, 8); /* picture timestamp */ | |
899 | if( (s->picture_number&~0xFF)+i < s->picture_number) | |
900 | i+= 256; | |
901 | s->picture_number= (s->picture_number&~0xFF) + i; | |
902 | ||
903 | /* PTYPE starts here */ | |
904 | if (get_bits1(&s->gb) != 1) { | |
905 | /* marker */ | |
906 | av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); | |
907 | return -1; | |
908 | } | |
909 | if (get_bits1(&s->gb) != 0) { | |
910 | av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); | |
911 | return -1; /* h263 id */ | |
912 | } | |
913 | skip_bits1(&s->gb); /* split screen off */ | |
914 | skip_bits1(&s->gb); /* camera off */ | |
915 | skip_bits1(&s->gb); /* freeze picture release off */ | |
916 | ||
917 | format = get_bits(&s->gb, 3); | |
918 | /* | |
919 | 0 forbidden | |
920 | 1 sub-QCIF | |
921 | 10 QCIF | |
922 | 7 extended PTYPE (PLUSPTYPE) | |
923 | */ | |
924 | ||
925 | if (format != 7 && format != 6) { | |
926 | s->h263_plus = 0; | |
927 | /* H.263v1 */ | |
928 | width = ff_h263_format[format][0]; | |
929 | height = ff_h263_format[format][1]; | |
930 | if (!width) | |
931 | return -1; | |
932 | ||
933 | s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); | |
934 | ||
935 | s->h263_long_vectors = get_bits1(&s->gb); | |
936 | ||
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 */ | |
940 | } | |
941 | s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ | |
942 | s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
943 | ||
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 */ | |
947 | ||
948 | s->width = width; | |
949 | s->height = height; | |
950 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; | |
f6fa7814 | 951 | s->avctx->framerate = (AVRational){ 30000, 1001 }; |
2ba45a60 DM |
952 | } else { |
953 | int ufep; | |
954 | ||
955 | /* H.263v2 */ | |
956 | s->h263_plus = 1; | |
957 | ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
958 | ||
959 | /* ufep other than 0 and 1 are reserved */ | |
960 | if (ufep == 1) { | |
961 | /* OPPTYPE */ | |
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"); | |
968 | } | |
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; | |
973 | if(s->avctx->lowres) | |
974 | s->loop_filter = 0; | |
975 | ||
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"); | |
979 | } | |
980 | if (get_bits1(&s->gb) != 0) { | |
981 | av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); | |
982 | } | |
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; | |
987 | ||
988 | skip_bits(&s->gb, 1); /* Prevent start code emulation */ | |
989 | ||
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); | |
993 | return -1; | |
994 | } | |
995 | ||
996 | /* MPPTYPE */ | |
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 | |
1004 | default: | |
1005 | return -1; | |
1006 | } | |
1007 | skip_bits(&s->gb, 2); | |
1008 | s->no_rounding = get_bits1(&s->gb); | |
1009 | skip_bits(&s->gb, 4); | |
1010 | ||
1011 | /* Get the picture dimensions */ | |
1012 | if (ufep) { | |
1013 | if (format == 6) { | |
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); | |
1017 | /* aspect ratios: | |
1018 | 0 - forbidden | |
1019 | 1 - 1:1 | |
1020 | 2 - 12:11 (CIF 4:3) | |
1021 | 3 - 10:11 (525-type 4:3) | |
1022 | 4 - 16:11 (CIF 16:9) | |
1023 | 5 - 40:33 (525-type 16:9) | |
1024 | 6-14 - reserved | |
1025 | */ | |
1026 | width = (get_bits(&s->gb, 9) + 1) * 4; | |
1027 | skip_bits1(&s->gb); | |
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); | |
1034 | }else{ | |
1035 | s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; | |
1036 | } | |
1037 | } else { | |
1038 | width = ff_h263_format[format][0]; | |
1039 | height = ff_h263_format[format][1]; | |
1040 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; | |
1041 | } | |
1042 | s->avctx->sample_aspect_ratio.den <<= s->ehc_mode; | |
1043 | if ((width == 0) || (height == 0)) | |
1044 | return -1; | |
1045 | s->width = width; | |
1046 | s->height = height; | |
1047 | ||
1048 | if(s->custom_pcf){ | |
1049 | int gcd; | |
f6fa7814 DM |
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){ | |
2ba45a60 DM |
1054 | av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
1055 | return -1; | |
1056 | } | |
f6fa7814 DM |
1057 | gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num); |
1058 | s->avctx->framerate.den /= gcd; | |
1059 | s->avctx->framerate.num /= gcd; | |
2ba45a60 | 1060 | }else{ |
f6fa7814 | 1061 | s->avctx->framerate = (AVRational){ 30000, 1001 }; |
2ba45a60 DM |
1062 | } |
1063 | } | |
1064 | ||
1065 | if(s->custom_pcf){ | |
1066 | skip_bits(&s->gb, 2); //extended Temporal reference | |
1067 | } | |
1068 | ||
1069 | if (ufep) { | |
1070 | if (s->umvplus) { | |
1071 | if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
1072 | skip_bits1(&s->gb); | |
1073 | } | |
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"); | |
1077 | } | |
1078 | if (get_bits1(&s->gb) != 0) { | |
1079 | av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
1080 | } | |
1081 | } | |
1082 | } | |
1083 | ||
1084 | s->qscale = get_bits(&s->gb, 5); | |
1085 | } | |
1086 | ||
1087 | if (s->width == 0 || s->height == 0) { | |
1088 | av_log(s->avctx, AV_LOG_ERROR, "dimensions 0\n"); | |
1089 | return -1; | |
1090 | } | |
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; | |
1094 | ||
1095 | if (s->pb_frame) { | |
1096 | skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
1097 | if (s->custom_pcf) | |
1098 | skip_bits(&s->gb, 2); //extended Temporal reference | |
1099 | skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
1100 | } | |
1101 | ||
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; | |
1106 | }else{ | |
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 || | |
1111 | s->pp_time <= 0){ | |
1112 | s->pp_time = 2; | |
1113 | s->pb_time = 1; | |
1114 | } | |
1115 | ff_mpeg4_init_direct_mv(s); | |
1116 | } | |
1117 | ||
1118 | /* PEI */ | |
1119 | if (skip_1stop_8data_bits(&s->gb) < 0) | |
1120 | return AVERROR_INVALIDDATA; | |
1121 | ||
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"); | |
1125 | return -1; | |
1126 | } | |
1127 | ||
1128 | ff_h263_decode_mba(s); | |
1129 | ||
1130 | if (get_bits1(&s->gb) != 1) { | |
1131 | av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
1132 | return -1; | |
1133 | } | |
1134 | } | |
1135 | s->f_code = 1; | |
1136 | ||
1137 | if(s->h263_aic){ | |
1138 | s->y_dc_scale_table= | |
1139 | s->c_dc_scale_table= ff_aic_dc_scale_table; | |
1140 | }else{ | |
1141 | s->y_dc_scale_table= | |
1142 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
1143 | } | |
1144 | ||
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){ | |
1147 | int i,j; | |
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++){ | |
1151 | for(j=0; j<3; j++){ | |
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); | |
1155 | } | |
1156 | av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
1157 | } | |
1158 | for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
1159 | } | |
1160 | ||
1161 | return 0; | |
1162 | } |