Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 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 |
||
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 |
||
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 "unary.h" |
||
41 | #include "flv.h" |
||
42 | #include "mpeg4video.h" |
||
43 | |||
44 | // The defines below define the number of bits that are read at once for |
||
45 | // reading vlc values. Changing these may improve speed and data cache needs |
||
46 | // be aware though that decreasing them may need the number of stages that is |
||
47 | // passed to get_vlc* to be increased. |
||
48 | #define MV_VLC_BITS 9 |
||
49 | #define H263_MBTYPE_B_VLC_BITS 6 |
||
50 | #define CBPC_B_VLC_BITS 3 |
||
51 | |||
52 | static const int h263_mb_type_b_map[15]= { |
||
53 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1, |
||
54 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP, |
||
55 | MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT, |
||
56 | MB_TYPE_L0 | MB_TYPE_16x16, |
||
57 | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_16x16, |
||
58 | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, |
||
59 | MB_TYPE_L1 | MB_TYPE_16x16, |
||
60 | MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_16x16, |
||
61 | MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, |
||
62 | MB_TYPE_L0L1 | MB_TYPE_16x16, |
||
63 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_16x16, |
||
64 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16, |
||
65 | 0, //stuffing |
||
66 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP, |
||
67 | MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT, |
||
68 | }; |
||
69 | |||
70 | void ff_h263_show_pict_info(MpegEncContext *s){ |
||
71 | if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
||
72 | 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", |
||
73 | s->qscale, av_get_picture_type_char(s->pict_type), |
||
74 | s->gb.size_in_bits, 1-s->no_rounding, |
||
75 | s->obmc ? " AP" : "", |
||
76 | s->umvplus ? " UMV" : "", |
||
77 | s->h263_long_vectors ? " LONG" : "", |
||
78 | s->h263_plus ? " +" : "", |
||
79 | s->h263_aic ? " AIC" : "", |
||
80 | s->alt_inter_vlc ? " AIV" : "", |
||
81 | s->modified_quant ? " MQ" : "", |
||
82 | s->loop_filter ? " LOOP" : "", |
||
83 | s->h263_slice_structured ? " SS" : "", |
||
84 | s->avctx->time_base.den, s->avctx->time_base.num |
||
85 | ); |
||
86 | } |
||
87 | } |
||
88 | |||
89 | /***********************************************/ |
||
90 | /* decoding */ |
||
91 | |||
92 | VLC ff_h263_intra_MCBPC_vlc; |
||
93 | VLC ff_h263_inter_MCBPC_vlc; |
||
94 | VLC ff_h263_cbpy_vlc; |
||
95 | static VLC mv_vlc; |
||
96 | static VLC h263_mbtype_b_vlc; |
||
97 | static VLC cbpc_b_vlc; |
||
98 | |||
99 | /* init vlcs */ |
||
100 | |||
101 | /* XXX: find a better solution to handle static init */ |
||
102 | av_cold void ff_h263_decode_init_vlc(void) |
||
103 | { |
||
104 | static volatile int done = 0; |
||
105 | |||
106 | if (!done) { |
||
107 | INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
||
108 | ff_h263_intra_MCBPC_bits, 1, 1, |
||
109 | ff_h263_intra_MCBPC_code, 1, 1, 72); |
||
110 | INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
||
111 | ff_h263_inter_MCBPC_bits, 1, 1, |
||
112 | ff_h263_inter_MCBPC_code, 1, 1, 198); |
||
113 | INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16, |
||
114 | &ff_h263_cbpy_tab[0][1], 2, 1, |
||
115 | &ff_h263_cbpy_tab[0][0], 2, 1, 64); |
||
116 | INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, |
||
117 | &ff_mvtab[0][1], 2, 1, |
||
118 | &ff_mvtab[0][0], 2, 1, 538); |
||
119 | ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]); |
||
120 | ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]); |
||
121 | INIT_VLC_RL(ff_h263_rl_inter, 554); |
||
122 | INIT_VLC_RL(ff_rl_intra_aic, 554); |
||
123 | INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
||
124 | &ff_h263_mbtype_b_tab[0][1], 2, 1, |
||
125 | &ff_h263_mbtype_b_tab[0][0], 2, 1, 80); |
||
126 | INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
||
127 | &ff_cbpc_b_tab[0][1], 2, 1, |
||
128 | &ff_cbpc_b_tab[0][0], 2, 1, 8); |
||
129 | done = 1; |
||
130 | } |
||
131 | } |
||
132 | |||
133 | int ff_h263_decode_mba(MpegEncContext *s) |
||
134 | { |
||
135 | int i, mb_pos; |
||
136 | |||
137 | for(i=0; i<6; i++){ |
||
138 | if(s->mb_num-1 <= ff_mba_max[i]) break; |
||
139 | } |
||
140 | mb_pos= get_bits(&s->gb, ff_mba_length[i]); |
||
141 | s->mb_x= mb_pos % s->mb_width; |
||
142 | s->mb_y= mb_pos / s->mb_width; |
||
143 | |||
144 | return mb_pos; |
||
145 | } |
||
146 | |||
147 | /** |
||
148 | * Decode the group of blocks header or slice header. |
||
149 | * @return <0 if an error occurred |
||
150 | */ |
||
151 | static int h263_decode_gob_header(MpegEncContext *s) |
||
152 | { |
||
153 | unsigned int val, gob_number; |
||
154 | int left; |
||
155 | |||
156 | /* Check for GOB Start Code */ |
||
157 | val = show_bits(&s->gb, 16); |
||
158 | if(val) |
||
159 | return -1; |
||
160 | |||
161 | /* We have a GBSC probably with GSTUFF */ |
||
162 | skip_bits(&s->gb, 16); /* Drop the zeros */ |
||
163 | left= get_bits_left(&s->gb); |
||
164 | //MN: we must check the bits left or we might end in a infinite loop (or segfault) |
||
165 | for(;left>13; left--){ |
||
166 | if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
||
167 | } |
||
168 | if(left<=13) |
||
169 | return -1; |
||
170 | |||
171 | if(s->h263_slice_structured){ |
||
172 | if(get_bits1(&s->gb)==0) |
||
173 | return -1; |
||
174 | |||
175 | ff_h263_decode_mba(s); |
||
176 | |||
177 | if(s->mb_num > 1583) |
||
178 | if(get_bits1(&s->gb)==0) |
||
179 | return -1; |
||
180 | |||
181 | s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
||
182 | if(get_bits1(&s->gb)==0) |
||
183 | return -1; |
||
184 | skip_bits(&s->gb, 2); /* GFID */ |
||
185 | }else{ |
||
186 | gob_number = get_bits(&s->gb, 5); /* GN */ |
||
187 | s->mb_x= 0; |
||
188 | s->mb_y= s->gob_index* gob_number; |
||
189 | skip_bits(&s->gb, 2); /* GFID */ |
||
190 | s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
||
191 | } |
||
192 | |||
193 | if(s->mb_y >= s->mb_height) |
||
194 | return -1; |
||
195 | |||
196 | if(s->qscale==0) |
||
197 | return -1; |
||
198 | |||
199 | return 0; |
||
200 | } |
||
201 | |||
202 | /** |
||
203 | * Find the next resync_marker. |
||
204 | * @param p pointer to buffer to scan |
||
205 | * @param end pointer to the end of the buffer |
||
206 | * @return pointer to the next resync_marker, or end if none was found |
||
207 | */ |
||
208 | const uint8_t *ff_h263_find_resync_marker(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end) |
||
209 | { |
||
210 | av_assert2(p < end); |
||
211 | |||
212 | end-=2; |
||
213 | p++; |
||
214 | if(s->resync_marker){ |
||
215 | int prefix_len = ff_mpeg4_get_video_packet_prefix_length(s); |
||
216 | for(;p |
||
217 | if(!*p){ |
||
218 | if (!p[-1] && ((p[1] >> (23-prefix_len)) == 1)) return p - 1; |
||
219 | else if (!p[ 1] && ((p[2] >> (23-prefix_len)) == 1)) return p; |
||
220 | } |
||
221 | } |
||
222 | } |
||
223 | return end+2; |
||
224 | } |
||
225 | |||
226 | /** |
||
227 | * Decode the group of blocks / video packet header. |
||
228 | * @return bit position of the resync_marker, or <0 if none was found |
||
229 | */ |
||
230 | int ff_h263_resync(MpegEncContext *s){ |
||
231 | int left, pos, ret; |
||
232 | |||
233 | if(s->codec_id==AV_CODEC_ID_MPEG4){ |
||
234 | skip_bits1(&s->gb); |
||
235 | align_get_bits(&s->gb); |
||
236 | } |
||
237 | |||
238 | if(show_bits(&s->gb, 16)==0){ |
||
239 | pos= get_bits_count(&s->gb); |
||
240 | if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) |
||
241 | ret= ff_mpeg4_decode_video_packet_header(s); |
||
242 | else |
||
243 | ret= h263_decode_gob_header(s); |
||
244 | if(ret>=0) |
||
245 | return pos; |
||
246 | } |
||
247 | //OK, it's not where it is supposed to be ... |
||
248 | s->gb= s->last_resync_gb; |
||
249 | align_get_bits(&s->gb); |
||
250 | left= get_bits_left(&s->gb); |
||
251 | |||
252 | for(;left>16+1+5+5; left-=8){ |
||
253 | if(show_bits(&s->gb, 16)==0){ |
||
254 | GetBitContext bak= s->gb; |
||
255 | |||
256 | pos= get_bits_count(&s->gb); |
||
257 | if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4) |
||
258 | ret= ff_mpeg4_decode_video_packet_header(s); |
||
259 | else |
||
260 | ret= h263_decode_gob_header(s); |
||
261 | if(ret>=0) |
||
262 | return pos; |
||
263 | |||
264 | s->gb= bak; |
||
265 | } |
||
266 | skip_bits(&s->gb, 8); |
||
267 | } |
||
268 | |||
269 | return -1; |
||
270 | } |
||
271 | |||
272 | int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
||
273 | { |
||
274 | int code, val, sign, shift; |
||
275 | code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
||
276 | |||
277 | if (code == 0) |
||
278 | return pred; |
||
279 | if (code < 0) |
||
280 | return 0xffff; |
||
281 | |||
282 | sign = get_bits1(&s->gb); |
||
283 | shift = f_code - 1; |
||
284 | val = code; |
||
285 | if (shift) { |
||
286 | val = (val - 1) << shift; |
||
287 | val |= get_bits(&s->gb, shift); |
||
288 | val++; |
||
289 | } |
||
290 | if (sign) |
||
291 | val = -val; |
||
292 | val += pred; |
||
293 | |||
294 | /* modulo decoding */ |
||
295 | if (!s->h263_long_vectors) { |
||
296 | val = sign_extend(val, 5 + f_code); |
||
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 | /* Decode 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 | av_dlog(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 | av_assert2(s->pict_type == AV_PICTURE_TYPE_P); |
||
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= ff_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 = ff_h263_decode_motion(s, pred_x, 1); |
||
387 | |||
388 | if (s->umvplus) |
||
389 | my = h263p_decode_umotion(s, pred_y); |
||
390 | else |
||
391 | my = ff_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 = ff_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 = ff_h263_decode_motion(s, pred_x, 1); |
||
405 | |||
406 | if (s->umvplus) |
||
407 | my = h263p_decode_umotion(s, pred_y); |
||
408 | else |
||
409 | my = ff_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= ff_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, int16_t * 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 = &ff_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 == AV_CODEC_ID_RV10){ |
||
462 | #if CONFIG_RV10_DECODER |
||
463 | if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) { |
||
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 = ff_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->err_recognition & (AV_EF_BITSTREAM|AV_EF_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 == AV_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 = &ff_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 | ff_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 | { |
||
566 | LOCAL_ALIGNED_16(int16_t, dblock, [64]); |
||
567 | int i, mbi; |
||
568 | int bli[6]; |
||
569 | |||
570 | /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly |
||
571 | * but real value should be restored in order to be used later (in OBMC condition) |
||
572 | */ |
||
573 | mbi = s->mb_intra; |
||
574 | memcpy(bli, s->block_last_index, sizeof(bli)); |
||
575 | s->mb_intra = 0; |
||
576 | for (i = 0; i < 6; i++) { |
||
577 | if (h263_decode_block(s, dblock, i, cbp&32) < 0) |
||
578 | return -1; |
||
579 | cbp+=cbp; |
||
580 | } |
||
581 | s->mb_intra = mbi; |
||
582 | memcpy(s->block_last_index, bli, sizeof(bli)); |
||
583 | return 0; |
||
584 | } |
||
585 | |||
586 | static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) |
||
587 | { |
||
588 | int c, mv = 1; |
||
589 | |||
590 | if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame |
||
591 | c = get_bits1(gb); |
||
592 | if (pb_frame == 2 && c) |
||
593 | mv = !get_bits1(gb); |
||
594 | } else { // h.263 Annex M improved PB-frame |
||
595 | mv = get_unary(gb, 0, 4) + 1; |
||
596 | c = mv & 1; |
||
597 | mv = !!(mv & 2); |
||
598 | } |
||
599 | if(c) |
||
600 | *cbpb = get_bits(gb, 6); |
||
601 | return mv; |
||
602 | } |
||
603 | |||
604 | int ff_h263_decode_mb(MpegEncContext *s, |
||
605 | int16_t block[6][64]) |
||
606 | { |
||
607 | int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
||
608 | int16_t *mot_val; |
||
609 | const int xy= s->mb_x + s->mb_y * s->mb_stride; |
||
610 | int cbpb = 0, pb_mv_count = 0; |
||
611 | |||
612 | av_assert2(!s->h263_pred); |
||
613 | |||
614 | if (s->pict_type == AV_PICTURE_TYPE_P) { |
||
615 | do{ |
||
616 | if (get_bits1(&s->gb)) { |
||
617 | /* skip mb */ |
||
618 | s->mb_intra = 0; |
||
619 | for(i=0;i<6;i++) |
||
620 | s->block_last_index[i] = -1; |
||
621 | s->mv_dir = MV_DIR_FORWARD; |
||
622 | s->mv_type = MV_TYPE_16X16; |
||
623 | s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
||
624 | s->mv[0][0][0] = 0; |
||
625 | s->mv[0][0][1] = 0; |
||
626 | s->mb_skipped = !(s->obmc | s->loop_filter); |
||
627 | goto end; |
||
628 | } |
||
629 | cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
||
630 | if (cbpc < 0){ |
||
631 | av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
||
632 | return -1; |
||
633 | } |
||
634 | }while(cbpc == 20); |
||
635 | |||
636 | s->dsp.clear_blocks(s->block[0]); |
||
637 | |||
638 | dquant = cbpc & 8; |
||
639 | s->mb_intra = ((cbpc & 4) != 0); |
||
640 | if (s->mb_intra) goto intra; |
||
641 | |||
642 | if(s->pb_frame && get_bits1(&s->gb)) |
||
643 | pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
||
644 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); |
||
645 | |||
646 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
||
647 | cbpy ^= 0xF; |
||
648 | |||
649 | cbp = (cbpc & 3) | (cbpy << 2); |
||
650 | if (dquant) { |
||
651 | h263_decode_dquant(s); |
||
652 | } |
||
653 | |||
654 | s->mv_dir = MV_DIR_FORWARD; |
||
655 | if ((cbpc & 16) == 0) { |
||
656 | s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0; |
||
657 | /* 16x16 motion prediction */ |
||
658 | s->mv_type = MV_TYPE_16X16; |
||
659 | ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
||
660 | if (s->umvplus) |
||
661 | mx = h263p_decode_umotion(s, pred_x); |
||
662 | else |
||
663 | mx = ff_h263_decode_motion(s, pred_x, 1); |
||
664 | |||
665 | if (mx >= 0xffff) |
||
666 | return -1; |
||
667 | |||
668 | if (s->umvplus) |
||
669 | my = h263p_decode_umotion(s, pred_y); |
||
670 | else |
||
671 | my = ff_h263_decode_motion(s, pred_y, 1); |
||
672 | |||
673 | if (my >= 0xffff) |
||
674 | return -1; |
||
675 | s->mv[0][0][0] = mx; |
||
676 | s->mv[0][0][1] = my; |
||
677 | |||
678 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
||
679 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
||
680 | } else { |
||
681 | s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0; |
||
682 | s->mv_type = MV_TYPE_8X8; |
||
683 | for(i=0;i<4;i++) { |
||
684 | mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
||
685 | if (s->umvplus) |
||
686 | mx = h263p_decode_umotion(s, pred_x); |
||
687 | else |
||
688 | mx = ff_h263_decode_motion(s, pred_x, 1); |
||
689 | if (mx >= 0xffff) |
||
690 | return -1; |
||
691 | |||
692 | if (s->umvplus) |
||
693 | my = h263p_decode_umotion(s, pred_y); |
||
694 | else |
||
695 | my = ff_h263_decode_motion(s, pred_y, 1); |
||
696 | if (my >= 0xffff) |
||
697 | return -1; |
||
698 | s->mv[0][i][0] = mx; |
||
699 | s->mv[0][i][1] = my; |
||
700 | if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
||
701 | skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
||
702 | mot_val[0] = mx; |
||
703 | mot_val[1] = my; |
||
704 | } |
||
705 | } |
||
706 | } else if(s->pict_type==AV_PICTURE_TYPE_B) { |
||
707 | int mb_type; |
||
708 | const int stride= s->b8_stride; |
||
709 | int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)]; |
||
710 | int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)]; |
||
711 | // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
||
712 | |||
713 | //FIXME ugly |
||
714 | mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= |
||
715 | mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= |
||
716 | mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= |
||
717 | mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
||
718 | |||
719 | do{ |
||
720 | mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); |
||
721 | if (mb_type < 0){ |
||
722 | av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); |
||
723 | return -1; |
||
724 | } |
||
725 | |||
726 | mb_type= h263_mb_type_b_map[ mb_type ]; |
||
727 | }while(!mb_type); |
||
728 | |||
729 | s->mb_intra = IS_INTRA(mb_type); |
||
730 | if(HAS_CBP(mb_type)){ |
||
731 | s->dsp.clear_blocks(s->block[0]); |
||
732 | cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
||
733 | if(s->mb_intra){ |
||
734 | dquant = IS_QUANT(mb_type); |
||
735 | goto intra; |
||
736 | } |
||
737 | |||
738 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); |
||
739 | |||
740 | if (cbpy < 0){ |
||
741 | av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
||
742 | return -1; |
||
743 | } |
||
744 | |||
745 | if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
||
746 | cbpy ^= 0xF; |
||
747 | |||
748 | cbp = (cbpc & 3) | (cbpy << 2); |
||
749 | }else |
||
750 | cbp=0; |
||
751 | |||
752 | av_assert2(!s->mb_intra); |
||
753 | |||
754 | if(IS_QUANT(mb_type)){ |
||
755 | h263_decode_dquant(s); |
||
756 | } |
||
757 | |||
758 | if(IS_DIRECT(mb_type)){ |
||
759 | s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
||
760 | mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); |
||
761 | }else{ |
||
762 | s->mv_dir = 0; |
||
763 | s->mv_type= MV_TYPE_16X16; |
||
764 | //FIXME UMV |
||
765 | |||
766 | if(USES_LIST(mb_type, 0)){ |
||
767 | int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &mx, &my); |
||
768 | s->mv_dir = MV_DIR_FORWARD; |
||
769 | |||
770 | mx = ff_h263_decode_motion(s, mx, 1); |
||
771 | my = ff_h263_decode_motion(s, my, 1); |
||
772 | |||
773 | s->mv[0][0][0] = mx; |
||
774 | s->mv[0][0][1] = my; |
||
775 | mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
||
776 | mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
||
777 | } |
||
778 | |||
779 | if(USES_LIST(mb_type, 1)){ |
||
780 | int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &mx, &my); |
||
781 | s->mv_dir |= MV_DIR_BACKWARD; |
||
782 | |||
783 | mx = ff_h263_decode_motion(s, mx, 1); |
||
784 | my = ff_h263_decode_motion(s, my, 1); |
||
785 | |||
786 | s->mv[1][0][0] = mx; |
||
787 | s->mv[1][0][1] = my; |
||
788 | mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
||
789 | mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
||
790 | } |
||
791 | } |
||
792 | |||
793 | s->current_picture.mb_type[xy] = mb_type; |
||
794 | } else { /* I-Frame */ |
||
795 | do{ |
||
796 | cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
||
797 | if (cbpc < 0){ |
||
798 | av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
||
799 | return -1; |
||
800 | } |
||
801 | }while(cbpc == 8); |
||
802 | |||
803 | s->dsp.clear_blocks(s->block[0]); |
||
804 | |||
805 | dquant = cbpc & 4; |
||
806 | s->mb_intra = 1; |
||
807 | intra: |
||
808 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA; |
||
809 | if (s->h263_aic) { |
||
810 | s->ac_pred = get_bits1(&s->gb); |
||
811 | if(s->ac_pred){ |
||
812 | s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED; |
||
813 | |||
814 | s->h263_aic_dir = get_bits1(&s->gb); |
||
815 | } |
||
816 | }else |
||
817 | s->ac_pred = 0; |
||
818 | |||
819 | if(s->pb_frame && get_bits1(&s->gb)) |
||
820 | pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
||
821 | cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); |
||
822 | if(cbpy<0){ |
||
823 | av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
||
824 | return -1; |
||
825 | } |
||
826 | cbp = (cbpc & 3) | (cbpy << 2); |
||
827 | if (dquant) { |
||
828 | h263_decode_dquant(s); |
||
829 | } |
||
830 | |||
831 | pb_mv_count += !!s->pb_frame; |
||
832 | } |
||
833 | |||
834 | while(pb_mv_count--){ |
||
835 | ff_h263_decode_motion(s, 0, 1); |
||
836 | ff_h263_decode_motion(s, 0, 1); |
||
837 | } |
||
838 | |||
839 | /* decode each block */ |
||
840 | for (i = 0; i < 6; i++) { |
||
841 | if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
||
842 | return -1; |
||
843 | cbp+=cbp; |
||
844 | } |
||
845 | |||
846 | if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) |
||
847 | return -1; |
||
848 | if(s->obmc && !s->mb_intra){ |
||
849 | if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1 |
||
850 | preview_obmc(s); |
||
851 | } |
||
852 | end: |
||
853 | |||
854 | /* per-MB end of slice check */ |
||
855 | { |
||
856 | int v= show_bits(&s->gb, 16); |
||
857 | |||
858 | if (get_bits_left(&s->gb) < 16) { |
||
859 | v >>= 16 - get_bits_left(&s->gb); |
||
860 | } |
||
861 | |||
862 | if(v==0) |
||
863 | return SLICE_END; |
||
864 | } |
||
865 | |||
866 | return SLICE_OK; |
||
867 | } |
||
868 | |||
869 | /* most is hardcoded. should extend to handle all h263 streams */ |
||
870 | int ff_h263_decode_picture_header(MpegEncContext *s) |
||
871 | { |
||
872 | int format, width, height, i; |
||
873 | uint32_t startcode; |
||
874 | |||
875 | align_get_bits(&s->gb); |
||
876 | |||
877 | if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) { |
||
878 | av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n"); |
||
879 | } |
||
880 | |||
881 | startcode= get_bits(&s->gb, 22-8); |
||
882 | |||
883 | for(i= get_bits_left(&s->gb); i>24; i-=8) { |
||
884 | startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
||
885 | |||
886 | if(startcode == 0x20) |
||
887 | break; |
||
888 | } |
||
889 | |||
890 | if (startcode != 0x20) { |
||
891 | av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
||
892 | return -1; |
||
893 | } |
||
894 | /* temporal reference */ |
||
895 | i = get_bits(&s->gb, 8); /* picture timestamp */ |
||
896 | if( (s->picture_number&~0xFF)+i < s->picture_number) |
||
897 | i+= 256; |
||
898 | s->current_picture_ptr->f.pts = |
||
899 | s->picture_number= (s->picture_number&~0xFF) + i; |
||
900 | |||
901 | /* PTYPE starts here */ |
||
902 | if (get_bits1(&s->gb) != 1) { |
||
903 | /* marker */ |
||
904 | av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
||
905 | return -1; |
||
906 | } |
||
907 | if (get_bits1(&s->gb) != 0) { |
||
908 | av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
||
909 | return -1; /* h263 id */ |
||
910 | } |
||
911 | skip_bits1(&s->gb); /* split screen off */ |
||
912 | skip_bits1(&s->gb); /* camera off */ |
||
913 | skip_bits1(&s->gb); /* freeze picture release off */ |
||
914 | |||
915 | format = get_bits(&s->gb, 3); |
||
916 | /* |
||
917 | |||
918 | 1 sub-QCIF |
||
919 | 10 QCIF |
||
920 | 7 extended PTYPE (PLUSPTYPE) |
||
921 | */ |
||
922 | |||
923 | if (format != 7 && format != 6) { |
||
924 | s->h263_plus = 0; |
||
925 | /* H.263v1 */ |
||
926 | width = ff_h263_format[format][0]; |
||
927 | height = ff_h263_format[format][1]; |
||
928 | if (!width) |
||
929 | return -1; |
||
930 | |||
931 | s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb); |
||
932 | |||
933 | s->h263_long_vectors = get_bits1(&s->gb); |
||
934 | |||
935 | if (get_bits1(&s->gb) != 0) { |
||
936 | av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
||
937 | return -1; /* SAC: off */ |
||
938 | } |
||
939 | s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
||
940 | s->unrestricted_mv = s->h263_long_vectors || s->obmc; |
||
941 | |||
942 | s->pb_frame = get_bits1(&s->gb); |
||
943 | s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
||
944 | skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
||
945 | |||
946 | s->width = width; |
||
947 | s->height = height; |
||
948 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
||
949 | s->avctx->time_base= (AVRational){1001, 30000}; |
||
950 | } else { |
||
951 | int ufep; |
||
952 | |||
953 | /* H.263v2 */ |
||
954 | s->h263_plus = 1; |
||
955 | ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ |
||
956 | |||
957 | /* ufep other than 0 and 1 are reserved */ |
||
958 | if (ufep == 1) { |
||
959 | /* OPPTYPE */ |
||
960 | format = get_bits(&s->gb, 3); |
||
961 | av_dlog(s->avctx, "ufep=1, format: %d\n", format); |
||
962 | s->custom_pcf= get_bits1(&s->gb); |
||
963 | s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
||
964 | if (get_bits1(&s->gb) != 0) { |
||
965 | av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); |
||
966 | } |
||
967 | s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
||
968 | s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ |
||
969 | s->loop_filter= get_bits1(&s->gb); |
||
970 | s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; |
||
971 | if(s->avctx->lowres) |
||
972 | s->loop_filter = 0; |
||
973 | |||
974 | s->h263_slice_structured= get_bits1(&s->gb); |
||
975 | if (get_bits1(&s->gb) != 0) { |
||
976 | av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); |
||
977 | } |
||
978 | if (get_bits1(&s->gb) != 0) { |
||
979 | av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); |
||
980 | } |
||
981 | s->alt_inter_vlc= get_bits1(&s->gb); |
||
982 | s->modified_quant= get_bits1(&s->gb); |
||
983 | if(s->modified_quant) |
||
984 | s->chroma_qscale_table= ff_h263_chroma_qscale_table; |
||
985 | |||
986 | skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
||
987 | |||
988 | skip_bits(&s->gb, 3); /* Reserved */ |
||
989 | } else if (ufep != 0) { |
||
990 | av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
||
991 | return -1; |
||
992 | } |
||
993 | |||
994 | /* MPPTYPE */ |
||
995 | s->pict_type = get_bits(&s->gb, 3); |
||
996 | switch(s->pict_type){ |
||
997 | case 0: s->pict_type= AV_PICTURE_TYPE_I;break; |
||
998 | case 1: s->pict_type= AV_PICTURE_TYPE_P;break; |
||
999 | case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break; |
||
1000 | case 3: s->pict_type= AV_PICTURE_TYPE_B;break; |
||
1001 | case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO |
||
1002 | default: |
||
1003 | return -1; |
||
1004 | } |
||
1005 | skip_bits(&s->gb, 2); |
||
1006 | s->no_rounding = get_bits1(&s->gb); |
||
1007 | skip_bits(&s->gb, 4); |
||
1008 | |||
1009 | /* Get the picture dimensions */ |
||
1010 | if (ufep) { |
||
1011 | if (format == 6) { |
||
1012 | /* Custom Picture Format (CPFMT) */ |
||
1013 | s->aspect_ratio_info = get_bits(&s->gb, 4); |
||
1014 | av_dlog(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
||
1015 | /* aspect ratios: |
||
1016 | |||
1017 | 1 - 1:1 |
||
1018 | 2 - 12:11 (CIF 4:3) |
||
1019 | 3 - 10:11 (525-type 4:3) |
||
1020 | 4 - 16:11 (CIF 16:9) |
||
1021 | 5 - 40:33 (525-type 16:9) |
||
1022 | 6-14 - reserved |
||
1023 | */ |
||
1024 | width = (get_bits(&s->gb, 9) + 1) * 4; |
||
1025 | skip_bits1(&s->gb); |
||
1026 | height = get_bits(&s->gb, 9) * 4; |
||
1027 | av_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); |
||
1028 | if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
||
1029 | /* aspected dimensions */ |
||
1030 | s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
||
1031 | s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); |
||
1032 | }else{ |
||
1033 | s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info]; |
||
1034 | } |
||
1035 | } else { |
||
1036 | width = ff_h263_format[format][0]; |
||
1037 | height = ff_h263_format[format][1]; |
||
1038 | s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
||
1039 | } |
||
1040 | s->avctx->sample_aspect_ratio.den <<= s->ehc_mode; |
||
1041 | if ((width == 0) || (height == 0)) |
||
1042 | return -1; |
||
1043 | s->width = width; |
||
1044 | s->height = height; |
||
1045 | |||
1046 | if(s->custom_pcf){ |
||
1047 | int gcd; |
||
1048 | s->avctx->time_base.den= 1800000; |
||
1049 | s->avctx->time_base.num= 1000 + get_bits1(&s->gb); |
||
1050 | s->avctx->time_base.num*= get_bits(&s->gb, 7); |
||
1051 | if(s->avctx->time_base.num == 0){ |
||
1052 | av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
||
1053 | return -1; |
||
1054 | } |
||
1055 | gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
||
1056 | s->avctx->time_base.den /= gcd; |
||
1057 | s->avctx->time_base.num /= gcd; |
||
1058 | }else{ |
||
1059 | s->avctx->time_base= (AVRational){1001, 30000}; |
||
1060 | } |
||
1061 | } |
||
1062 | |||
1063 | if(s->custom_pcf){ |
||
1064 | skip_bits(&s->gb, 2); //extended Temporal reference |
||
1065 | } |
||
1066 | |||
1067 | if (ufep) { |
||
1068 | if (s->umvplus) { |
||
1069 | if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
||
1070 | skip_bits1(&s->gb); |
||
1071 | } |
||
1072 | if(s->h263_slice_structured){ |
||
1073 | if (get_bits1(&s->gb) != 0) { |
||
1074 | av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); |
||
1075 | } |
||
1076 | if (get_bits1(&s->gb) != 0) { |
||
1077 | av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); |
||
1078 | } |
||
1079 | } |
||
1080 | } |
||
1081 | |||
1082 | s->qscale = get_bits(&s->gb, 5); |
||
1083 | } |
||
1084 | |||
1085 | if (s->width == 0 || s->height == 0) { |
||
1086 | av_log(s->avctx, AV_LOG_ERROR, "dimensions 0\n"); |
||
1087 | return -1; |
||
1088 | } |
||
1089 | s->mb_width = (s->width + 15) / 16; |
||
1090 | s->mb_height = (s->height + 15) / 16; |
||
1091 | s->mb_num = s->mb_width * s->mb_height; |
||
1092 | |||
1093 | if (s->pb_frame) { |
||
1094 | skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ |
||
1095 | if (s->custom_pcf) |
||
1096 | skip_bits(&s->gb, 2); //extended Temporal reference |
||
1097 | skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ |
||
1098 | } |
||
1099 | |||
1100 | if (s->pict_type!=AV_PICTURE_TYPE_B) { |
||
1101 | s->time = s->picture_number; |
||
1102 | s->pp_time = s->time - s->last_non_b_time; |
||
1103 | s->last_non_b_time = s->time; |
||
1104 | }else{ |
||
1105 | s->time = s->picture_number; |
||
1106 | s->pb_time = s->pp_time - (s->last_non_b_time - s->time); |
||
1107 | if (s->pp_time <=s->pb_time || |
||
1108 | s->pp_time <= s->pp_time - s->pb_time || |
||
1109 | s->pp_time <= 0){ |
||
1110 | s->pp_time = 2; |
||
1111 | s->pb_time = 1; |
||
1112 | } |
||
1113 | ff_mpeg4_init_direct_mv(s); |
||
1114 | } |
||
1115 | |||
1116 | /* PEI */ |
||
1117 | while (get_bits1(&s->gb) != 0) { |
||
1118 | skip_bits(&s->gb, 8); |
||
1119 | } |
||
1120 | |||
1121 | if(s->h263_slice_structured){ |
||
1122 | if (get_bits1(&s->gb) != 1) { |
||
1123 | av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); |
||
1124 | return -1; |
||
1125 | } |
||
1126 | |||
1127 | ff_h263_decode_mba(s); |
||
1128 | |||
1129 | if (get_bits1(&s->gb) != 1) { |
||
1130 | av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); |
||
1131 | return -1; |
||
1132 | } |
||
1133 | } |
||
1134 | s->f_code = 1; |
||
1135 | |||
1136 | if(s->h263_aic){ |
||
1137 | s->y_dc_scale_table= |
||
1138 | s->c_dc_scale_table= ff_aic_dc_scale_table; |
||
1139 | }else{ |
||
1140 | s->y_dc_scale_table= |
||
1141 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
||
1142 | } |
||
1143 | |||
1144 | ff_h263_show_pict_info(s); |
||
1145 | if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){ |
||
1146 | int i,j; |
||
1147 | for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
||
1148 | av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
||
1149 | for(i=0; i<13; i++){ |
||
1150 | for(j=0; j<3; j++){ |
||
1151 | int v= get_bits(&s->gb, 8); |
||
1152 | v |= get_sbits(&s->gb, 8)<<8; |
||
1153 | av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); |
||
1154 | } |
||
1155 | av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
||
1156 | } |
||
1157 | for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
||
1158 | } |
||
1159 | |||
1160 | return 0; |
||
1161 | }50;>8; |