Mercurial > libavcodec.hg
annotate ituh263dec.c @ 12483:0159a19bfff7 libavcodec
aacdec: Rework channel mapping compatibility hacks.
For a PCE based configuration map the channels solely based on tags.
For an indexed configuration map the channels solely based on position.
This works with all known exotic samples including al17, elem_id0, bad_concat,
and lfe_is_sce.
author | alexc |
---|---|
date | Fri, 10 Sep 2010 18:01:48 +0000 |
parents | 7dd2a45249a9 |
children |
rev | line source |
---|---|
10828 | 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 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11195
diff
changeset
|
26 * @file |
10828 | 27 * h263 decoder. |
28 */ | |
29 | |
30 //#define DEBUG | |
31 #include <limits.h> | |
32 | |
33 #include "dsputil.h" | |
34 #include "avcodec.h" | |
35 #include "mpegvideo.h" | |
36 #include "h263.h" | |
37 #include "mathops.h" | |
38 #include "unary.h" | |
39 #include "flv.h" | |
40 #include "mpeg4video.h" | |
41 | |
42 //#undef NDEBUG | |
43 //#include <assert.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_pict_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" : "", | |
85 s->avctx->time_base.den, s->avctx->time_base.num | |
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 void h263_decode_init_vlc(MpegEncContext *s) | |
104 { | |
105 static int done = 0; | |
106 | |
107 if (!done) { | |
108 done = 1; | |
109 | |
110 INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, | |
111 ff_h263_intra_MCBPC_bits, 1, 1, | |
112 ff_h263_intra_MCBPC_code, 1, 1, 72); | |
113 INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
114 ff_h263_inter_MCBPC_bits, 1, 1, | |
115 ff_h263_inter_MCBPC_code, 1, 1, 198); | |
116 INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16, | |
117 &ff_h263_cbpy_tab[0][1], 2, 1, | |
118 &ff_h263_cbpy_tab[0][0], 2, 1, 64); | |
119 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
120 &mvtab[0][1], 2, 1, | |
121 &mvtab[0][0], 2, 1, 538); | |
122 init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]); | |
123 init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]); | |
124 INIT_VLC_RL(ff_h263_rl_inter, 554); | |
125 INIT_VLC_RL(rl_intra_aic, 554); | |
126 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | |
127 &h263_mbtype_b_tab[0][1], 2, 1, | |
128 &h263_mbtype_b_tab[0][0], 2, 1, 80); | |
129 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
130 &cbpc_b_tab[0][1], 2, 1, | |
131 &cbpc_b_tab[0][0], 2, 1, 8); | |
132 } | |
133 } | |
134 | |
135 int ff_h263_decode_mba(MpegEncContext *s) | |
136 { | |
137 int i, mb_pos; | |
138 | |
139 for(i=0; i<6; i++){ | |
140 if(s->mb_num-1 <= ff_mba_max[i]) break; | |
141 } | |
142 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
143 s->mb_x= mb_pos % s->mb_width; | |
144 s->mb_y= mb_pos / s->mb_width; | |
145 | |
146 return mb_pos; | |
147 } | |
148 | |
149 /** | |
150 * decodes the group of blocks header or slice header. | |
151 * @return <0 if an error occurred | |
152 */ | |
153 static int h263_decode_gob_header(MpegEncContext *s) | |
154 { | |
155 unsigned int val, gfid, gob_number; | |
156 int left; | |
157 | |
158 /* Check for GOB Start Code */ | |
159 val = show_bits(&s->gb, 16); | |
160 if(val) | |
161 return -1; | |
162 | |
163 /* We have a GBSC probably with GSTUFF */ | |
164 skip_bits(&s->gb, 16); /* Drop the zeros */ | |
165 left= get_bits_left(&s->gb); | |
166 //MN: we must check the bits left or we might end in a infinite loop (or segfault) | |
167 for(;left>13; left--){ | |
168 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ | |
169 } | |
170 if(left<=13) | |
171 return -1; | |
172 | |
173 if(s->h263_slice_structured){ | |
174 if(get_bits1(&s->gb)==0) | |
175 return -1; | |
176 | |
177 ff_h263_decode_mba(s); | |
178 | |
179 if(s->mb_num > 1583) | |
180 if(get_bits1(&s->gb)==0) | |
181 return -1; | |
182 | |
183 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ | |
184 if(get_bits1(&s->gb)==0) | |
185 return -1; | |
186 gfid = get_bits(&s->gb, 2); /* GFID */ | |
187 }else{ | |
188 gob_number = get_bits(&s->gb, 5); /* GN */ | |
189 s->mb_x= 0; | |
190 s->mb_y= s->gob_index* gob_number; | |
191 gfid = get_bits(&s->gb, 2); /* GFID */ | |
192 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
193 } | |
194 | |
195 if(s->mb_y >= s->mb_height) | |
196 return -1; | |
197 | |
198 if(s->qscale==0) | |
199 return -1; | |
200 | |
201 return 0; | |
202 } | |
203 | |
204 /** | |
205 * finds the next resync_marker | |
206 * @param p pointer to buffer to scan | |
207 * @param end pointer to the end of the buffer | |
208 * @return pointer to the next resync_marker, or end if none was found | |
209 */ | |
210 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end) | |
211 { | |
212 assert(p < end); | |
213 | |
214 end-=2; | |
215 p++; | |
216 for(;p<end; p+=2){ | |
217 if(!*p){ | |
218 if (!p[-1] && p[1]) return p - 1; | |
219 else if(!p[ 1] && p[2]) return p; | |
220 } | |
221 } | |
222 return end+2; | |
223 } | |
224 | |
225 /** | |
226 * decodes the group of blocks / video packet header. | |
227 * @return bit position of the resync_marker, or <0 if none was found | |
228 */ | |
229 int ff_h263_resync(MpegEncContext *s){ | |
230 int left, pos, ret; | |
231 | |
232 if(s->codec_id==CODEC_ID_MPEG4){ | |
233 skip_bits1(&s->gb); | |
234 align_get_bits(&s->gb); | |
235 } | |
236 | |
237 if(show_bits(&s->gb, 16)==0){ | |
238 pos= get_bits_count(&s->gb); | |
239 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4) | |
240 ret= mpeg4_decode_video_packet_header(s); | |
241 else | |
242 ret= h263_decode_gob_header(s); | |
243 if(ret>=0) | |
244 return pos; | |
245 } | |
246 //OK, it's not where it is supposed to be ... | |
247 s->gb= s->last_resync_gb; | |
248 align_get_bits(&s->gb); | |
249 left= get_bits_left(&s->gb); | |
250 | |
251 for(;left>16+1+5+5; left-=8){ | |
252 if(show_bits(&s->gb, 16)==0){ | |
253 GetBitContext bak= s->gb; | |
254 | |
255 pos= get_bits_count(&s->gb); | |
256 if(CONFIG_MPEG4_DECODER && s->codec_id==CODEC_ID_MPEG4) | |
257 ret= mpeg4_decode_video_packet_header(s); | |
258 else | |
259 ret= h263_decode_gob_header(s); | |
260 if(ret>=0) | |
261 return pos; | |
262 | |
263 s->gb= bak; | |
264 } | |
265 skip_bits(&s->gb, 8); | |
266 } | |
267 | |
268 return -1; | |
269 } | |
270 | |
271 int h263_decode_motion(MpegEncContext * s, int pred, int f_code) | |
272 { | |
273 int code, val, sign, shift, l; | |
274 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); | |
275 | |
276 if (code == 0) | |
277 return pred; | |
278 if (code < 0) | |
279 return 0xffff; | |
280 | |
281 sign = get_bits1(&s->gb); | |
282 shift = f_code - 1; | |
283 val = code; | |
284 if (shift) { | |
285 val = (val - 1) << shift; | |
286 val |= get_bits(&s->gb, shift); | |
287 val++; | |
288 } | |
289 if (sign) | |
290 val = -val; | |
291 val += pred; | |
292 | |
293 /* modulo decoding */ | |
294 if (!s->h263_long_vectors) { | |
295 l = INT_BIT - 5 - f_code; | |
296 val = (val<<l)>>l; | |
297 } else { | |
298 /* horrible h263 long vector mode */ | |
299 if (pred < -31 && val < -63) | |
300 val += 64; | |
301 if (pred > 32 && val > 63) | |
302 val -= 64; | |
303 | |
304 } | |
305 return val; | |
306 } | |
307 | |
308 | |
309 /* Decodes RVLC of H.263+ UMV */ | |
310 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
311 { | |
312 int code = 0, sign; | |
313 | |
314 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
315 return pred; | |
316 | |
317 code = 2 + get_bits1(&s->gb); | |
318 | |
319 while (get_bits1(&s->gb)) | |
320 { | |
321 code <<= 1; | |
322 code += get_bits1(&s->gb); | |
323 } | |
324 sign = code & 1; | |
325 code >>= 1; | |
326 | |
327 code = (sign) ? (pred - code) : (pred + code); | |
328 dprintf(s->avctx,"H.263+ UMV Motion = %d\n", code); | |
329 return code; | |
330 | |
331 } | |
332 | |
333 /** | |
334 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
335 */ | |
336 static void preview_obmc(MpegEncContext *s){ | |
337 GetBitContext gb= s->gb; | |
338 | |
339 int cbpc, i, pred_x, pred_y, mx, my; | |
340 int16_t *mot_val; | |
341 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
342 const int stride= s->b8_stride*2; | |
343 | |
344 for(i=0; i<4; i++) | |
345 s->block_index[i]+= 2; | |
346 for(i=4; i<6; i++) | |
347 s->block_index[i]+= 1; | |
348 s->mb_x++; | |
349 | |
350 assert(s->pict_type == FF_P_TYPE); | |
351 | |
352 do{ | |
353 if (get_bits1(&s->gb)) { | |
354 /* skip mb */ | |
355 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; | |
356 mot_val[0 ]= mot_val[2 ]= | |
357 mot_val[0+stride]= mot_val[2+stride]= 0; | |
358 mot_val[1 ]= mot_val[3 ]= | |
359 mot_val[1+stride]= mot_val[3+stride]= 0; | |
360 | |
361 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
362 goto end; | |
363 } | |
364 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
365 }while(cbpc == 20); | |
366 | |
367 if(cbpc & 4){ | |
368 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
369 }else{ | |
370 get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
371 if (cbpc & 8) { | |
372 if(s->modified_quant){ | |
373 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
374 else skip_bits(&s->gb, 5); | |
375 }else | |
376 skip_bits(&s->gb, 2); | |
377 } | |
378 | |
379 if ((cbpc & 16) == 0) { | |
380 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; | |
381 /* 16x16 motion prediction */ | |
382 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
383 if (s->umvplus) | |
384 mx = h263p_decode_umotion(s, pred_x); | |
385 else | |
386 mx = h263_decode_motion(s, pred_x, 1); | |
387 | |
388 if (s->umvplus) | |
389 my = h263p_decode_umotion(s, pred_y); | |
390 else | |
391 my = h263_decode_motion(s, pred_y, 1); | |
392 | |
393 mot_val[0 ]= mot_val[2 ]= | |
394 mot_val[0+stride]= mot_val[2+stride]= mx; | |
395 mot_val[1 ]= mot_val[3 ]= | |
396 mot_val[1+stride]= mot_val[3+stride]= my; | |
397 } else { | |
398 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; | |
399 for(i=0;i<4;i++) { | |
400 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
401 if (s->umvplus) | |
402 mx = h263p_decode_umotion(s, pred_x); | |
403 else | |
404 mx = h263_decode_motion(s, pred_x, 1); | |
405 | |
406 if (s->umvplus) | |
407 my = h263p_decode_umotion(s, pred_y); | |
408 else | |
409 my = h263_decode_motion(s, pred_y, 1); | |
410 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
411 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
412 mot_val[0] = mx; | |
413 mot_val[1] = my; | |
414 } | |
415 } | |
416 } | |
417 end: | |
418 | |
419 for(i=0; i<4; i++) | |
420 s->block_index[i]-= 2; | |
421 for(i=4; i<6; i++) | |
422 s->block_index[i]-= 1; | |
423 s->mb_x--; | |
424 | |
425 s->gb= gb; | |
426 } | |
427 | |
428 static void h263_decode_dquant(MpegEncContext *s){ | |
429 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
430 | |
431 if(s->modified_quant){ | |
432 if(get_bits1(&s->gb)) | |
433 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
434 else | |
435 s->qscale= get_bits(&s->gb, 5); | |
436 }else | |
437 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
438 ff_set_qscale(s, s->qscale); | |
439 } | |
440 | |
441 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, | |
442 int n, int coded) | |
443 { | |
444 int code, level, i, j, last, run; | |
445 RLTable *rl = &ff_h263_rl_inter; | |
446 const uint8_t *scan_table; | |
447 GetBitContext gb= s->gb; | |
448 | |
449 scan_table = s->intra_scantable.permutated; | |
450 if (s->h263_aic && s->mb_intra) { | |
451 rl = &rl_intra_aic; | |
452 i = 0; | |
453 if (s->ac_pred) { | |
454 if (s->h263_aic_dir) | |
455 scan_table = s->intra_v_scantable.permutated; /* left */ | |
456 else | |
457 scan_table = s->intra_h_scantable.permutated; /* top */ | |
458 } | |
459 } else if (s->mb_intra) { | |
460 /* DC coef */ | |
461 if(s->codec_id == CODEC_ID_RV10){ | |
462 #if CONFIG_RV10_DECODER | |
463 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { | |
464 int component, diff; | |
465 component = (n <= 3 ? 0 : n - 4 + 1); | |
466 level = s->last_dc[component]; | |
467 if (s->rv10_first_dc_coded[component]) { | |
468 diff = rv_decode_dc(s, n); | |
469 if (diff == 0xffff) | |
470 return -1; | |
471 level += diff; | |
472 level = level & 0xff; /* handle wrap round */ | |
473 s->last_dc[component] = level; | |
474 } else { | |
475 s->rv10_first_dc_coded[component] = 1; | |
476 } | |
477 } else { | |
478 level = get_bits(&s->gb, 8); | |
479 if (level == 255) | |
480 level = 128; | |
481 } | |
482 #endif | |
483 }else{ | |
484 level = get_bits(&s->gb, 8); | |
485 if((level&0x7F) == 0){ | |
486 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); | |
487 if(s->error_recognition >= FF_ER_COMPLIANT) | |
488 return -1; | |
489 } | |
490 if (level == 255) | |
491 level = 128; | |
492 } | |
493 block[0] = level; | |
494 i = 1; | |
495 } else { | |
496 i = 0; | |
497 } | |
498 if (!coded) { | |
499 if (s->mb_intra && s->h263_aic) | |
500 goto not_coded; | |
501 s->block_last_index[n] = i - 1; | |
502 return 0; | |
503 } | |
504 retry: | |
505 for(;;) { | |
506 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); | |
507 if (code < 0){ | |
508 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); | |
509 return -1; | |
510 } | |
511 if (code == rl->n) { | |
512 /* escape */ | |
513 if (CONFIG_FLV_DECODER && s->h263_flv > 1) { | |
514 ff_flv2_decode_ac_esc(&s->gb, &level, &run, &last); | |
515 } else { | |
516 last = get_bits1(&s->gb); | |
517 run = get_bits(&s->gb, 6); | |
518 level = (int8_t)get_bits(&s->gb, 8); | |
519 if(level == -128){ | |
520 if (s->codec_id == CODEC_ID_RV10) { | |
521 /* XXX: should patch encoder too */ | |
522 level = get_sbits(&s->gb, 12); | |
523 }else{ | |
524 level = get_bits(&s->gb, 5); | |
525 level |= get_sbits(&s->gb, 6)<<5; | |
526 } | |
527 } | |
528 } | |
529 } else { | |
530 run = rl->table_run[code]; | |
531 level = rl->table_level[code]; | |
532 last = code >= rl->last; | |
533 if (get_bits1(&s->gb)) | |
534 level = -level; | |
535 } | |
536 i += run; | |
537 if (i >= 64){ | |
538 if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){ | |
539 //Looks like a hack but no, it's the way it is supposed to work ... | |
540 rl = &rl_intra_aic; | |
541 i = 0; | |
542 s->gb= gb; | |
543 s->dsp.clear_block(block); | |
544 goto retry; | |
545 } | |
546 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); | |
547 return -1; | |
548 } | |
549 j = scan_table[i]; | |
550 block[j] = level; | |
551 if (last) | |
552 break; | |
553 i++; | |
554 } | |
555 not_coded: | |
556 if (s->mb_intra && s->h263_aic) { | |
557 h263_pred_acdc(s, block, n); | |
558 i = 63; | |
559 } | |
560 s->block_last_index[n] = i; | |
561 return 0; | |
562 } | |
563 | |
564 static int h263_skip_b_part(MpegEncContext *s, int cbp) | |
565 { | |
11195 | 566 LOCAL_ALIGNED_16(DCTELEM, dblock, [64]); |
10828 | 567 int i, mbi; |
568 | |
569 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly | |
570 * but real value should be restored in order to be used later (in OBMC condition) | |
571 */ | |
572 mbi = s->mb_intra; | |
573 s->mb_intra = 0; | |
574 for (i = 0; i < 6; i++) { | |
575 if (h263_decode_block(s, dblock, i, cbp&32) < 0) | |
576 return -1; | |
577 cbp+=cbp; | |
578 } | |
579 s->mb_intra = mbi; | |
580 return 0; | |
581 } | |
582 | |
583 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) | |
584 { | |
585 int c, mv = 1; | |
586 | |
587 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame | |
588 c = get_bits1(gb); | |
589 if (pb_frame == 2 && c) | |
590 mv = !get_bits1(gb); | |
591 } else { // h.263 Annex M improved PB-frame | |
592 mv = get_unary(gb, 0, 4) + 1; | |
593 c = mv & 1; | |
594 mv = !!(mv & 2); | |
595 } | |
596 if(c) | |
597 *cbpb = get_bits(gb, 6); | |
598 return mv; | |
599 } | |
600 | |
601 int ff_h263_decode_mb(MpegEncContext *s, | |
602 DCTELEM block[6][64]) | |
603 { | |
604 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
605 int16_t *mot_val; | |
606 const int xy= s->mb_x + s->mb_y * s->mb_stride; | |
607 int cbpb = 0, pb_mv_count = 0; | |
608 | |
609 assert(!s->h263_pred); | |
610 | |
611 if (s->pict_type == FF_P_TYPE) { | |
612 do{ | |
613 if (get_bits1(&s->gb)) { | |
614 /* skip mb */ | |
615 s->mb_intra = 0; | |
616 for(i=0;i<6;i++) | |
617 s->block_last_index[i] = -1; | |
618 s->mv_dir = MV_DIR_FORWARD; | |
619 s->mv_type = MV_TYPE_16X16; | |
620 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
621 s->mv[0][0][0] = 0; | |
622 s->mv[0][0][1] = 0; | |
623 s->mb_skipped = !(s->obmc | s->loop_filter); | |
624 goto end; | |
625 } | |
626 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
627 if (cbpc < 0){ | |
628 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
629 return -1; | |
630 } | |
631 }while(cbpc == 20); | |
632 | |
633 s->dsp.clear_blocks(s->block[0]); | |
634 | |
635 dquant = cbpc & 8; | |
636 s->mb_intra = ((cbpc & 4) != 0); | |
637 if (s->mb_intra) goto intra; | |
638 | |
639 if(s->pb_frame && get_bits1(&s->gb)) | |
640 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); | |
641 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
642 | |
643 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
644 cbpy ^= 0xF; | |
645 | |
646 cbp = (cbpc & 3) | (cbpy << 2); | |
647 if (dquant) { | |
648 h263_decode_dquant(s); | |
649 } | |
650 | |
651 s->mv_dir = MV_DIR_FORWARD; | |
652 if ((cbpc & 16) == 0) { | |
653 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; | |
654 /* 16x16 motion prediction */ | |
655 s->mv_type = MV_TYPE_16X16; | |
656 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); | |
657 if (s->umvplus) | |
658 mx = h263p_decode_umotion(s, pred_x); | |
659 else | |
660 mx = h263_decode_motion(s, pred_x, 1); | |
661 | |
662 if (mx >= 0xffff) | |
663 return -1; | |
664 | |
665 if (s->umvplus) | |
666 my = h263p_decode_umotion(s, pred_y); | |
667 else | |
668 my = h263_decode_motion(s, pred_y, 1); | |
669 | |
670 if (my >= 0xffff) | |
671 return -1; | |
672 s->mv[0][0][0] = mx; | |
673 s->mv[0][0][1] = my; | |
674 | |
675 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
676 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
677 } else { | |
678 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; | |
679 s->mv_type = MV_TYPE_8X8; | |
680 for(i=0;i<4;i++) { | |
681 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); | |
682 if (s->umvplus) | |
683 mx = h263p_decode_umotion(s, pred_x); | |
684 else | |
685 mx = h263_decode_motion(s, pred_x, 1); | |
686 if (mx >= 0xffff) | |
687 return -1; | |
688 | |
689 if (s->umvplus) | |
690 my = h263p_decode_umotion(s, pred_y); | |
691 else | |
692 my = h263_decode_motion(s, pred_y, 1); | |
693 if (my >= 0xffff) | |
694 return -1; | |
695 s->mv[0][i][0] = mx; | |
696 s->mv[0][i][1] = my; | |
697 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) | |
698 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
699 mot_val[0] = mx; | |
700 mot_val[1] = my; | |
701 } | |
702 } | |
703 } else if(s->pict_type==FF_B_TYPE) { | |
704 int mb_type; | |
705 const int stride= s->b8_stride; | |
706 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; | |
707 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
708 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
709 | |
710 //FIXME ugly | |
711 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
712 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
713 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
714 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; | |
715 | |
716 do{ | |
717 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
718 if (mb_type < 0){ | |
719 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
720 return -1; | |
721 } | |
722 | |
723 mb_type= h263_mb_type_b_map[ mb_type ]; | |
724 }while(!mb_type); | |
725 | |
726 s->mb_intra = IS_INTRA(mb_type); | |
727 if(HAS_CBP(mb_type)){ | |
728 s->dsp.clear_blocks(s->block[0]); | |
729 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); | |
730 if(s->mb_intra){ | |
731 dquant = IS_QUANT(mb_type); | |
732 goto intra; | |
733 } | |
734 | |
735 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
736 | |
737 if (cbpy < 0){ | |
738 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
739 return -1; | |
740 } | |
741 | |
742 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
743 cbpy ^= 0xF; | |
744 | |
745 cbp = (cbpc & 3) | (cbpy << 2); | |
746 }else | |
747 cbp=0; | |
748 | |
749 assert(!s->mb_intra); | |
750 | |
751 if(IS_QUANT(mb_type)){ | |
752 h263_decode_dquant(s); | |
753 } | |
754 | |
755 if(IS_DIRECT(mb_type)){ | |
756 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
757 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
758 }else{ | |
759 s->mv_dir = 0; | |
760 s->mv_type= MV_TYPE_16X16; | |
761 //FIXME UMV | |
762 | |
763 if(USES_LIST(mb_type, 0)){ | |
764 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); | |
765 s->mv_dir = MV_DIR_FORWARD; | |
766 | |
767 mx = h263_decode_motion(s, mx, 1); | |
768 my = h263_decode_motion(s, my, 1); | |
769 | |
770 s->mv[0][0][0] = mx; | |
771 s->mv[0][0][1] = my; | |
772 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; | |
773 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
774 } | |
775 | |
776 if(USES_LIST(mb_type, 1)){ | |
777 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); | |
778 s->mv_dir |= MV_DIR_BACKWARD; | |
779 | |
780 mx = h263_decode_motion(s, mx, 1); | |
781 my = h263_decode_motion(s, my, 1); | |
782 | |
783 s->mv[1][0][0] = mx; | |
784 s->mv[1][0][1] = my; | |
785 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; | |
786 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
787 } | |
788 } | |
789 | |
790 s->current_picture.mb_type[xy]= mb_type; | |
791 } else { /* I-Frame */ | |
792 do{ | |
793 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
794 if (cbpc < 0){ | |
795 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
796 return -1; | |
797 } | |
798 }while(cbpc == 8); | |
799 | |
800 s->dsp.clear_blocks(s->block[0]); | |
801 | |
802 dquant = cbpc & 4; | |
803 s->mb_intra = 1; | |
804 intra: | |
805 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
806 if (s->h263_aic) { | |
807 s->ac_pred = get_bits1(&s->gb); | |
808 if(s->ac_pred){ | |
809 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; | |
810 | |
811 s->h263_aic_dir = get_bits1(&s->gb); | |
812 } | |
813 }else | |
814 s->ac_pred = 0; | |
815 | |
816 if(s->pb_frame && get_bits1(&s->gb)) | |
817 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); | |
818 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
819 if(cbpy<0){ | |
820 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
821 return -1; | |
822 } | |
823 cbp = (cbpc & 3) | (cbpy << 2); | |
824 if (dquant) { | |
825 h263_decode_dquant(s); | |
826 } | |
827 | |
828 pb_mv_count += !!s->pb_frame; | |
829 } | |
830 | |
831 while(pb_mv_count--){ | |
832 h263_decode_motion(s, 0, 1); | |
833 h263_decode_motion(s, 0, 1); | |
834 } | |
835 | |
836 /* decode each block */ | |
837 for (i = 0; i < 6; i++) { | |
838 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
839 return -1; | |
840 cbp+=cbp; | |
841 } | |
842 | |
843 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) | |
844 return -1; | |
845 if(s->obmc && !s->mb_intra){ | |
846 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) | |
847 preview_obmc(s); | |
848 } | |
849 end: | |
850 | |
851 /* per-MB end of slice check */ | |
852 { | |
853 int v= show_bits(&s->gb, 16); | |
854 | |
855 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ | |
856 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; | |
857 } | |
858 | |
859 if(v==0) | |
860 return SLICE_END; | |
861 } | |
862 | |
863 return SLICE_OK; | |
864 } | |
865 | |
866 /* most is hardcoded. should extend to handle all h263 streams */ | |
867 int h263_decode_picture_header(MpegEncContext *s) | |
868 { | |
869 int format, width, height, i; | |
870 uint32_t startcode; | |
871 | |
872 align_get_bits(&s->gb); | |
873 | |
874 startcode= get_bits(&s->gb, 22-8); | |
875 | |
876 for(i= get_bits_left(&s->gb); i>24; i-=8) { | |
877 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; | |
878 | |
879 if(startcode == 0x20) | |
880 break; | |
881 } | |
882 | |
883 if (startcode != 0x20) { | |
884 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); | |
885 return -1; | |
886 } | |
887 /* temporal reference */ | |
888 i = get_bits(&s->gb, 8); /* picture timestamp */ | |
889 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
890 i+= 256; | |
891 s->current_picture_ptr->pts= | |
892 s->picture_number= (s->picture_number&~0xFF) + i; | |
893 | |
894 /* PTYPE starts here */ | |
895 if (get_bits1(&s->gb) != 1) { | |
896 /* marker */ | |
897 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); | |
898 return -1; | |
899 } | |
900 if (get_bits1(&s->gb) != 0) { | |
901 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); | |
902 return -1; /* h263 id */ | |
903 } | |
904 skip_bits1(&s->gb); /* split screen off */ | |
905 skip_bits1(&s->gb); /* camera off */ | |
906 skip_bits1(&s->gb); /* freeze picture release off */ | |
907 | |
908 format = get_bits(&s->gb, 3); | |
909 /* | |
910 0 forbidden | |
911 1 sub-QCIF | |
912 10 QCIF | |
913 7 extended PTYPE (PLUSPTYPE) | |
914 */ | |
915 | |
916 if (format != 7 && format != 6) { | |
917 s->h263_plus = 0; | |
918 /* H.263v1 */ | |
919 width = h263_format[format][0]; | |
920 height = h263_format[format][1]; | |
921 if (!width) | |
922 return -1; | |
923 | |
924 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); | |
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}; | |
942 s->avctx->time_base= (AVRational){1001, 30000}; | |
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); | |
954 dprintf(s->avctx, "ufep=1, format: %d\n", format); | |
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){ | |
988 case 0: s->pict_type= FF_I_TYPE;break; | |
989 case 1: s->pict_type= FF_P_TYPE;break; | |
990 case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break; | |
991 case 3: s->pict_type= FF_B_TYPE;break; | |
992 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO | |
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); | |
1005 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); | |
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; | |
1018 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); | |
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 { | |
1027 width = h263_format[format][0]; | |
1028 height = h263_format[format][1]; | |
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; | |
1038 s->avctx->time_base.den= 1800000; | |
1039 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
1040 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
1041 if(s->avctx->time_base.num == 0){ | |
1042 av_log(s, AV_LOG_ERROR, "zero framerate\n"); | |
1043 return -1; | |
1044 } | |
1045 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); | |
1046 s->avctx->time_base.den /= gcd; | |
1047 s->avctx->time_base.num /= gcd; | |
1048 }else{ | |
1049 s->avctx->time_base= (AVRational){1001, 30000}; | |
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 | |
1075 s->mb_width = (s->width + 15) / 16; | |
1076 s->mb_height = (s->height + 15) / 16; | |
1077 s->mb_num = s->mb_width * s->mb_height; | |
1078 | |
1079 if (s->pb_frame) { | |
1080 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
1081 if (s->custom_pcf) | |
1082 skip_bits(&s->gb, 2); //extended Temporal reference | |
1083 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
1084 } | |
1085 | |
1086 /* PEI */ | |
1087 while (get_bits1(&s->gb) != 0) { | |
1088 skip_bits(&s->gb, 8); | |
1089 } | |
1090 | |
1091 if(s->h263_slice_structured){ | |
1092 if (get_bits1(&s->gb) != 1) { | |
1093 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
1094 return -1; | |
1095 } | |
1096 | |
1097 ff_h263_decode_mba(s); | |
1098 | |
1099 if (get_bits1(&s->gb) != 1) { | |
1100 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
1101 return -1; | |
1102 } | |
1103 } | |
1104 s->f_code = 1; | |
1105 | |
1106 if(s->h263_aic){ | |
1107 s->y_dc_scale_table= | |
1108 s->c_dc_scale_table= ff_aic_dc_scale_table; | |
1109 }else{ | |
1110 s->y_dc_scale_table= | |
1111 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
1112 } | |
1113 | |
1114 ff_h263_show_pict_info(s); | |
1115 if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){ | |
1116 int i,j; | |
1117 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
1118 av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
1119 for(i=0; i<13; i++){ | |
1120 for(j=0; j<3; j++){ | |
1121 int v= get_bits(&s->gb, 8); | |
1122 v |= get_sbits(&s->gb, 8)<<8; | |
1123 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); | |
1124 } | |
1125 av_log(s->avctx, AV_LOG_DEBUG, "\n"); | |
1126 } | |
1127 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); | |
1128 } | |
1129 | |
1130 return 0; | |
1131 } |