Mercurial > libavcodec.hg
annotate ituh263dec.c @ 12178:b3c39e9d4d3e libavcodec
aacenc: Template quantize_and_encode_band_cost().
author | alexc |
---|---|
date | Fri, 16 Jul 2010 20:02:46 +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 } |