ffmpeg / libavcodec / ituh263dec.c @ 2912e87a
History  View  Annotate  Download (35.6 KB)
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) 20022004 Michael Niedermayer <michaelni@gmx.at>

7 
*

8 
* This file is part of Libav.

9 
*

10 
* Libav 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 
* Libav 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 Libav; if not, write to the Free Software

22 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

23 
*/

24  
25 
/**

26 
* @file

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, 1s>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_num1 <= 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 
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 
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 
{ 
566 
LOCAL_ALIGNED_16(DCTELEM, dblock, [64]);

567 
int i, mbi;

568  
569 
/* we have to set s>mb_intra to zero to decode Bpart of PBframe 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 PBframe 
588 
c = get_bits1(gb); 
589 
if (pb_frame == 2 && c) 
590 
mv = !get_bits1(gb); 
591 
} else { // h.263 Annex M improved PBframe 
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 { /* IFrame */ 
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 
/* perMB 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, 228); 
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 subQCIF

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 
av_dlog(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, "Syntaxbased 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 
av_dlog(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 (525type 4:3)

1011 
4  16:11 (CIF 16:9)

1012 
5  40:33 (525type 16:9)

1013 
614  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 
av_dlog(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 Bpictures */ 
1081 
if (s>custom_pcf)

1082 
skip_bits(&s>gb, 2); //extended Temporal reference 
1083 
skip_bits(&s>gb, 2); /* Quantization information for Bpictures */ 
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 
} 