ffmpeg / libavcodec / h263.c @ 8f8402e4
History  View  Annotate  Download (130 KB)
1 
/*


2 
* H263/MPEG4 backend for ffmpeg encoder and decoder

3 
* Copyright (c) 2000,2001 Fabrice Bellard.

4 
* H263+ support.

5 
* Copyright (c) 2001 Juan J. Sierralta P.

6 
*

7 
* This library is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2 of the License, or (at your option) any later version.

11 
*

12 
* This library is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with this library; if not, write to the Free Software

19 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 021111307 USA

20 
*

21 
* ac prediction encoding & bframe support by Michael Niedermayer <michaelni@gmx.at>

22 
*/

23 

24 
//#define DEBUG

25 
#include "common.h" 
26 
#include "dsputil.h" 
27 
#include "avcodec.h" 
28 
#include "mpegvideo.h" 
29 
#include "h263data.h" 
30 
#include "mpeg4data.h" 
31  
32 
//rounded divison & shift

33 
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)1)))>>(b) : ((a) + (1<<((b)1))1)>>(b)) 
34  
35 
#define PRINT_MB_TYPE(a) ;

36 
//#define PRINT_MB_TYPE(a) printf(a);

37  
38 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, 
39 
int n);

40 
static void h263_encode_motion(MpegEncContext * s, int val, int fcode); 
41 
static void h263p_encode_umotion(MpegEncContext * s, int val); 
42 
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, 
43 
int n, int dc, UINT8 *scan_table, 
44 
PutBitContext *dc_pb, PutBitContext *ac_pb); 
45 
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); 
46 
static int h263p_decode_umotion(MpegEncContext * s, int pred); 
47 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
48 
int n, int coded); 
49 
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); 
50 
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
51 
int n, int coded); 
52 
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr); 
53 
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, 
54 
int dir);

55 
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); 
56  
57 
extern UINT32 inverse[256]; 
58  
59 
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 
60 
static UINT8 fcode_tab[MAX_MV*2+1]; 
61 
static UINT8 umv_fcode_tab[MAX_MV*2+1]; 
62  
63 
static UINT16 uni_DCtab_lum [512][2]; 
64 
static UINT16 uni_DCtab_chrom[512][2]; 
65  
66 
int h263_get_picture_format(int width, int height) 
67 
{ 
68 
int format;

69  
70 
if (width == 128 && height == 96) 
71 
format = 1;

72 
else if (width == 176 && height == 144) 
73 
format = 2;

74 
else if (width == 352 && height == 288) 
75 
format = 3;

76 
else if (width == 704 && height == 576) 
77 
format = 4;

78 
else if (width == 1408 && height == 1152) 
79 
format = 5;

80 
else

81 
format = 7;

82 
return format;

83 
} 
84  
85 
void h263_encode_picture_header(MpegEncContext * s, int picture_number) 
86 
{ 
87 
int format;

88  
89 
align_put_bits(&s>pb); 
90  
91 
/* Update the pointer to last GOB */

92 
s>ptr_lastgob = pbBufPtr(&s>pb); 
93 
s>gob_number = 0;

94  
95 
put_bits(&s>pb, 22, 0x20); /* PSC */ 
96 
put_bits(&s>pb, 8, (((INT64)s>picture_number * 30 * FRAME_RATE_BASE) / 
97 
s>frame_rate) & 0xff);

98  
99 
put_bits(&s>pb, 1, 1); /* marker */ 
100 
put_bits(&s>pb, 1, 0); /* h263 id */ 
101 
put_bits(&s>pb, 1, 0); /* split screen off */ 
102 
put_bits(&s>pb, 1, 0); /* camera off */ 
103 
put_bits(&s>pb, 1, 0); /* freeze picture release off */ 
104 

105 
format = h263_get_picture_format(s>width, s>height); 
106 
if (!s>h263_plus) {

107 
/* H.263v1 */

108 
put_bits(&s>pb, 3, format);

109 
put_bits(&s>pb, 1, (s>pict_type == P_TYPE));

110 
/* By now UMV IS DISABLED ON H.263v1, since the restrictions

111 
of H.263v1 UMV implies to check the predicted MV after

112 
calculation of the current MB to see if we're on the limits */

113 
put_bits(&s>pb, 1, 0); /* unrestricted motion vector: off */ 
114 
put_bits(&s>pb, 1, 0); /* SAC: off */ 
115 
put_bits(&s>pb, 1, 0); /* advanced prediction mode: off */ 
116 
put_bits(&s>pb, 1, 0); /* not PB frame */ 
117 
put_bits(&s>pb, 5, s>qscale);

118 
put_bits(&s>pb, 1, 0); /* Continuous Presence Multipoint mode: off */ 
119 
} else {

120 
/* H.263v2 */

121 
/* H.263 Plus PTYPE */

122 
put_bits(&s>pb, 3, 7); 
123 
put_bits(&s>pb,3,1); /* Update Full Extended PTYPE */ 
124 
if (format == 7) 
125 
put_bits(&s>pb,3,6); /* Custom Source Format */ 
126 
else

127 
put_bits(&s>pb, 3, format);

128 

129 
put_bits(&s>pb,1,0); /* Custom PCF: off */ 
130 
s>umvplus = (s>pict_type == P_TYPE) && s>unrestricted_mv; 
131 
put_bits(&s>pb, 1, s>umvplus); /* Unrestricted Motion Vector */ 
132 
put_bits(&s>pb,1,0); /* SAC: off */ 
133 
put_bits(&s>pb,1,0); /* Advanced Prediction Mode: off */ 
134 
put_bits(&s>pb,1,s>h263_aic); /* Advanced Intra Coding */ 
135 
put_bits(&s>pb,1,0); /* Deblocking Filter: off */ 
136 
put_bits(&s>pb,1,0); /* Slice Structured: off */ 
137 
put_bits(&s>pb,1,0); /* Reference Picture Selection: off */ 
138 
put_bits(&s>pb,1,0); /* Independent Segment Decoding: off */ 
139 
put_bits(&s>pb,1,0); /* Alternative Inter VLC: off */ 
140 
put_bits(&s>pb,1,0); /* Modified Quantization: off */ 
141 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
142 
put_bits(&s>pb,3,0); /* Reserved */ 
143 

144 
put_bits(&s>pb, 3, s>pict_type == P_TYPE);

145 

146 
put_bits(&s>pb,1,0); /* Reference Picture Resampling: off */ 
147 
put_bits(&s>pb,1,0); /* ReducedResolution Update: off */ 
148 
if (s>pict_type == I_TYPE)

149 
s>no_rounding = 0;

150 
else

151 
s>no_rounding ^= 1;

152 
put_bits(&s>pb,1,s>no_rounding); /* Rounding Type */ 
153 
put_bits(&s>pb,2,0); /* Reserved */ 
154 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
155 

156 
/* This should be here if PLUSPTYPE */

157 
put_bits(&s>pb, 1, 0); /* Continuous Presence Multipoint mode: off */ 
158 

159 
if (format == 7) { 
160 
/* Custom Picture Format (CPFMT) */

161 

162 
if (s>aspect_ratio_info)

163 
put_bits(&s>pb,4,s>aspect_ratio_info);

164 
else

165 
put_bits(&s>pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */ 
166 
put_bits(&s>pb,9,(s>width >> 2)  1); 
167 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
168 
put_bits(&s>pb,9,(s>height >> 2)); 
169 
} 
170 

171 
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

172 
if (s>umvplus)

173 
put_bits(&s>pb,1,1); /* Limited according tables of Annex D */ 
174 
put_bits(&s>pb, 5, s>qscale);

175 
} 
176  
177 
put_bits(&s>pb, 1, 0); /* no PEI */ 
178  
179 
if(s>h263_aic){

180 
s>y_dc_scale_table= 
181 
s>c_dc_scale_table= h263_aic_dc_scale_table; 
182 
}else{

183 
s>y_dc_scale_table= 
184 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
185 
} 
186 
} 
187  
188 
int h263_encode_gob_header(MpegEncContext * s, int mb_line) 
189 
{ 
190 
int pdif=0; 
191 

192 
/* Check to see if we need to put a new GBSC */

193 
/* for RTP packetization */

194 
if (s>rtp_mode) {

195 
pdif = pbBufPtr(&s>pb)  s>ptr_lastgob; 
196 
if (pdif >= s>rtp_payload_size) {

197 
/* Bad luck, packet must be cut before */

198 
align_put_bits(&s>pb); 
199 
flush_put_bits(&s>pb); 
200 
/* Call the RTP callback to send the last GOB */

201 
if (s>rtp_callback) {

202 
pdif = pbBufPtr(&s>pb)  s>ptr_lastgob; 
203 
s>rtp_callback(s>ptr_lastgob, pdif, s>gob_number); 
204 
} 
205 
s>ptr_lastgob = pbBufPtr(&s>pb); 
206 
put_bits(&s>pb, 17, 1); /* GBSC */ 
207 
s>gob_number = mb_line / s>gob_index; 
208 
put_bits(&s>pb, 5, s>gob_number); /* GN */ 
209 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
210 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
211 
//fprintf(stderr,"\nGOB: %2d size: %d", s>gob_number  1, pdif);

212 
return pdif;

213 
} else if (pdif + s>mb_line_avgsize >= s>rtp_payload_size) { 
214 
/* Cut the packet before we can't */

215 
align_put_bits(&s>pb); 
216 
flush_put_bits(&s>pb); 
217 
/* Call the RTP callback to send the last GOB */

218 
if (s>rtp_callback) {

219 
pdif = pbBufPtr(&s>pb)  s>ptr_lastgob; 
220 
s>rtp_callback(s>ptr_lastgob, pdif, s>gob_number); 
221 
} 
222 
s>ptr_lastgob = pbBufPtr(&s>pb); 
223 
put_bits(&s>pb, 17, 1); /* GBSC */ 
224 
s>gob_number = mb_line / s>gob_index; 
225 
put_bits(&s>pb, 5, s>gob_number); /* GN */ 
226 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
227 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
228 
//fprintf(stderr,"\nGOB: %2d size: %d", s>gob_number  1, pdif);

229 
return pdif;

230 
} 
231 
} 
232 
return 0; 
233 
} 
234  
235 
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6]) 
236 
{ 
237 
int score0=0, score1=0; 
238 
int i, n;

239  
240 
for(n=0; n<6; n++){ 
241 
INT16 *ac_val, *ac_val1; 
242  
243 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
244 
ac_val1= ac_val; 
245 
if(dir[n]){

246 
ac_val= s>block_wrap[n]*16;

247 
for(i=1; i<8; i++){ 
248 
const int level= block[n][block_permute_op(i )]; 
249 
score0+= ABS(level); 
250 
score1+= ABS(level  ac_val[i+8]);

251 
ac_val1[i ]= block[n][block_permute_op(i<<3)];

252 
ac_val1[i+8]= level;

253 
} 
254 
}else{

255 
ac_val= 16;

256 
for(i=1; i<8; i++){ 
257 
const int level= block[n][block_permute_op(i<<3)]; 
258 
score0+= ABS(level); 
259 
score1+= ABS(level  ac_val[i]); 
260 
ac_val1[i ]= level; 
261 
ac_val1[i+8]= block[n][block_permute_op(i )];

262 
} 
263 
} 
264 
} 
265  
266 
return score0 > score1 ? 1 : 0; 
267 
} 
268  
269 
void mpeg4_encode_mb(MpegEncContext * s,

270 
DCTELEM block[6][64], 
271 
int motion_x, int motion_y) 
272 
{ 
273 
int cbpc, cbpy, i, pred_x, pred_y;

274 
int bits;

275 
PutBitContext * const pb2 = s>data_partitioning ? &s>pb2 : &s>pb;

276 
PutBitContext * const tex_pb = s>data_partitioning && s>pict_type!=B_TYPE ? &s>tex_pb : &s>pb;

277 
PutBitContext * const dc_pb = s>data_partitioning && s>pict_type!=I_TYPE ? &s>pb2 : &s>pb;

278 
const int interleaved_stats= (s>flags&CODEC_FLAG_PASS1) && !s>data_partitioning ? 1 : 0; 
279 

280 
// printf("**mb x=%d y=%d\n", s>mb_x, s>mb_y);

281 
if (!s>mb_intra) {

282 
/* compute cbp */

283 
int cbp = 0; 
284 
for (i = 0; i < 6; i++) { 
285 
if (s>block_last_index[i] >= 0) 
286 
cbp = 1 << (5  i); 
287 
} 
288  
289 
if(s>pict_type==B_TYPE){

290 
static const int mb_type_table[8]= {1, 2, 3, 1,1,1,1, 0}; /* convert from mv_dir to type */ 
291 
int mb_type= mb_type_table[s>mv_dir];

292 

293 
if(s>mb_x==0){ 
294 
s>last_mv[0][0][0]= 
295 
s>last_mv[0][0][1]= 
296 
s>last_mv[1][0][0]= 
297 
s>last_mv[1][0][1]= 0; 
298 
} 
299  
300 
/* nothing to do if this MB was skiped in the next P Frame */

301 
if(s>mbskip_table[s>mb_y * s>mb_width + s>mb_x]){

302 
s>skip_count++; 
303 
s>mv[0][0][0]= 
304 
s>mv[0][0][1]= 
305 
s>mv[1][0][0]= 
306 
s>mv[1][0][1]= 0; 
307 
s>mv_dir= MV_DIR_FORWARD; //doesnt matter

308 
return;

309 
} 
310  
311 
if ((cbp  motion_x  motion_y  mb_type) ==0) { 
312 
/* direct MB with MV={0,0} */

313 
put_bits(&s>pb, 1, 1); /* mb not coded modb1=1 */ 
314  
315 
if(interleaved_stats){

316 
s>misc_bits++; 
317 
s>last_bits++; 
318 
} 
319 
s>skip_count++; 
320 
return;

321 
} 
322 
put_bits(&s>pb, 1, 0); /* mb coded modb1=0 */ 
323 
put_bits(&s>pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge 
324 
put_bits(&s>pb, mb_type+1, 1); // this table is so simple that we dont need it :) 
325 
if(cbp) put_bits(&s>pb, 6, cbp); 
326 

327 
if(cbp && mb_type)

328 
put_bits(&s>pb, 1, 0); /* no qscale change */ 
329  
330 
if(interleaved_stats){

331 
bits= get_bit_count(&s>pb); 
332 
s>misc_bits+= bits  s>last_bits; 
333 
s>last_bits=bits; 
334 
} 
335  
336 
switch(mb_type)

337 
{ 
338 
case 0: /* direct */ 
339 
h263_encode_motion(s, motion_x, 1);

340 
h263_encode_motion(s, motion_y, 1);

341 
break;

342 
case 1: /* bidir */ 
343 
h263_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
344 
h263_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
345 
h263_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
346 
h263_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
347 
s>last_mv[0][0][0]= s>mv[0][0][0]; 
348 
s>last_mv[0][0][1]= s>mv[0][0][1]; 
349 
s>last_mv[1][0][0]= s>mv[1][0][0]; 
350 
s>last_mv[1][0][1]= s>mv[1][0][1]; 
351 
break;

352 
case 2: /* backward */ 
353 
h263_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
354 
h263_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
355 
s>last_mv[1][0][0]= motion_x; 
356 
s>last_mv[1][0][1]= motion_y; 
357 
break;

358 
case 3: /* forward */ 
359 
h263_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
360 
h263_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
361 
s>last_mv[0][0][0]= motion_x; 
362 
s>last_mv[0][0][1]= motion_y; 
363 
break;

364 
default:

365 
printf("unknown mb type\n");

366 
return;

367 
} 
368  
369 
if(interleaved_stats){

370 
bits= get_bit_count(&s>pb); 
371 
s>mv_bits+= bits  s>last_bits; 
372 
s>last_bits=bits; 
373 
} 
374  
375 
/* encode each block */

376 
for (i = 0; i < 6; i++) { 
377 
mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s>pb); 
378 
} 
379  
380 
if(interleaved_stats){

381 
bits= get_bit_count(&s>pb); 
382 
s>p_tex_bits+= bits  s>last_bits; 
383 
s>last_bits=bits; 
384 
} 
385 
}else{ /* s>pict_type==B_TYPE */ 
386 
if ((cbp  motion_x  motion_y) == 0 && s>mv_type==MV_TYPE_16X16) { 
387 
/* check if the B frames can skip it too, as we must skip it if we skip here

388 
why didnt they just compress the skipmb bits instead of reusing them ?! */

389 
if(s>max_b_frames>0){ 
390 
int i;

391 
int x,y, offset;

392 
uint8_t *p_pic; 
393  
394 
x= s>mb_x*16;

395 
y= s>mb_y*16;

396 
if(x+16 > s>width) x= s>width16; 
397 
if(y+16 > s>height) y= s>height16; 
398  
399 
offset= x + y*s>linesize; 
400 
p_pic= s>new_picture[0] + offset;

401 

402 
s>mb_skiped=1;

403 
for(i=0; i<s>max_b_frames; i++){ 
404 
uint8_t *b_pic; 
405 
int diff;

406  
407 
if(s>coded_order[i+1].pict_type!=B_TYPE) break; 
408  
409 
b_pic= s>coded_order[i+1].picture[0] + offset; 
410 
diff= pix_abs16x16(p_pic, b_pic, s>linesize); 
411 
if(diff>s>qscale*70){ //FIXME check that 70 is optimal 
412 
s>mb_skiped=0;

413 
break;

414 
} 
415 
} 
416 
}else

417 
s>mb_skiped=1;

418  
419 
if(s>mb_skiped==1){ 
420 
/* skip macroblock */

421 
put_bits(&s>pb, 1, 1); 
422  
423 
if(interleaved_stats){

424 
s>misc_bits++; 
425 
s>last_bits++; 
426 
} 
427 
s>skip_count++; 
428 
return;

429 
} 
430 
} 
431  
432 
put_bits(&s>pb, 1, 0); /* mb coded */ 
433 
if(s>mv_type==MV_TYPE_16X16){

434 
cbpc = cbp & 3;

435 
put_bits(&s>pb, 
436 
inter_MCBPC_bits[cbpc], 
437 
inter_MCBPC_code[cbpc]); 
438 
cbpy = cbp >> 2;

439 
cbpy ^= 0xf;

440 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
441 

442 
if(interleaved_stats){

443 
bits= get_bit_count(&s>pb); 
444 
s>misc_bits+= bits  s>last_bits; 
445 
s>last_bits=bits; 
446 
} 
447  
448 
/* motion vectors: 16x16 mode */

449 
h263_pred_motion(s, 0, &pred_x, &pred_y);

450 

451 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
452 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
453 
}else{

454 
cbpc = (cbp & 3)+16; 
455 
put_bits(&s>pb, 
456 
inter_MCBPC_bits[cbpc], 
457 
inter_MCBPC_code[cbpc]); 
458 
cbpy = cbp >> 2;

459 
cbpy ^= 0xf;

460 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
461  
462 
if(interleaved_stats){

463 
bits= get_bit_count(&s>pb); 
464 
s>misc_bits+= bits  s>last_bits; 
465 
s>last_bits=bits; 
466 
} 
467  
468 
for(i=0; i<4; i++){ 
469 
/* motion vectors: 8x8 mode*/

470 
h263_pred_motion(s, i, &pred_x, &pred_y); 
471  
472 
h263_encode_motion(s, s>motion_val[ s>block_index[i] ][0]  pred_x, s>f_code);

473 
h263_encode_motion(s, s>motion_val[ s>block_index[i] ][1]  pred_y, s>f_code);

474 
} 
475 
} 
476  
477 
if(interleaved_stats){

478 
bits= get_bit_count(&s>pb); 
479 
s>mv_bits+= bits  s>last_bits; 
480 
s>last_bits=bits; 
481 
} 
482  
483 
/* encode each block */

484 
for (i = 0; i < 6; i++) { 
485 
mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb); 
486 
} 
487  
488 
if(interleaved_stats){

489 
bits= get_bit_count(&s>pb); 
490 
s>p_tex_bits+= bits  s>last_bits; 
491 
s>last_bits=bits; 
492 
} 
493 
s>p_count++; 
494 
} 
495 
} else {

496 
int cbp;

497 
int dc_diff[6]; //dc values with the dc prediction subtracted 
498 
int dir[6]; //prediction direction 
499 
int zigzag_last_index[6]; 
500 
UINT8 *scan_table[6];

501  
502 
for(i=0; i<6; i++){ 
503 
const int level= block[i][0]; 
504 
UINT16 *dc_ptr; 
505  
506 
dc_diff[i]= level  ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); 
507 
if (i < 4) { 
508 
*dc_ptr = level * s>y_dc_scale; 
509 
} else {

510 
*dc_ptr = level * s>c_dc_scale; 
511 
} 
512 
} 
513  
514 
s>ac_pred= decide_ac_pred(s, block, dir); 
515  
516 
if(s>ac_pred){

517 
for(i=0; i<6; i++){ 
518 
UINT8 *st; 
519 
int last_index;

520  
521 
mpeg4_inv_pred_ac(s, block[i], i, dir[i]); 
522 
if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */ 
523 
else st = ff_alternate_horizontal_scan; /* top */ 
524  
525 
for(last_index=63; last_index>=0; last_index) //FIXME optimize 
526 
if(block[i][st[last_index]]) break; 
527 
zigzag_last_index[i]= s>block_last_index[i]; 
528 
s>block_last_index[i]= last_index; 
529 
scan_table[i]= st; 
530 
} 
531 
}else{

532 
for(i=0; i<6; i++) 
533 
scan_table[i]= zigzag_direct; 
534 
} 
535  
536 
/* compute cbp */

537 
cbp = 0;

538 
for (i = 0; i < 6; i++) { 
539 
if (s>block_last_index[i] >= 1) 
540 
cbp = 1 << (5  i); 
541 
} 
542  
543 
cbpc = cbp & 3;

544 
if (s>pict_type == I_TYPE) {

545 
put_bits(&s>pb, 
546 
intra_MCBPC_bits[cbpc], 
547 
intra_MCBPC_code[cbpc]); 
548 
} else {

549 
put_bits(&s>pb, 1, 0); /* mb coded */ 
550 
put_bits(&s>pb, 
551 
inter_MCBPC_bits[cbpc + 4],

552 
inter_MCBPC_code[cbpc + 4]);

553 
} 
554 
put_bits(pb2, 1, s>ac_pred);

555 
cbpy = cbp >> 2;

556 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
557  
558 
if(interleaved_stats){

559 
bits= get_bit_count(&s>pb); 
560 
s>misc_bits+= bits  s>last_bits; 
561 
s>last_bits=bits; 
562 
} 
563  
564 
/* encode each block */

565 
for (i = 0; i < 6; i++) { 
566 
mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); 
567 
} 
568  
569 
if(interleaved_stats){

570 
bits= get_bit_count(&s>pb); 
571 
s>i_tex_bits+= bits  s>last_bits; 
572 
s>last_bits=bits; 
573 
} 
574 
s>i_count++; 
575  
576 
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */

577 
if(s>ac_pred){

578 
for(i=0; i<6; i++){ 
579 
int j;

580 
INT16 *ac_val; 
581  
582 
ac_val = s>ac_val[0][0] + s>block_index[i] * 16; 
583  
584 
if(dir[i]){

585 
for(j=1; j<8; j++) 
586 
block[i][block_permute_op(j )]= ac_val[j+8];

587 
}else{

588 
for(j=1; j<8; j++) 
589 
block[i][block_permute_op(j<<3)]= ac_val[j ];

590 
} 
591 
s>block_last_index[i]= zigzag_last_index[i]; 
592 
} 
593 
} 
594 
} 
595 
} 
596  
597 
void h263_encode_mb(MpegEncContext * s,

598 
DCTELEM block[6][64], 
599 
int motion_x, int motion_y) 
600 
{ 
601 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

602 
INT16 pred_dc; 
603 
INT16 rec_intradc[6];

604 
UINT16 *dc_ptr[6];

605 

606 
//printf("**mb x=%d y=%d\n", s>mb_x, s>mb_y);

607 
if (!s>mb_intra) {

608 
/* compute cbp */

609 
cbp = 0;

610 
for (i = 0; i < 6; i++) { 
611 
if (s>block_last_index[i] >= 0) 
612 
cbp = 1 << (5  i); 
613 
} 
614 
if ((cbp  motion_x  motion_y) == 0) { 
615 
/* skip macroblock */

616 
put_bits(&s>pb, 1, 1); 
617 
return;

618 
} 
619 
put_bits(&s>pb, 1, 0); /* mb coded */ 
620 
cbpc = cbp & 3;

621 
put_bits(&s>pb, 
622 
inter_MCBPC_bits[cbpc], 
623 
inter_MCBPC_code[cbpc]); 
624 
cbpy = cbp >> 2;

625 
cbpy ^= 0xf;

626 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
627  
628 
/* motion vectors: 16x16 mode only now */

629 
h263_pred_motion(s, 0, &pred_x, &pred_y);

630 

631 
if (!s>umvplus) {

632 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
633 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
634 
} 
635 
else {

636 
h263p_encode_umotion(s, motion_x  pred_x); 
637 
h263p_encode_umotion(s, motion_y  pred_y); 
638 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
639 
/* To prevent Start Code emulation */

640 
put_bits(&s>pb,1,1); 
641 
} 
642 
} else {

643 
int li = s>h263_aic ? 0 : 1; 
644 

645 
cbp = 0;

646 
for(i=0; i<6; i++) { 
647 
/* Predict DC */

648 
if (s>h263_aic && s>mb_intra) {

649 
INT16 level = block[i][0];

650 

651 
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); 
652 
level = pred_dc; 
653 
/* Quant */

654 
if (level < 0) 
655 
level = (level + (s>qscale >> 1))/(s>y_dc_scale);

656 
else

657 
level = (level  (s>qscale >> 1))/(s>y_dc_scale);

658 

659 
/* AIC can change CBP */

660 
if (level == 0 && s>block_last_index[i] == 0) 
661 
s>block_last_index[i] = 1;

662 
else if (level < 127) 
663 
level = 127;

664 
else if (level > 127) 
665 
level = 127;

666 

667 
block[i][0] = level;

668 
/* Reconstruction */

669 
rec_intradc[i] = (s>y_dc_scale*level) + pred_dc; 
670 
/* Oddify */

671 
rec_intradc[i] = 1;

672 
//if ((rec_intradc[i] % 2) == 0)

673 
// rec_intradc[i]++;

674 
/* Clipping */

675 
if (rec_intradc[i] < 0) 
676 
rec_intradc[i] = 0;

677 
else if (rec_intradc[i] > 2047) 
678 
rec_intradc[i] = 2047;

679 

680 
/* Update AC/DC tables */

681 
*dc_ptr[i] = rec_intradc[i]; 
682 
} 
683 
/* compute cbp */

684 
if (s>block_last_index[i] >= li)

685 
cbp = 1 << (5  i); 
686 
} 
687  
688 
cbpc = cbp & 3;

689 
if (s>pict_type == I_TYPE) {

690 
put_bits(&s>pb, 
691 
intra_MCBPC_bits[cbpc], 
692 
intra_MCBPC_code[cbpc]); 
693 
} else {

694 
put_bits(&s>pb, 1, 0); /* mb coded */ 
695 
put_bits(&s>pb, 
696 
inter_MCBPC_bits[cbpc + 4],

697 
inter_MCBPC_code[cbpc + 4]);

698 
} 
699 
if (s>h263_aic) {

700 
/* XXX: currently, we do not try to use ac prediction */

701 
put_bits(&s>pb, 1, 0); /* no AC prediction */ 
702 
} 
703 
cbpy = cbp >> 2;

704 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
705 
} 
706  
707 
for(i=0; i<6; i++) { 
708 
/* encode each block */

709 
h263_encode_block(s, block[i], i); 
710 

711 
/* Update INTRADC for decoding */

712 
if (s>h263_aic && s>mb_intra) {

713 
block[i][0] = rec_intradc[i];

714 

715 
} 
716 
} 
717 
} 
718  
719 
static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr) 
720 
{ 
721 
int x, y, wrap, a, c, pred_dc, scale;

722 
INT16 *dc_val, *ac_val; 
723  
724 
/* find prediction */

725 
if (n < 4) { 
726 
x = 2 * s>mb_x + 1 + (n & 1); 
727 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
728 
wrap = s>mb_width * 2 + 2; 
729 
dc_val = s>dc_val[0];

730 
ac_val = s>ac_val[0][0]; 
731 
scale = s>y_dc_scale; 
732 
} else {

733 
x = s>mb_x + 1;

734 
y = s>mb_y + 1;

735 
wrap = s>mb_width + 2;

736 
dc_val = s>dc_val[n  4 + 1]; 
737 
ac_val = s>ac_val[n  4 + 1][0]; 
738 
scale = s>c_dc_scale; 
739 
} 
740 
/* B C

741 
* A X

742 
*/

743 
a = dc_val[(x  1) + (y) * wrap];

744 
c = dc_val[(x) + (y  1) * wrap];

745 

746 
/* No prediction outside GOB boundary */

747 
if (s>first_slice_line && ((n < 2)  (n > 3))) 
748 
c = 1024;

749 
pred_dc = 1024;

750 
/* just DC prediction */

751 
if (a != 1024 && c != 1024) 
752 
pred_dc = (a + c) >> 1;

753 
else if (a != 1024) 
754 
pred_dc = a; 
755 
else

756 
pred_dc = c; 
757 

758 
/* we assume pred is positive */

759 
//pred_dc = (pred_dc + (scale >> 1)) / scale;

760 
*dc_val_ptr = &dc_val[x + y * wrap]; 
761 
return pred_dc;

762 
} 
763  
764  
765 
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n) 
766 
{ 
767 
int x, y, wrap, a, c, pred_dc, scale, i;

768 
INT16 *dc_val, *ac_val, *ac_val1; 
769  
770 
/* find prediction */

771 
if (n < 4) { 
772 
x = 2 * s>mb_x + 1 + (n & 1); 
773 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
774 
wrap = s>mb_width * 2 + 2; 
775 
dc_val = s>dc_val[0];

776 
ac_val = s>ac_val[0][0]; 
777 
scale = s>y_dc_scale; 
778 
} else {

779 
x = s>mb_x + 1;

780 
y = s>mb_y + 1;

781 
wrap = s>mb_width + 2;

782 
dc_val = s>dc_val[n  4 + 1]; 
783 
ac_val = s>ac_val[n  4 + 1][0]; 
784 
scale = s>c_dc_scale; 
785 
} 
786 

787 
ac_val += ((y) * wrap + (x)) * 16;

788 
ac_val1 = ac_val; 
789 

790 
/* B C

791 
* A X

792 
*/

793 
a = dc_val[(x  1) + (y) * wrap];

794 
c = dc_val[(x) + (y  1) * wrap];

795 

796 
/* No prediction outside GOB boundary */

797 
if (s>first_slice_line && ((n < 2)  (n > 3))) 
798 
c = 1024;

799 
pred_dc = 1024;

800 
if (s>ac_pred) {

801 
if (s>h263_aic_dir) {

802 
/* left prediction */

803 
if (a != 1024) { 
804 
ac_val = 16;

805 
for(i=1;i<8;i++) { 
806 
block[block_permute_op(i*8)] += ac_val[i];

807 
} 
808 
pred_dc = a; 
809 
} 
810 
} else {

811 
/* top prediction */

812 
if (c != 1024) { 
813 
ac_val = 16 * wrap;

814 
for(i=1;i<8;i++) { 
815 
block[block_permute_op(i)] += ac_val[i + 8];

816 
} 
817 
pred_dc = c; 
818 
} 
819 
} 
820 
} else {

821 
/* just DC prediction */

822 
if (a != 1024 && c != 1024) 
823 
pred_dc = (a + c) >> 1;

824 
else if (a != 1024) 
825 
pred_dc = a; 
826 
else

827 
pred_dc = c; 
828 
} 
829 

830 
/* we assume pred is positive */

831 
block[0]=block[0]*scale + pred_dc; 
832 

833 
if (block[0] < 0) 
834 
block[0] = 0; 
835 
else if (!(block[0] & 1)) 
836 
block[0]++;

837 

838 
/* Update AC/DC tables */

839 
dc_val[(x) + (y) * wrap] = block[0];

840 

841 
/* left copy */

842 
for(i=1;i<8;i++) 
843 
ac_val1[i] = block[block_permute_op(i * 8)];

844 
/* top copy */

845 
for(i=1;i<8;i++) 
846 
ac_val1[8 + i] = block[block_permute_op(i)];

847 
} 
848  
849 
INT16 *h263_pred_motion(MpegEncContext * s, int block,

850 
int *px, int *py) 
851 
{ 
852 
int xy, wrap;

853 
INT16 *A, *B, *C, *mot_val; 
854 
static const int off[4]= {2, 1, 1, 1}; 
855  
856 
wrap = s>block_wrap[0];

857 
xy = s>block_index[block]; 
858  
859 
mot_val = s>motion_val[xy]; 
860  
861 
A = s>motion_val[xy  1];

862 
/* special case for first (slice) line */

863 
if ((s>mb_y == 0  s>first_slice_line) && block<3) { 
864 
// we cant just change some MVs to simulate that as we need them for the B frames (and ME)

865 
// and if we ever support non rectangular objects than we need to do a few ifs here anyway :(

866 
if(block==0){ //most common case 
867 
if(s>mb_x == s>resync_mb_x){ //rare 
868 
*px= *py = 0;

869 
}else if(s>mb_x + 1 == s>resync_mb_x){ //rare 
870 
C = s>motion_val[xy + off[block]  wrap]; 
871 
if(s>mb_x==0){ 
872 
*px = C[0];

873 
*py = C[1];

874 
}else{

875 
*px = mid_pred(A[0], 0, C[0]); 
876 
*py = mid_pred(A[1], 0, C[1]); 
877 
} 
878 
}else{

879 
*px = A[0];

880 
*py = A[1];

881 
} 
882 
}else if(block==1){ 
883 
if(s>mb_x + 1 == s>resync_mb_x){ //rare 
884 
C = s>motion_val[xy + off[block]  wrap]; 
885 
*px = mid_pred(A[0], 0, C[0]); 
886 
*py = mid_pred(A[1], 0, C[1]); 
887 
}else{

888 
*px = A[0];

889 
*py = A[1];

890 
} 
891 
}else{ /* block==2*/ 
892 
B = s>motion_val[xy  wrap]; 
893 
C = s>motion_val[xy + off[block]  wrap]; 
894 
if(s>mb_x == s>resync_mb_x) //rare 
895 
A[0]=A[1]=0; 
896 

897 
*px = mid_pred(A[0], B[0], C[0]); 
898 
*py = mid_pred(A[1], B[1], C[1]); 
899 
} 
900 
} else {

901 
B = s>motion_val[xy  wrap]; 
902 
C = s>motion_val[xy + off[block]  wrap]; 
903 
*px = mid_pred(A[0], B[0], C[0]); 
904 
*py = mid_pred(A[1], B[1], C[1]); 
905 
} 
906 
return mot_val;

907 
} 
908  
909 
static void h263_encode_motion(MpegEncContext * s, int val, int f_code) 
910 
{ 
911 
int range, l, m, bit_size, sign, code, bits;

912  
913 
if (val == 0) { 
914 
/* zero vector */

915 
code = 0;

916 
put_bits(&s>pb, mvtab[code][1], mvtab[code][0]); 
917 
} else {

918 
bit_size = f_code  1;

919 
range = 1 << bit_size;

920 
/* modulo encoding */

921 
l = range * 32;

922 
m = 2 * l;

923 
if (val < l) {

924 
val += m; 
925 
} else if (val >= l) { 
926 
val = m; 
927 
} 
928  
929 
if (val >= 0) { 
930 
sign = 0;

931 
} else {

932 
val = val; 
933 
sign = 1;

934 
} 
935 
val; 
936 
code = (val >> bit_size) + 1;

937 
bits = val & (range  1);

938  
939 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
940 
if (bit_size > 0) { 
941 
put_bits(&s>pb, bit_size, bits); 
942 
} 
943 
} 
944 
} 
945  
946 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

947 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
948 
{ 
949 
short sval = 0; 
950 
short i = 0; 
951 
short n_bits = 0; 
952 
short temp_val;

953 
int code = 0; 
954 
int tcode;

955 

956 
if ( val == 0) 
957 
put_bits(&s>pb, 1, 1); 
958 
else if (val == 1) 
959 
put_bits(&s>pb, 3, 0); 
960 
else if (val == 1) 
961 
put_bits(&s>pb, 3, 2); 
962 
else {

963 

964 
sval = ((val < 0) ? (short)(val):(short)val); 
965 
temp_val = sval; 
966 

967 
while (temp_val != 0) { 
968 
temp_val = temp_val >> 1;

969 
n_bits++; 
970 
} 
971 

972 
i = n_bits  1;

973 
while (i > 0) { 
974 
tcode = (sval & (1 << (i1))) >> (i1); 
975 
tcode = (tcode << 1)  1; 
976 
code = (code << 2)  tcode;

977 
i; 
978 
} 
979 
code = ((code << 1)  (val < 0)) << 1; 
980 
put_bits(&s>pb, (2*n_bits)+1, code); 
981 
//printf("\nVal = %d\tCode = %d", sval, code);

982 
} 
983 
} 
984  
985 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
986 
{ 
987 
int f_code;

988 
int mv;

989 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
990 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

991 
int len;

992  
993 
if(mv==0) len= mvtab[0][1]; 
994 
else{

995 
int val, bit_size, range, code;

996  
997 
bit_size = s>f_code  1;

998 
range = 1 << bit_size;

999  
1000 
val=mv; 
1001 
if (val < 0) 
1002 
val = val; 
1003 
val; 
1004 
code = (val >> bit_size) + 1;

1005 
if(code<33){ 
1006 
len= mvtab[code][1] + 1 + bit_size; 
1007 
}else{

1008 
len= mvtab[32][1] + 2 + bit_size; 
1009 
} 
1010 
} 
1011  
1012 
mv_penalty[f_code][mv+MAX_MV]= len; 
1013 
} 
1014 
} 
1015  
1016 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
1017 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
1018 
fcode_tab[mv+MAX_MV]= f_code; 
1019 
} 
1020 
} 
1021  
1022 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
1023 
umv_fcode_tab[mv]= 1;

1024 
} 
1025 
} 
1026  
1027 
static void init_uni_dc_tab(void) 
1028 
{ 
1029 
int level, uni_code, uni_len;

1030  
1031 
for(level=256; level<256; level++){ 
1032 
int size, v, l;

1033 
/* find number of bits */

1034 
size = 0;

1035 
v = abs(level); 
1036 
while (v) {

1037 
v >>= 1;

1038 
size++; 
1039 
} 
1040  
1041 
if (level < 0) 
1042 
l= (level) ^ ((1 << size)  1); 
1043 
else

1044 
l= level; 
1045  
1046 
/* luminance */

1047 
uni_code= DCtab_lum[size][0];

1048 
uni_len = DCtab_lum[size][1];

1049  
1050 
if (size > 0) { 
1051 
uni_code<<=size; uni_code=l; 
1052 
uni_len+=size; 
1053 
if (size > 8){ 
1054 
uni_code<<=1; uni_code=1; 
1055 
uni_len++; 
1056 
} 
1057 
} 
1058 
uni_DCtab_lum[level+256][0]= uni_code; 
1059 
uni_DCtab_lum[level+256][1]= uni_len; 
1060  
1061 
/* chrominance */

1062 
uni_code= DCtab_chrom[size][0];

1063 
uni_len = DCtab_chrom[size][1];

1064 

1065 
if (size > 0) { 
1066 
uni_code<<=size; uni_code=l; 
1067 
uni_len+=size; 
1068 
if (size > 8){ 
1069 
uni_code<<=1; uni_code=1; 
1070 
uni_len++; 
1071 
} 
1072 
} 
1073 
uni_DCtab_chrom[level+256][0]= uni_code; 
1074 
uni_DCtab_chrom[level+256][1]= uni_len; 
1075  
1076 
} 
1077 
} 
1078  
1079 
void h263_encode_init(MpegEncContext *s)

1080 
{ 
1081 
static int done = 0; 
1082  
1083 
if (!done) {

1084 
done = 1;

1085  
1086 
init_uni_dc_tab(); 
1087  
1088 
init_rl(&rl_inter); 
1089 
init_rl(&rl_intra); 
1090 
init_rl(&rl_intra_aic); 
1091  
1092 
init_mv_penalty_and_fcode(s); 
1093 
} 
1094 
s>mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

1095 

1096 
// use fcodes >1 only for mpeg4 & h263 & h263p FIXME

1097 
switch(s>codec_id){

1098 
case CODEC_ID_MPEG4:

1099 
s>fcode_tab= fcode_tab; 
1100 
s>min_qcoeff= 2048;

1101 
s>max_qcoeff= 2047;

1102 
break;

1103 
case CODEC_ID_H263P:

1104 
s>fcode_tab= umv_fcode_tab; 
1105 
s>min_qcoeff= 128;

1106 
s>max_qcoeff= 127;

1107 
break;

1108 
//Note for mpeg4 & h263 the dcscale table will be set per frame as needed later

1109 
default: //nothing needed default table allready set in mpegvideo.c 
1110 
s>min_qcoeff= 128;

1111 
s>max_qcoeff= 127;

1112 
s>y_dc_scale_table= 
1113 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
1114 
} 
1115  
1116 
/* h263 type bias */

1117 
//FIXME mpeg4 mpeg quantizer

1118 
s>intra_quant_bias=0;

1119 
s>inter_quant_bias=(1<<(QUANT_BIAS_SHIFT2)); //(a  x/4)/x 
1120 
} 
1121  
1122 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
1123 
{ 
1124 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;

1125 
RLTable *rl; 
1126  
1127 
rl = &rl_inter; 
1128 
if (s>mb_intra && !s>h263_aic) {

1129 
/* DC coef */

1130 
level = block[0];

1131 
/* 255 cannot be represented, so we clamp */

1132 
if (level > 254) { 
1133 
level = 254;

1134 
block[0] = 254; 
1135 
} 
1136 
/* 0 cannot be represented also */

1137 
else if (!level) { 
1138 
level = 1;

1139 
block[0] = 1; 
1140 
} 
1141 
if (level == 128) 
1142 
put_bits(&s>pb, 8, 0xff); 
1143 
else

1144 
put_bits(&s>pb, 8, level & 0xff); 
1145 
i = 1;

1146 
} else {

1147 
i = 0;

1148 
if (s>h263_aic && s>mb_intra)

1149 
rl = &rl_intra_aic; 
1150 
} 
1151 

1152 
/* AC coefs */

1153 
last_index = s>block_last_index[n]; 
1154 
last_non_zero = i  1;

1155 
for (; i <= last_index; i++) {

1156 
j = zigzag_direct[i]; 
1157 
level = block[j]; 
1158 
if (level) {

1159 
run = i  last_non_zero  1;

1160 
last = (i == last_index); 
1161 
sign = 0;

1162 
slevel = level; 
1163 
if (level < 0) { 
1164 
sign = 1;

1165 
level = level; 
1166 
} 
1167 
code = get_rl_index(rl, last, run, level); 
1168 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1169 
if (code == rl>n) {

1170 
put_bits(&s>pb, 1, last);

1171 
put_bits(&s>pb, 6, run);

1172 
put_bits(&s>pb, 8, slevel & 0xff); 
1173 
} else {

1174 
put_bits(&s>pb, 1, sign);

1175 
} 
1176 
last_non_zero = i; 
1177 
} 
1178 
} 
1179 
} 
1180  
1181 
/***************************************************/

1182  
1183 
void ff_mpeg4_stuffing(PutBitContext * pbc)

1184 
{ 
1185 
int length;

1186 
put_bits(pbc, 1, 0); 
1187 
length= (get_bit_count(pbc))&7;

1188 
if(length) put_bits(pbc, length, (1<<length)1); 
1189 
} 
1190  
1191 
/* must be called before writing the header */

1192 
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ 
1193 
int time_div, time_mod;

1194  
1195 
if(s>pict_type==I_TYPE){ //we will encode a vol header 
1196 
s>time_increment_resolution= s>frame_rate/ff_gcd(s>frame_rate, FRAME_RATE_BASE); 
1197 
if(s>time_increment_resolution>=256*256) s>time_increment_resolution= 256*128; 
1198  
1199 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
1200 
} 
1201  
1202 
s>time= picture_number*(INT64)FRAME_RATE_BASE*s>time_increment_resolution/s>frame_rate; 
1203 
time_div= s>time/s>time_increment_resolution; 
1204 
time_mod= s>time%s>time_increment_resolution; 
1205  
1206 
if(s>pict_type==B_TYPE){

1207 
s>bp_time= s>last_non_b_time  s>time; 
1208 
}else{

1209 
s>last_time_base= s>time_base; 
1210 
s>time_base= time_div; 
1211 
s>pp_time= s>time  s>last_non_b_time; 
1212 
s>last_non_b_time= s>time; 
1213 
} 
1214 
} 
1215  
1216 
static void mpeg4_encode_vol_header(MpegEncContext * s) 
1217 
{ 
1218 
int vo_ver_id=1; //must be 2 if we want GMC or qpel 
1219 
char buf[255]; 
1220  
1221 
s>vo_type= s>has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE; 
1222  
1223 
put_bits(&s>pb, 16, 0); 
1224 
put_bits(&s>pb, 16, 0x100); /* video obj */ 
1225 
put_bits(&s>pb, 16, 0); 
1226 
put_bits(&s>pb, 16, 0x120); /* video obj layer */ 
1227  
1228 
put_bits(&s>pb, 1, 0); /* random access vol */ 
1229 
put_bits(&s>pb, 8, s>vo_type); /* video obj type indication */ 
1230 
put_bits(&s>pb, 1, 1); /* is obj layer id= yes */ 
1231 
put_bits(&s>pb, 4, vo_ver_id); /* is obj layer ver id */ 
1232 
put_bits(&s>pb, 3, 1); /* is obj layer priority */ 
1233 
if(s>aspect_ratio_info)

1234 
put_bits(&s>pb, 4, s>aspect_ratio_info);/* aspect ratio info */ 
1235 
else

1236 
put_bits(&s>pb, 4, 1); /* aspect ratio info= sqare pixel */ 
1237  
1238 
if(s>low_delay){

1239 
put_bits(&s>pb, 1, 1); /* vol control parameters= yes */ 
1240 
put_bits(&s>pb, 2, 1); /* chroma format YUV 420/YV12 */ 
1241 
put_bits(&s>pb, 1, s>low_delay);

1242 
put_bits(&s>pb, 1, 0); /* vbv parameters= no */ 
1243 
}else{

1244 
put_bits(&s>pb, 1, 0); /* vol control parameters= no */ 
1245 
} 
1246  
1247 
put_bits(&s>pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 
1248 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1249 

1250 
put_bits(&s>pb, 16, s>time_increment_resolution);

1251 
if (s>time_increment_bits < 1) 
1252 
s>time_increment_bits = 1;

1253 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1254 
put_bits(&s>pb, 1, 0); /* fixed vop rate=no */ 
1255 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1256 
put_bits(&s>pb, 13, s>width); /* vol width */ 
1257 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1258 
put_bits(&s>pb, 13, s>height); /* vol height */ 
1259 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1260 
put_bits(&s>pb, 1, 0); /* interlace */ 
1261 
put_bits(&s>pb, 1, 1); /* obmc disable */ 
1262 
if (vo_ver_id == 1) { 
1263 
put_bits(&s>pb, 1, s>vol_sprite_usage=0); /* sprite enable */ 
1264 
}else{ /* vo_ver_id == 2 */ 
1265 
put_bits(&s>pb, 2, s>vol_sprite_usage=0); /* sprite enable */ 
1266 
} 
1267 
put_bits(&s>pb, 1, 0); /* not 8 bit */ 
1268 
put_bits(&s>pb, 1, 0); /* quant type= h263 style*/ 
1269 
if (vo_ver_id != 1) 
1270 
put_bits(&s>pb, 1, s>quarter_sample=0); 
1271 
put_bits(&s>pb, 1, 1); /* complexity estimation disable */ 
1272 
s>resync_marker= s>rtp_mode; 
1273 
put_bits(&s>pb, 1, s>resync_marker ? 0 : 1);/* resync marker disable */ 
1274 
put_bits(&s>pb, 1, s>data_partitioning ? 1 : 0); 
1275 
if(s>data_partitioning){

1276 
put_bits(&s>pb, 1, 0); /* no rvlc */ 
1277 
} 
1278  
1279 
if (vo_ver_id != 1){ 
1280 
put_bits(&s>pb, 1, 0); /* newpred */ 
1281 
put_bits(&s>pb, 1, 0); /* reduced res vop */ 
1282 
} 
1283 
put_bits(&s>pb, 1, 0); /* scalability */ 
1284  
1285 
ff_mpeg4_stuffing(&s>pb); 
1286 
put_bits(&s>pb, 16, 0); 
1287 
put_bits(&s>pb, 16, 0x1B2); /* user_data */ 
1288 
sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);

1289 
put_string(&s>pb, buf); 
1290  
1291 
ff_mpeg4_stuffing(&s>pb); 
1292 
} 
1293  
1294 
/* write mpeg4 VOP header */

1295 
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
1296 
{ 
1297 
int time_incr;

1298 
int time_div, time_mod;

1299 

1300 
if(s>pict_type==I_TYPE){

1301 
s>no_rounding=0;

1302 
if(picture_number==0  !s>strict_std_compliance) 
1303 
mpeg4_encode_vol_header(s); 
1304 
} 
1305 

1306 
//printf("num:%d rate:%d base:%d\n", s>picture_number, s>frame_rate, FRAME_RATE_BASE);

1307 

1308 
put_bits(&s>pb, 16, 0); /* vop header */ 
1309 
put_bits(&s>pb, 16, 0x1B6); /* vop header */ 
1310 
put_bits(&s>pb, 2, s>pict_type  1); /* pict type: I = 0 , P = 1 */ 
1311  
1312 
time_div= s>time/s>time_increment_resolution; 
1313 
time_mod= s>time%s>time_increment_resolution; 
1314 
time_incr= time_div  s>last_time_base; 
1315 
while(time_incr)

1316 
put_bits(&s>pb, 1, 1); 
1317 

1318 
put_bits(&s>pb, 1, 0); 
1319  
1320 
put_bits(&s>pb, 1, 1); /* marker */ 
1321 
put_bits(&s>pb, s>time_increment_bits, time_mod); /* time increment */

1322 
put_bits(&s>pb, 1, 1); /* marker */ 
1323 
put_bits(&s>pb, 1, 1); /* vop coded */ 
1324 
if ( s>pict_type == P_TYPE

1325 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE)) { 
1326 
s>no_rounding ^= 1;

1327 
put_bits(&s>pb, 1, s>no_rounding); /* rounding type */ 
1328 
} 
1329 
put_bits(&s>pb, 3, 0); /* intra dc VLC threshold */ 
1330 
//FIXME sprite stuff

1331  
1332 
put_bits(&s>pb, 5, s>qscale);

1333  
1334 
if (s>pict_type != I_TYPE)

1335 
put_bits(&s>pb, 3, s>f_code); /* fcode_for */ 
1336 
if (s>pict_type == B_TYPE)

1337 
put_bits(&s>pb, 3, s>b_code); /* fcode_back */ 
1338 
// printf("****frame %d\n", picture_number);

1339  
1340 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support

1341 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
1342 
} 
1343  
1344 
static void h263_dc_scale(MpegEncContext * s) 
1345 
{ 
1346 
s>y_dc_scale= s>y_dc_scale_table[ s>qscale ]; 
1347 
s>c_dc_scale= s>c_dc_scale_table[ s>qscale ]; 
1348 
} 
1349  
1350 
inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) 
1351 
{ 
1352 
int a, b, c, wrap, pred, scale;

1353 
UINT16 *dc_val; 
1354 
int dummy;

1355  
1356 
/* find prediction */

1357 
if (n < 4) { 
1358 
scale = s>y_dc_scale; 
1359 
} else {

1360 
scale = s>c_dc_scale; 
1361 
} 
1362 
wrap= s>block_wrap[n]; 
1363 
dc_val = s>dc_val[0] + s>block_index[n];

1364  
1365 
/* B C

1366 
* A X

1367 
*/

1368 
a = dc_val[  1];

1369 
b = dc_val[  1  wrap];

1370 
c = dc_val[  wrap]; 
1371  
1372 
if (abs(a  b) < abs(b  c)) {

1373 
pred = c; 
1374 
*dir_ptr = 1; /* top */ 
1375 
} else {

1376 
pred = a; 
1377 
*dir_ptr = 0; /* left */ 
1378 
} 
1379 
/* we assume pred is positive */

1380 
#ifdef ARCH_X86

1381 
asm volatile ( 
1382 
"xorl %%edx, %%edx \n\t"

1383 
"mul %%ecx \n\t"

1384 
: "=d" (pred), "=a"(dummy) 
1385 
: "a" (pred + (scale >> 1)), "c" (inverse[scale]) 
1386 
); 
1387 
#else

1388 
pred = (pred + (scale >> 1)) / scale;

1389 
#endif

1390  
1391 
/* prepare address for prediction update */

1392 
*dc_val_ptr = &dc_val[0];

1393  
1394 
return pred;

1395 
} 
1396  
1397 
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1398 
int dir)

1399 
{ 
1400 
int i;

1401 
INT16 *ac_val, *ac_val1; 
1402  
1403 
/* find prediction */

1404 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1405 
ac_val1 = ac_val; 
1406 
if (s>ac_pred) {

1407 
if (dir == 0) { 
1408 
/* left prediction */

1409 
ac_val = 16;

1410 
for(i=1;i<8;i++) { 
1411 
block[block_permute_op(i*8)] += ac_val[i];

1412 
} 
1413 
} else {

1414 
/* top prediction */

1415 
ac_val = 16 * s>block_wrap[n];

1416 
for(i=1;i<8;i++) { 
1417 
block[block_permute_op(i)] += ac_val[i + 8];

1418 
} 
1419 
} 
1420 
} 
1421 
/* left copy */

1422 
for(i=1;i<8;i++) 
1423 
ac_val1[i] = block[block_permute_op(i * 8)];

1424 
/* top copy */

1425 
for(i=1;i<8;i++) 
1426 
ac_val1[8 + i] = block[block_permute_op(i)];

1427 
} 
1428  
1429 
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1430 
int dir)

1431 
{ 
1432 
int i;

1433 
INT16 *ac_val; 
1434  
1435 
/* find prediction */

1436 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1437 

1438 
if (dir == 0) { 
1439 
/* left prediction */

1440 
ac_val = 16;

1441 
for(i=1;i<8;i++) { 
1442 
block[block_permute_op(i*8)] = ac_val[i];

1443 
} 
1444 
} else {

1445 
/* top prediction */

1446 
ac_val = 16 * s>block_wrap[n];

1447 
for(i=1;i<8;i++) { 
1448 
block[block_permute_op(i)] = ac_val[i + 8];

1449 
} 
1450 
} 
1451 
} 
1452  
1453 
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) 
1454 
{ 
1455 
#if 1 
1456 
// if(level<255  level>255) printf("dc overflow\n");

1457 
level+=256;

1458 
if (n < 4) { 
1459 
/* luminance */

1460 
put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]); 
1461 
} else {

1462 
/* chrominance */

1463 
put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]); 
1464 
} 
1465 
#else

1466 
int size, v;

1467 
/* find number of bits */

1468 
size = 0;

1469 
v = abs(level); 
1470 
while (v) {

1471 
v >>= 1;

1472 
size++; 
1473 
} 
1474  
1475 
if (n < 4) { 
1476 
/* luminance */

1477 
put_bits(&s>pb, DCtab_lum[size][1], DCtab_lum[size][0]); 
1478 
} else {

1479 
/* chrominance */

1480 
put_bits(&s>pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 
1481 
} 
1482  
1483 
/* encode remaining bits */

1484 
if (size > 0) { 
1485 
if (level < 0) 
1486 
level = (level) ^ ((1 << size)  1); 
1487 
put_bits(&s>pb, size, level); 
1488 
if (size > 8) 
1489 
put_bits(&s>pb, 1, 1); 
1490 
} 
1491 
#endif

1492 
} 
1493  
1494 
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
1495 
UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) 
1496 
{ 
1497 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

1498 
int code;

1499 
const RLTable *rl;

1500  
1501 
if (s>mb_intra) {

1502 
/* mpeg4 based DC predictor */

1503 
mpeg4_encode_dc(dc_pb, intra_dc, n); 
1504 
i = 1;

1505 
rl = &rl_intra; 
1506 
} else {

1507 
i = 0;

1508 
rl = &rl_inter; 
1509 
} 
1510  
1511 
/* AC coefs */

1512 
last_index = s>block_last_index[n]; 
1513 
last_non_zero = i  1;

1514 
for (; i <= last_index; i++) {

1515 
j = scan_table[i]; 
1516 
level = block[j]; 
1517 
if (level) {

1518 
run = i  last_non_zero  1;

1519 
last = (i == last_index); 
1520 
sign = 0;

1521 
slevel = level; 
1522 
if (level < 0) { 
1523 
sign = 1;

1524 
level = level; 
1525 
} 
1526 
code = get_rl_index(rl, last, run, level); 
1527 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1528 
if (code == rl>n) {

1529 
int level1, run1;

1530 
level1 = level  rl>max_level[last][run]; 
1531 
if (level1 < 1) 
1532 
goto esc2;

1533 
code = get_rl_index(rl, last, run, level1); 
1534 
if (code == rl>n) {

1535 
esc2:

1536 
put_bits(ac_pb, 1, 1); 
1537 
if (level > MAX_LEVEL)

1538 
goto esc3;

1539 
run1 = run  rl>max_run[last][level]  1;

1540 
if (run1 < 0) 
1541 
goto esc3;

1542 
code = get_rl_index(rl, last, run1, level); 
1543 
if (code == rl>n) {

1544 
esc3:

1545 
/* third escape */

1546 
put_bits(ac_pb, 1, 1); 
1547 
put_bits(ac_pb, 1, last);

1548 
put_bits(ac_pb, 6, run);

1549 
put_bits(ac_pb, 1, 1); 
1550 
put_bits(ac_pb, 12, slevel & 0xfff); 
1551 
put_bits(ac_pb, 1, 1); 
1552 
} else {

1553 
/* second escape */

1554 
put_bits(ac_pb, 1, 0); 
1555 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1556 
put_bits(ac_pb, 1, sign);

1557 
} 
1558 
} else {

1559 
/* first escape */

1560 
put_bits(ac_pb, 1, 0); 
1561 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1562 
put_bits(ac_pb, 1, sign);

1563 
} 
1564 
} else {

1565 
put_bits(ac_pb, 1, sign);

1566 
} 
1567 
last_non_zero = i; 
1568 
} 
1569 
} 
1570 
} 
1571  
1572  
1573  
1574 
/***********************************************/

1575 
/* decoding */

1576  
1577 
static VLC intra_MCBPC_vlc;

1578 
static VLC inter_MCBPC_vlc;

1579 
static VLC cbpy_vlc;

1580 
static VLC mv_vlc;

1581 
static VLC dc_lum, dc_chrom;

1582 
static VLC sprite_trajectory;

1583 
static VLC mb_type_b_vlc;

1584  
1585 
void init_rl(RLTable *rl)

1586 
{ 
1587 
INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; 
1588 
UINT8 index_run[MAX_RUN+1];

1589 
int last, run, level, start, end, i;

1590  
1591 
/* compute max_level[], max_run[] and index_run[] */

1592 
for(last=0;last<2;last++) { 
1593 
if (last == 0) { 
1594 
start = 0;

1595 
end = rl>last; 
1596 
} else {

1597 
start = rl>last; 
1598 
end = rl>n; 
1599 
} 
1600  
1601 
memset(max_level, 0, MAX_RUN + 1); 
1602 
memset(max_run, 0, MAX_LEVEL + 1); 
1603 
memset(index_run, rl>n, MAX_RUN + 1);

1604 
for(i=start;i<end;i++) {

1605 
run = rl>table_run[i]; 
1606 
level = rl>table_level[i]; 
1607 
if (index_run[run] == rl>n)

1608 
index_run[run] = i; 
1609 
if (level > max_level[run])

1610 
max_level[run] = level; 
1611 
if (run > max_run[level])

1612 
max_run[level] = run; 
1613 
} 
1614 
rl>max_level[last] = av_malloc(MAX_RUN + 1);

1615 
memcpy(rl>max_level[last], max_level, MAX_RUN + 1);

1616 
rl>max_run[last] = av_malloc(MAX_LEVEL + 1);

1617 
memcpy(rl>max_run[last], max_run, MAX_LEVEL + 1);

1618 
rl>index_run[last] = av_malloc(MAX_RUN + 1);

1619 
memcpy(rl>index_run[last], index_run, MAX_RUN + 1);

1620 
} 
1621 
} 
1622  
1623 
void init_vlc_rl(RLTable *rl)

1624 
{ 
1625 
init_vlc(&rl>vlc, 9, rl>n + 1, 
1626 
&rl>table_vlc[0][1], 4, 2, 
1627 
&rl>table_vlc[0][0], 4, 2); 
1628 
} 
1629  
1630 
/* init vlcs */

1631  
1632 
/* XXX: find a better solution to handle static init */

1633 
void h263_decode_init_vlc(MpegEncContext *s)

1634 
{ 
1635 
static int done = 0; 
1636  
1637 
if (!done) {

1638 
done = 1;

1639  
1640 
init_vlc(&intra_MCBPC_vlc, 6, 8, 
1641 
intra_MCBPC_bits, 1, 1, 
1642 
intra_MCBPC_code, 1, 1); 
1643 
init_vlc(&inter_MCBPC_vlc, 9, 25, 
1644 
inter_MCBPC_bits, 1, 1, 
1645 
inter_MCBPC_code, 1, 1); 
1646 
init_vlc(&cbpy_vlc, 6, 16, 
1647 
&cbpy_tab[0][1], 2, 1, 
1648 
&cbpy_tab[0][0], 2, 1); 
1649 
init_vlc(&mv_vlc, 9, 33, 
1650 
&mvtab[0][1], 2, 1, 
1651 
&mvtab[0][0], 2, 1); 
1652 
init_rl(&rl_inter); 
1653 
init_rl(&rl_intra); 
1654 
init_rl(&rl_intra_aic); 
1655 
init_vlc_rl(&rl_inter); 
1656 
init_vlc_rl(&rl_intra); 
1657 
init_vlc_rl(&rl_intra_aic); 
1658 
init_vlc(&dc_lum, 9, 13, 
1659 
&DCtab_lum[0][1], 2, 1, 
1660 
&DCtab_lum[0][0], 2, 1); 
1661 
init_vlc(&dc_chrom, 9, 13, 
1662 
&DCtab_chrom[0][1], 2, 1, 
1663 
&DCtab_chrom[0][0], 2, 1); 
1664 
init_vlc(&sprite_trajectory, 9, 15, 
1665 
&sprite_trajectory_tab[0][1], 4, 2, 
1666 
&sprite_trajectory_tab[0][0], 4, 2); 
1667 
init_vlc(&mb_type_b_vlc, 4, 4, 
1668 
&mb_type_b_tab[0][1], 2, 1, 
1669 
&mb_type_b_tab[0][0], 2, 1); 
1670 
} 
1671 
} 
1672  
1673 
int h263_decode_gob_header(MpegEncContext *s)

1674 
{ 
1675 
unsigned int val, gfid; 
1676 

1677 
/* Check for GOB Start Code */

1678 
val = show_bits(&s>gb, 16);

1679 
if (val == 0) { 
1680 
/* We have a GBSC probably with GSTUFF */

1681 
skip_bits(&s>gb, 16); /* Drop the zeros */ 
1682 
while (get_bits1(&s>gb) == 0); /* Seek the '1' bit */ 
1683 
#ifdef DEBUG

1684 
fprintf(stderr,"\nGOB Start Code at MB %d\n", (s>mb_y * s>mb_width) + s>mb_x);

1685 
#endif

1686 
s>gob_number = get_bits(&s>gb, 5); /* GN */ 
1687 
gfid = get_bits(&s>gb, 2); /* GFID */ 
1688 
s>qscale = get_bits(&s>gb, 5); /* GQUANT */ 
1689 
#ifdef DEBUG

1690 
fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s>gob_number, gfid, s>qscale);

1691 
#endif

1692 
return 1; 
1693 
} 
1694 
return 0; 
1695 

1696 
} 
1697  
1698 
static inline void memsetw(short *tab, int val, int n) 
1699 
{ 
1700 
int i;

1701 
for(i=0;i<n;i++) 
1702 
tab[i] = val; 
1703 
} 
1704  
1705 
void ff_mpeg4_init_partitions(MpegEncContext *s)

1706 
{ 
1707 
init_put_bits(&s>tex_pb, s>tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL); 
1708 
init_put_bits(&s>pb2 , s>pb2_buffer , PB_BUFFER_SIZE, NULL, NULL); 
1709 
} 
1710  
1711 
void ff_mpeg4_merge_partitions(MpegEncContext *s)

1712 
{ 
1713 
const int pb2_len = get_bit_count(&s>pb2 ); 
1714 
const int tex_pb_len= get_bit_count(&s>tex_pb); 
1715 
const int bits= get_bit_count(&s>pb); 
1716  
1717 
if(s>pict_type==I_TYPE){

1718 
put_bits(&s>pb, 19, DC_MARKER);

1719 
s>misc_bits+=19 + pb2_len + bits  s>last_bits;

1720 
s>i_tex_bits+= tex_pb_len; 
1721 
}else{

1722 
put_bits(&s>pb, 17, MOTION_MARKER);

1723 
s>misc_bits+=17 + pb2_len;;

1724 
s>mv_bits+= bits  s>last_bits; 
1725 
s>p_tex_bits+= tex_pb_len; 
1726 
} 
1727  
1728 
flush_put_bits(&s>pb2); 
1729 
flush_put_bits(&s>tex_pb); 
1730  
1731 
ff_copy_bits(&s>pb, s>pb2_buffer , pb2_len); 
1732 
ff_copy_bits(&s>pb, s>tex_pb_buffer, tex_pb_len); 
1733 
s>last_bits= get_bit_count(&s>pb); 
1734 
} 
1735  
1736 
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)

1737 
{ 
1738 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
1739  
1740 
ff_mpeg4_stuffing(&s>pb); 
1741 
if(s>pict_type==I_TYPE)

1742 
put_bits(&s>pb, 16, 0); 
1743 
else if(s>pict_type==B_TYPE) 
1744 
put_bits(&s>pb, MAX(MAX(s>f_code, s>b_code)+15, 17), 0); 
1745 
else /* S/P_TYPE */ 
1746 
put_bits(&s>pb, s>f_code+15, 0); 
1747 
put_bits(&s>pb, 1, 1); 
1748 

1749 
put_bits(&s>pb, mb_num_bits, s>mb_x + s>mb_y*s>mb_width); 
1750 
put_bits(&s>pb, 5, s>qscale);

1751 
put_bits(&s>pb, 1, 0); /* no HEC */ 
1752 
} 
1753  
1754 
/**

1755 
* decodes the next video packet and sets s>next_qscale

1756 
* returns mb_num of the next packet or <0 if something went wrong

1757 
*/

1758 
static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb) 
1759 
{ 
1760 
int bits;

1761 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
1762 
int header_extension=0, mb_num; 
1763 
//printf("%X\n", show_bits(&gb, 24));

1764 
//printf("parse_video_packet_header\n");

1765 
// if(show_aligned_bits(gb, 1, 16) != 0) return 1;

1766 

1767 
/* is there enough space left for a video packet + header */

1768 
if( get_bits_count(gb) > gb>size*820) return 1; 
1769  
1770 
//printf("resync at %d %d\n", s>mb_x, s>mb_y);

1771 
// skip_bits(gb, 1);

1772 
// align_get_bits(gb);

1773 
if(get_bits(gb, 16)!=0){ 
1774 
printf("internal error while decoding video packet header\n");

1775 
} 
1776  
1777 
//printf("%X\n", show_bits(gb, 24));

1778 
bits=0;

1779 
while(!get_bits1(gb) && bits<30) bits++; 
1780 
if((s>pict_type == P_TYPE  s>pict_type == S_TYPE) && bits != s>f_code1){ 
1781 
printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n",

1782 
bits+1, s>f_code, get_bits_count(gb), gb>size*8, s>mb_x, s>mb_y); 
1783 
return 1; 
1784 
}else if(s>pict_type == I_TYPE && bits != 0){ 
1785 
printf("marker too long\n");

1786 
return 1; 
1787 
}else if(s>pict_type == B_TYPE && bits != MAX(MAX(s>f_code, s>b_code)1, 1)){ 
1788 
printf("marker does not match f/b_code\n");

1789 
return 1; 
1790 
} 
1791 
//printf("%X\n", show_bits(gb, 24));

1792  
1793 
if(s>shape != RECT_SHAPE){

1794 
header_extension= get_bits1(gb); 
1795 
//FIXME more stuff here

1796 
} 
1797  
1798 
mb_num= get_bits(gb, mb_num_bits); 
1799 
if(mb_num < s>mb_x + s>mb_y*s>mb_width  mb_num>=s>mb_num){

1800 
fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s>mb_x + s>mb_y*s>mb_width);

1801 
return 1; 
1802 
} 
1803  
1804 
if(s>shape != BIN_ONLY_SHAPE){

1805 
s>next_resync_qscale= get_bits(gb, 5);

1806 
if(s>next_resync_qscale==0) 
1807 
s>next_resync_qscale= s>qscale; 
1808 
if(s>next_resync_qscale==0){ 
1809 
fprintf(stderr, "qscale==0\n");

1810 
return 1; 
1811 
} 
1812 
} 
1813  
1814 
if(s>shape == RECT_SHAPE){

1815 
header_extension= get_bits1(gb); 
1816 
} 
1817 
if(header_extension){

1818 
int time_increment;

1819 
int time_incr=0; 
1820 
printf("header extension not supported\n");

1821 
return 1; 
1822  
1823 
while (get_bits1(gb) != 0) 
1824 
time_incr++; 
1825  
1826 
check_marker(gb, "before time_increment in video packed header");

1827 
time_increment= get_bits(gb, s>time_increment_bits); 
1828 
if(s>pict_type!=B_TYPE){

1829 
s>last_time_base= s>time_base; 
1830 
s>time_base+= time_incr; 
1831 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
1832 
s>pp_time= s>time  s>last_non_b_time; 
1833 
s>last_non_b_time= s>time; 
1834 
}else{

1835 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
1836 
s>bp_time= s>last_non_b_time  s>time; 
1837 
} 
1838 
check_marker(gb, "before vop_coding_type in video packed header");

1839 

1840 
skip_bits(gb, 2); /* vop coding type */ 
1841 
//FIXME not rect stuff here

1842  
1843 
if(s>shape != BIN_ONLY_SHAPE){

1844 
skip_bits(gb, 3); /* intra dc vlc threshold */ 
1845  
1846 
if(s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE && s>num_sprite_warping_points){

1847 
mpeg4_decode_sprite_trajectory(s); 
1848 
} 
1849  
1850 
//FIXME reduced res stuff here

1851 

1852 
if (s>pict_type != I_TYPE) {

1853 
s>f_code = get_bits(gb, 3); /* fcode_for */ 
1854 
if(s>f_code==0){ 
1855 
printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");

1856 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
1857 
} 
1858 
} 
1859 
if (s>pict_type == B_TYPE) {

1860 
s>b_code = get_bits(gb, 3);

1861 
} 
1862 
} 
1863 
} 
1864 
//FIXME newpred stuff

1865 

1866 
//printf("parse ok %d %d %d %d\n", mb_num, s>mb_x + s>mb_y*s>mb_width, get_bits_count(gb), get_bits_count(&s>gb));

1867  
1868 
return mb_num;

1869 
} 
1870  
1871 
void ff_mpeg4_clean_buffers(MpegEncContext *s)

1872 
{ 
1873 
int c_wrap, c_xy, l_wrap, l_xy;

1874  
1875 
l_wrap= s>block_wrap[0];

1876 
l_xy= s>mb_y*l_wrap*2 + s>mb_x*2; 
1877 
c_wrap= s>block_wrap[4];

1878 
c_xy= s>mb_y*c_wrap + s>mb_x; 
1879  
1880 
/* clean DC */

1881 
memsetw(s>dc_val[0] + l_xy, 1024, l_wrap*2+1); 
1882 
memsetw(s>dc_val[1] + c_xy, 1024, c_wrap+1); 
1883 
memsetw(s>dc_val[2] + c_xy, 1024, c_wrap+1); 
1884  
1885 
/* clean AC */

1886 
memset(s>ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16)); 
1887 
memset(s>ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); 
1888 
memset(s>ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); 
1889  
1890 
/* clean MV */

1891 
// we cant clear the MVs as they might be needed by a b frame

1892 
// memset(s>motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));

1893 
// memset(s>motion_val, 0, 2*sizeof(INT16)*(2 + s>mb_width*2)*(2 + s>mb_height*2));

1894 
s>last_mv[0][0][0]= 
1895 
s>last_mv[0][0][1]= 
1896 
s>last_mv[1][0][0]= 
1897 
s>last_mv[1][0][1]= 0; 
1898 
} 
1899  
1900 
/* searches for the next resync marker clears ac,dc,mc, and sets s>next_resync_gb, s>mb_num_left */

1901 
int ff_mpeg4_resync(MpegEncContext *s)

1902 
{ 
1903 
GetBitContext gb; 
1904 

1905 
/* search & parse next resync marker */

1906 

1907 
gb= s>next_resync_gb; 
1908 
align_get_bits(&gb); 
1909 
//printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s>next_resync_gb));

1910 
for(;;) {

1911 
int v= show_bits(&gb, 24); 
1912 
if( get_bits_count(&gb) >= gb.size*824  v == 1 /* startcode */){ 
1913 
s>mb_num_left= s>mb_num  s>mb_x  s>mb_y*s>mb_width; 
1914 
//printf("mpeg4_resync end\n");

1915 
s>gb= s>next_resync_gb; //continue at the next resync marker

1916 
return 1; 
1917 
}else if(v>>8 == 0){ 
1918 
int next;

1919 
s>next_resync_pos= get_bits_count(&gb); 
1920 

1921 
next= decode_video_packet_header(s, &gb); 
1922 
if(next >= 0){ 
1923 
s>mb_num_left= next  s>mb_x  s>mb_y*s>mb_width; 
1924 
break;

1925 
} 
1926  
1927 
align_get_bits(&gb); 
1928 
} 
1929 
skip_bits(&gb, 8);

1930 
} 
1931 
s>next_resync_gb=gb; 
1932 

1933 
return 0; 
1934 
} 
1935  
1936 
static inline void init_block_index(MpegEncContext *s) 
1937 
{ 
1938 
s>block_index[0]= s>block_wrap[0]*(s>mb_y*2 + 1)  1 + s>mb_x*2; 
1939 
s>block_index[1]= s>block_wrap[0]*(s>mb_y*2 + 1) + s>mb_x*2; 
1940 
s>block_index[2]= s>block_wrap[0]*(s>mb_y*2 + 2)  1 + s>mb_x*2; 
1941 
s>block_index[3]= s>block_wrap[0]*(s>mb_y*2 + 2) + s>mb_x*2; 
1942 
s>block_index[4]= s>block_wrap[4]*(s>mb_y + 1) + s>block_wrap[0]*(s>mb_height*2 + 2) + s>mb_x; 
1943 
s>block_index[5]= s>block_wrap[4]*(s>mb_y + 1 + s>mb_height + 2) + s>block_wrap[0]*(s>mb_height*2 + 2) + s>mb_x; 
1944 
} 
1945  
1946 
static inline void update_block_index(MpegEncContext *s) 
1947 
{ 
1948 
s>block_index[0]+=2; 
1949 
s>block_index[1]+=2; 
1950 
s>block_index[2]+=2; 
1951 
s>block_index[3]+=2; 
1952 
s>block_index[4]++;

1953 
s>block_index[5]++;

1954 
} 
1955  
1956 
/**

1957 
* decodes the first & second partition

1958 
* returns error type or 0 if no error

1959 
*/

1960 
int ff_mpeg4_decode_partitions(MpegEncContext *s)

1961 
{ 
1962 
static const INT8 quant_tab[4] = { 1, 2, 1, 2 }; 
1963 
int mb_num;

1964 

1965 
/* decode first partition */

1966 
mb_num=0;

1967 
s>first_slice_line=1;

1968 
s>mb_x= s>resync_mb_x; 
1969 
for(s>mb_y= s>resync_mb_y; mb_num < s>mb_num_left; s>mb_y++){

1970 
init_block_index(s); 
1971 
for(; mb_num < s>mb_num_left && s>mb_x<s>mb_width; s>mb_x++){

1972 
const int xy= s>mb_x + s>mb_y*s>mb_width; 
1973 
int cbpc;

1974 
int dir=0; 
1975 

1976 
mb_num++; 
1977 
update_block_index(s); 
1978 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1) 
1979 
s>first_slice_line=0;

1980 

1981 
if(s>mb_x==0) PRINT_MB_TYPE("\n"); 
1982  
1983 
if(s>pict_type==I_TYPE){

1984 
int i;

1985  
1986 
PRINT_MB_TYPE("I");

1987 
cbpc = get_vlc(&s>gb, &intra_MCBPC_vlc); 
1988 
if (cbpc < 0){ 
1989 
fprintf(stderr, "cbpc corrupted at %d %d\n", s>mb_x, s>mb_y);

1990 
return DECODING_DESYNC;

1991 
} 
1992 
s>cbp_table[xy]= cbpc & 3;

1993 
s>mb_type[xy]= MB_TYPE_INTRA; 
1994 
s>mb_intra = 1;

1995  
1996 
if(cbpc & 4) { 
1997 
s>qscale += quant_tab[get_bits(&s>gb, 2)];

1998 
if (s>qscale < 1) 
1999 
s>qscale = 1;

2000 
else if (s>qscale > 31) 
2001 
s>qscale = 31;

2002 
h263_dc_scale(s); 
2003 
} 
2004 
s>qscale_table[xy]= s>qscale; 
2005  
2006 
s>mbintra_table[xy]= 1;

2007 
for(i=0; i<6; i++){ 
2008 
int dc_pred_dir;

2009 
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);

2010 
if(dc < 0){ 
2011 
fprintf(stderr, "DC corrupted at %d %d\n", s>mb_x, s>mb_y);

2012 
return DECODING_DESYNC;

2013 
} 
2014 
dir<<=1;

2015 
if(dc_pred_dir) dir=1; 
2016 
} 
2017 
s>pred_dir_table[xy]= dir; 
2018 
}else{ /* P/S_TYPE */ 
2019 
int mx, my, pred_x, pred_y;

2020 
INT16 * const mot_val= s>motion_val[s>block_index[0]]; 
2021 
const int stride= s>block_wrap[0]*2; 
2022  
2023 
if(get_bits1(&s>gb)){

2024 
/* skip mb */

2025 
s>mb_type[xy]= MB_TYPE_SKIPED; 
2026 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

2027 
const int a= s>sprite_warping_accuracy; 
2028 
PRINT_MB_TYPE("G");

2029 
if(s>divx_version==500 && s>divx_build==413){ 
2030 
mx = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
2031 
my = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
2032 
}else{

2033 
mx = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
2034 
my = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
2035 
s>mb_type[xy]= MB_TYPE_GMC  MB_TYPE_SKIPED; 
2036 
} 
2037 
}else{

2038 
PRINT_MB_TYPE("S");

2039 
mx = 0;

2040 
my = 0;

2041 
} 
2042 
mot_val[0 ]= mot_val[2 ]= 
2043 
mot_val[0+stride]= mot_val[2+stride]= mx; 
2044 
mot_val[1 ]= mot_val[3 ]= 
2045 
mot_val[1+stride]= mot_val[3+stride]= my; 
2046  
2047 
if(s>mbintra_table[xy])

2048 
ff_clean_intra_table_entries(s); 
2049  
2050 
continue;

2051 
} 
2052 
cbpc = get_vlc(&s>gb, &inter_MCBPC_vlc); 
2053 
if (cbpc < 0){ 
2054 
fprintf(stderr, "cbpc corrupted at %d %d\n", s>mb_x, s>mb_y);

2055 
return DECODING_DESYNC;

2056 
} 
2057 
if (cbpc > 20) 
2058 
cbpc+=3;

2059 
else if (cbpc == 20) 
2060 
fprintf(stderr, "Stuffing !");

2061 
s>cbp_table[xy]= cbpc&(8+3); //8 is dquant 
2062 

2063 
s>mb_intra = ((cbpc & 4) != 0); 
2064 

2065 
if(s>mb_intra){

2066 
PRINT_MB_TYPE("I");

2067 
s>mbintra_table[xy]= 1;

2068 
s>mb_type[xy]= MB_TYPE_INTRA; 
2069 
mot_val[0 ]= mot_val[2 ]= 
2070 
mot_val[0+stride]= mot_val[2+stride]= 0; 
2071 
mot_val[1 ]= mot_val[3 ]= 
2072 
mot_val[1+stride]= mot_val[3+stride]= 0; 
2073 
}else{

2074 
if(s>mbintra_table[xy])

2075 
ff_clean_intra_table_entries(s); 
2076  
2077 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
2078 
s>mcsel= get_bits1(&s>gb); 
2079 
else s>mcsel= 0; 
2080 

2081 
if ((cbpc & 16) == 0) { 
2082 
PRINT_MB_TYPE("P");

2083 
/* 16x16 motion prediction */

2084 
s>mb_type[xy]= MB_TYPE_INTER; 
2085  
2086 
h263_pred_motion(s, 0, &pred_x, &pred_y);

2087 
if(!s>mcsel)

2088 
mx = h263_decode_motion(s, pred_x, s>f_code); 
2089 
else {

2090 
const int a= s>sprite_warping_accuracy; 
2091 
if(s>divx_version==500 && s>divx_build==413){ 
2092 
mx = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
2093 
}else{

2094 
mx = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
2095 
} 
2096 
} 
2097 
if (mx >= 0xffff) 
2098 
return DECODING_DESYNC;

2099 

2100 
if(!s>mcsel)

2101 
my = h263_decode_motion(s, pred_y, s>f_code); 
2102 
else{

2103 
const int a= s>sprite_warping_accuracy; 
2104 
if(s>divx_version==500 && s>divx_build==413){ 
2105 
my = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
2106 
}else{

2107 
my = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
2108 
} 
2109 
} 
2110 
if (my >= 0xffff) 
2111 
return DECODING_DESYNC;

2112 
mot_val[0 ]= mot_val[2 ] = 
2113 
mot_val[0+stride]= mot_val[2+stride]= mx; 
2114 
mot_val[1 ]= mot_val[3 ]= 
2115 
mot_val[1+stride]= mot_val[3+stride]= my; 
2116 
} else {

2117 
int i;

2118 
PRINT_MB_TYPE("4");

2119 
s>mb_type[xy]= MB_TYPE_INTER4V; 
2120 
for(i=0;i<4;i++) { 
2121 
INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); 
2122 
mx = h263_decode_motion(s, pred_x, s>f_code); 
2123 
if (mx >= 0xffff) 
2124 
return DECODING_DESYNC;

2125 

2126 
my = h263_decode_motion(s, pred_y, s>f_code); 
2127 
if (my >= 0xffff) 
2128 
return DECODING_DESYNC;

2129 
mot_val[0] = mx;

2130 
mot_val[1] = my;

2131 
} 
2132 
} 
2133 
} 
2134 
} 
2135 
} 
2136 
s>mb_x= 0;

2137 
} 
2138  
2139 
if (s>pict_type==I_TYPE && get_bits(&s>gb, 19)!=DC_MARKER ) s>decoding_error= DECODING_DESYNC; 
2140 
else if(s>pict_type!=I_TYPE && get_bits(&s>gb, 17)!=MOTION_MARKER) s>decoding_error= DECODING_DESYNC; 
2141 
if(s>decoding_error== DECODING_DESYNC){

2142 
fprintf(stderr, "marker missing after first partition at %d %d\n", s>mb_x, s>mb_y);

2143 
return DECODING_DESYNC;

2144 
} 
2145  
2146 
/* decode second partition */

2147 
mb_num=0;

2148 
s>mb_x= s>resync_mb_x; 
2149 
for(s>mb_y= s>resync_mb_y; mb_num < s>mb_num_left; s>mb_y++){

2150 
init_block_index(s); 
2151 
for(; mb_num < s>mb_num_left && s>mb_x<s>mb_width; s>mb_x++){

2152 
const int xy= s>mb_x + s>mb_y*s>mb_width; 
2153  
2154 
mb_num++; 
2155 
update_block_index(s); 
2156 

2157 
if(s>pict_type==I_TYPE){

2158 
int ac_pred= get_bits1(&s>gb);

2159 
int cbpy = get_vlc(&s>gb, &cbpy_vlc);

2160 
if(cbpy<0){ 
2161 
fprintf(stderr, "cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

2162 
return DECODING_AC_LOST;

2163 
} 
2164 

2165 
s>cbp_table[xy]= cbpy<<2;

2166 
s>pred_dir_table[xy]= ac_pred<<7;

2167 
}else{ /* P  S_TYPE */ 
2168 
if(s>mb_type[xy]&MB_TYPE_INTRA){

2169 
int dir=0,i; 
2170 
int ac_pred = get_bits1(&s>gb);

2171 
int cbpy = get_vlc(&s>gb, &cbpy_vlc);

2172  
2173 
if(cbpy<0){ 
2174 
fprintf(stderr, "I cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

2175 
return DECODING_ACDC_LOST;

2176 
} 
2177 

2178 
if(s>cbp_table[xy] & 8) { 
2179 
s>qscale += quant_tab[get_bits(&s>gb, 2)];

2180 
if (s>qscale < 1) 
2181 
s>qscale = 1;

2182 
else if (s>qscale > 31) 
2183 
s>qscale = 31;

2184 
h263_dc_scale(s); 
2185 
} 
2186 
s>qscale_table[xy]= s>qscale; 
2187  
2188 
for(i=0; i<6; i++){ 
2189 
int dc_pred_dir;

2190 
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);

2191 
if(dc < 0){ 
2192 
fprintf(stderr, "DC corrupted at %d %d\n", s>mb_x, s>mb_y);

2193 
return DECODING_ACDC_LOST;

2194 
} 
2195 
dir<<=1;

2196 
if(dc_pred_dir) dir=1; 
2197 
} 
2198 
s>cbp_table[xy]&= 3; //remove dquant 
2199 
s>cbp_table[xy]= cbpy<<2;

2200 
s>pred_dir_table[xy]= dir  (ac_pred<<7);

2201 
}else if(s>mb_type[xy]&MB_TYPE_SKIPED){ 
2202 
s>qscale_table[xy]= s>qscale; 
2203 
s>cbp_table[xy]= 0;

2204 
}else{

2205 
int cbpy = get_vlc(&s>gb, &cbpy_vlc);

2206  
2207 
if(cbpy<0){ 
2208 
fprintf(stderr, "P cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

2209 
return DECODING_ACDC_LOST;

2210 
} 
2211 

2212 
if(s>cbp_table[xy] & 8) { 
2213 
//fprintf(stderr, "dquant\n");

2214 
s>qscale += quant_tab[get_bits(&s>gb, 2)];

2215 
if (s>qscale < 1) 
2216 
s>qscale = 1;

2217 
else if (s>qscale > 31) 
2218 
s>qscale = 31;

2219 
h263_dc_scale(s); 
2220 
} 
2221 
s>qscale_table[xy]= s>qscale; 
2222  
2223 
s>cbp_table[xy]&= 3; //remove dquant 
2224 
s>cbp_table[xy]= (cbpy^0xf)<<2; 
2225 
} 
2226 
} 
2227 
} 
2228 
s>mb_x= 0;

2229 
} 
2230 

2231  
2232 
return 0; 
2233 
} 
2234  
2235 
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, 
2236 
DCTELEM block[6][64]) 
2237 
{ 
2238 
int cbp, mb_type;

2239 
const int xy= s>mb_x + s>mb_y*s>mb_width; 
2240  
2241 
if(s>mb_x==s>resync_mb_x && s>mb_y==s>resync_mb_y){ //Note resync_mb_{x,y}==0 at the start 
2242 
int i;

2243 
int block_index_backup[6]; 
2244 
int qscale= s>qscale;

2245 

2246 
for(i=0; i<6; i++) block_index_backup[i]= s>block_index[i]; 
2247 

2248 
s>decoding_error= ff_mpeg4_decode_partitions(s); 
2249 

2250 
for(i=0; i<6; i++) s>block_index[i]= block_index_backup[i]; 
2251 
s>first_slice_line=1;

2252 
s>mb_x= s>resync_mb_x; 
2253 
s>mb_y= s>resync_mb_y; 
2254 
s>qscale= qscale; 
2255 
h263_dc_scale(s); 
2256  
2257 
if(s>decoding_error==DECODING_DESYNC) return 1; 
2258 
} 
2259 

2260 
mb_type= s>mb_type[xy]; 
2261 
if(s>decoding_error)

2262 
cbp=0;

2263 
else

2264 
cbp = s>cbp_table[xy]; 
2265  
2266 
if(s>decoding_error!=DECODING_ACDC_LOST && s>qscale_table[xy] != s>qscale){

2267 
s>qscale= s>qscale_table[xy]; 
2268 
h263_dc_scale(s); 
2269 
} 
2270  
2271 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

2272 
int i;

2273 
for(i=0; i<4; i++){ 
2274 
s>mv[0][i][0] = s>motion_val[ s>block_index[i] ][0]; 
2275 
s>mv[0][i][1] = s>motion_val[ s>block_index[i] ][1]; 
2276 
} 
2277 
s>mb_intra = mb_type&MB_TYPE_INTRA; 
2278  
2279 
if (mb_type&MB_TYPE_SKIPED) {

2280 
/* skip mb */

2281 
for(i=0;i<6;i++) 
2282 
s>block_last_index[i] = 1;

2283 
s>mv_dir = MV_DIR_FORWARD; 
2284 
s>mv_type = MV_TYPE_16X16; 
2285 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

2286 
s>mcsel=1;

2287 
s>mb_skiped = 0;

2288 
}else{

2289 
s>mcsel=0;

2290 
s>mb_skiped = 1;

2291 
} 
2292 
return 0; 
2293 
}else if(s>mb_intra && s>decoding_error!=DECODING_ACDC_LOST){ 
2294 
s>ac_pred = s>pred_dir_table[xy]>>7;

2295  
2296 
/* decode each block */

2297 
for (i = 0; i < 6; i++) { 
2298 
int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1); 
2299 
if(ret==DECODING_AC_LOST){

2300 
fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s>mb_x, s>mb_y);

2301 
s>decoding_error=DECODING_AC_LOST; 
2302 
cbp=0;

2303 
}else if(ret==DECODING_ACDC_LOST){ 
2304 
fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s>mb_x, s>mb_y);

2305 
s>decoding_error=DECODING_ACDC_LOST; 
2306 
break;

2307 
} 
2308 
} 
2309 
}else if(!s>mb_intra){ 
2310 
// s>mcsel= 0; //FIXME do we need to init that

2311 

2312 
s>mv_dir = MV_DIR_FORWARD; 
2313 
if (mb_type&MB_TYPE_INTER4V) {

2314 
s>mv_type = MV_TYPE_8X8; 
2315 
} else {

2316 
s>mv_type = MV_TYPE_16X16; 
2317 
} 
2318 
if(s>decoding_error==0 && cbp){ 
2319 
/* decode each block */

2320 
for (i = 0; i < 6; i++) { 
2321 
int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1); 
2322 
if(ret==DECODING_AC_LOST){

2323 
fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s>mb_x, s>mb_y);

2324 
s>decoding_error=DECODING_AC_LOST; 
2325 
break;

2326 
} 
2327 
} 
2328 
} 
2329 
} 
2330 
} else { /* IFrame */ 
2331 
int i;

2332 
s>mb_intra = 1;

2333 
s>ac_pred = s>pred_dir_table[xy]>>7;

2334 

2335 
/* decode each block */

2336 
for (i = 0; i < 6; i++) { 
2337 
int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1); 
2338 
if(ret==DECODING_AC_LOST){

2339 
fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s>mb_x, s>mb_y);

2340 
s>decoding_error=DECODING_AC_LOST; 
2341 
cbp=0;

2342 
}else if(ret==DECODING_ACDC_LOST){ 
2343 
fprintf(stderr, "dc corrupted at %d %d\n", s>mb_x, s>mb_y);

2344 
return 1; 
2345 
} 
2346 
} 
2347 
} 
2348  
2349 
return 0; 
2350 
} 
2351  
2352  
2353 
int h263_decode_mb(MpegEncContext *s,

2354 
DCTELEM block[6][64]) 
2355 
{ 
2356 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

2357 
INT16 *mot_val; 
2358 
static INT8 quant_tab[4] = { 1, 2, 1, 2 }; 
2359  
2360 
if(s>mb_x==0) PRINT_MB_TYPE("\n") 
2361  
2362 
if(s>resync_marker){

2363 
if(s>resync_mb_x == s>mb_x && s>resync_mb_y+1 == s>mb_y){ 
2364 
s>first_slice_line=0;

2365 
} 
2366 
} 
2367  
2368 
if(s>data_partitioning && s>pict_type!=B_TYPE)

2369 
return mpeg4_decode_partitioned_mb(s, block);

2370  
2371 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

2372 
if (get_bits1(&s>gb)) {

2373 
/* skip mb */

2374 
s>mb_intra = 0;

2375 
for(i=0;i<6;i++) 
2376 
s>block_last_index[i] = 1;

2377 
s>mv_dir = MV_DIR_FORWARD; 
2378 
s>mv_type = MV_TYPE_16X16; 
2379 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

2380 
const int a= s>sprite_warping_accuracy; 
2381 
// int l = (1 << (s>f_code  1)) * 32;

2382 
PRINT_MB_TYPE("G");

2383 
s>mcsel=1;

2384 
if(s>divx_version==500 && s>divx_build==413){ 
2385 
s>mv[0][0][0] = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
2386 
s>mv[0][0][1] = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
2387 
}else{

2388 
s>mv[0][0][0] = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
2389 
s>mv[0][0][1] = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
2390 
} 
2391 
/* if (s>mv[0][0][0] < l) s>mv[0][0][0]= l;

2392 
else if (s>mv[0][0][0] >= l) s>mv[0][0][0]= l1;

2393 
if (s>mv[0][0][1] < l) s>mv[0][0][1]= l;

2394 
else if (s>mv[0][0][1] >= l) s>mv[0][0][1]= l1;*/

2395  
2396 
s>mb_skiped = 0;

2397 
}else{

2398 
PRINT_MB_TYPE("S");

2399 
s>mcsel=0;

2400 
s>mv[0][0][0] = 0; 
2401 
s>mv[0][0][1] = 0; 
2402 
s>mb_skiped = 1;

2403 
} 
2404 
return 0; 
2405 
} 
2406 
cbpc = get_vlc(&s>gb, &inter_MCBPC_vlc); 
2407 
//fprintf(stderr, "\tCBPC: %d", cbpc);

2408 
if (cbpc < 0) 
2409 
return 1; 
2410 
if (cbpc > 20) 
2411 
cbpc+=3;

2412 
else if (cbpc == 20) 
2413 
fprintf(stderr, "Stuffing !");

2414 

2415 
dquant = cbpc & 8;

2416 
s>mb_intra = ((cbpc & 4) != 0); 
2417 
if (s>mb_intra) goto intra; 
2418 

2419 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
2420 
s>mcsel= get_bits1(&s>gb); 
2421 
else s>mcsel= 0; 
2422 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
2423 
cbp = (cbpc & 3)  ((cbpy ^ 0xf) << 2); 
2424 
if (dquant) {

2425 
s>qscale += quant_tab[get_bits(&s>gb, 2)];

2426 
if (s>qscale < 1) 
2427 
s>qscale = 1;

2428 
else if (s>qscale > 31) 
2429 
s>qscale = 31;

2430 
h263_dc_scale(s); 
2431 
} 
2432 
s>mv_dir = MV_DIR_FORWARD; 
2433 
if ((cbpc & 16) == 0) { 
2434 
PRINT_MB_TYPE("P");

2435 
/* 16x16 motion prediction */

2436 
s>mv_type = MV_TYPE_16X16; 
2437 
h263_pred_motion(s, 0, &pred_x, &pred_y);

2438 
if (s>umvplus_dec)

2439 
mx = h263p_decode_umotion(s, pred_x); 
2440 
else if(!s>mcsel) 
2441 
mx = h263_decode_motion(s, pred_x, s>f_code); 
2442 
else {

2443 
const int a= s>sprite_warping_accuracy; 
2444 
// int l = (1 << (s>f_code  1)) * 32;

2445 
if(s>divx_version==500 && s>divx_build==413){ 
2446 
mx = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
2447 
}else{

2448 
mx = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
2449 
} 
2450 
// if (mx < l) mx= l, printf("C");

2451 
// else if (mx >= l) mx= l1, printf("C");

2452 
} 
2453 
if (mx >= 0xffff) 
2454 
return 1; 
2455 

2456 
if (s>umvplus_dec)

2457 
my = h263p_decode_umotion(s, pred_y); 
2458 
else if(!s>mcsel) 
2459 
my = h263_decode_motion(s, pred_y, s>f_code); 
2460 
else{

2461 
const int a= s>sprite_warping_accuracy; 
2462 
// int l = (1 << (s>f_code  1)) * 32;

2463 
if(s>divx_version==500 && s>divx_build==413){ 
2464 
my = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
2465 
}else{

2466 
my = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
2467 
} 
2468 
// if (my < l) my= l, printf("C");

2469 
// else if (my >= l) my= l1, printf("C");

2470 
} 
2471 
if (my >= 0xffff) 
2472 
return 1; 
2473 
s>mv[0][0][0] = mx; 
2474 
s>mv[0][0][1] = my; 
2475 
/*fprintf(stderr, "\n MB %d", (s>mb_y * s>mb_width) + s>mb_x);

2476 
fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);

2477 
fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/

2478 
if (s>umvplus_dec && (mx  pred_x) == 1 && (my  pred_y) == 1) 
2479 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

2480 

2481 
} else {

2482 
PRINT_MB_TYPE("4");

2483 
s>mv_type = MV_TYPE_8X8; 
2484 
for(i=0;i<4;i++) { 
2485 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
2486 
if (s>umvplus_dec)

2487 
mx = h263p_decode_umotion(s, pred_x); 
2488 
else

2489 
mx = h263_decode_motion(s, pred_x, s>f_code); 
2490 
if (mx >= 0xffff) 
2491 
return 1; 
2492 

2493 
if (s>umvplus_dec)

2494 
my = h263p_decode_umotion(s, pred_y); 
2495 
else

2496 
my = h263_decode_motion(s, pred_y, s>f_code); 
2497 
if (my >= 0xffff) 
2498 
return 1; 
2499 
s>mv[0][i][0] = mx; 
2500 
s>mv[0][i][1] = my; 
2501 
if (s>umvplus_dec && (mx  pred_x) == 1 && (my  pred_y) == 1) 
2502 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

2503 
mot_val[0] = mx;

2504 
mot_val[1] = my;

2505 
} 
2506 
} 
2507 
} else if(s>pict_type==B_TYPE) { 
2508 
int modb1; // first bit of modb 
2509 
int modb2; // second bit of modb 
2510 
int mb_type;

2511 
uint16_t time_pp; 
2512 
uint16_t time_pb; 
2513 
int xy;

2514  
2515 
s>mb_intra = 0; //Bframes never contain intra blocks 
2516 
s>mcsel=0; // ... true gmc blocks 
2517  
2518 
if(s>mb_x==0){ 
2519 
s>last_mv[0][0][0]= 
2520 
s>last_mv[0][0][1]= 
2521 
s>last_mv[1][0][0]= 
2522 
s>last_mv[1][0][1]= 0; 
2523 
} 
2524  
2525 
/* if we skipped it in the future P Frame than skip it now too */

2526 
s>mb_skiped= s>mbskip_table[s>mb_y * s>mb_width + s>mb_x]; // Note, skiptab=0 if last was GMC

2527  
2528 
if(s>mb_skiped){

2529 
/* skip mb */

2530 
for(i=0;i<6;i++) 
2531 
s>block_last_index[i] = 1;

2532  
2533 
s>mv_dir = MV_DIR_FORWARD; 
2534 
s>mv_type = MV_TYPE_16X16; 
2535 
s>mv[0][0][0] = 0; 
2536 
s>mv[0][0][1] = 0; 
2537 
s>mv[1][0][0] = 0; 
2538 
s>mv[1][0][1] = 0; 
2539 
//FIXME is this correct?

2540 
/* s>last_mv[0][0][0]=

2541 
s>last_mv[0][0][1]=0;*/

2542 
PRINT_MB_TYPE("s")

2543 
return 0; 
2544 
} 
2545  
2546 
modb1= get_bits1(&s>gb); 
2547 
if(modb1==0){ 
2548 
modb2= get_bits1(&s>gb); 
2549 
mb_type= get_vlc(&s>gb, &mb_type_b_vlc); 
2550 
if(modb2==0) cbp= get_bits(&s>gb, 6); 
2551 
else cbp=0; 
2552 
if (mb_type && cbp) {

2553 
if(get_bits1(&s>gb)){

2554 
s>qscale +=get_bits1(&s>gb)*4  2; 
2555 
if (s>qscale < 1) 
2556 
s>qscale = 1;

2557 
else if (s>qscale > 31) 
2558 
s>qscale = 31;

2559 
h263_dc_scale(s); 
2560 
} 
2561 
} 
2562 
}else{

2563 
mb_type=4; //like 0 but no vectors coded 
2564 
cbp=0;

2565 
} 
2566 
s>mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here

2567 
mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my 
2568 
switch(mb_type)

2569 
{ 
2570 
case 0: /* direct */ 
2571 
mx = h263_decode_motion(s, 0, 1); 
2572 
my = h263_decode_motion(s, 0, 1); 
2573 
case 4: /* direct with mx=my=0 */ 
2574 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
2575 
xy= s>block_index[0];

2576 
time_pp= s>pp_time; 
2577 
time_pb= time_pp  s>bp_time; 
2578 
//if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);

2579 
//FIXME 4MV

2580 
//FIXME avoid divides

2581 
s>mv[0][0][0] = s>motion_val[xy][0]*time_pb/time_pp + mx; 
2582 
s>mv[0][0][1] = s>motion_val[xy][1]*time_pb/time_pp + my; 
2583 
s>mv[1][0][0] = mx ? s>mv[0][0][0]  s>motion_val[xy][0] 
2584 
: s>motion_val[xy][0]*(time_pb  time_pp)/time_pp + mx;

2585 
s>mv[1][0][1] = my ? s>mv[0][0][1]  s>motion_val[xy][1] 
2586 
: s>motion_val[xy][1]*(time_pb  time_pp)/time_pp + my;

2587 
/* s>mv[0][0][0] =

2588 
s>mv[0][0][1] =

2589 
s>mv[1][0][0] =

2590 
s>mv[1][0][1] = 1000;*/

2591 
PRINT_MB_TYPE("D");

2592 
break;

2593 
case 1: 
2594 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD; 
2595 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
2596 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
2597 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
2598 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
2599  
2600 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
2601 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
2602 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
2603 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
2604 
PRINT_MB_TYPE("i");

2605 
break;

2606 
case 2: 
2607 
s>mv_dir = MV_DIR_BACKWARD; 
2608 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
2609 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
2610 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
2611 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
2612 
PRINT_MB_TYPE("B");

2613 
break;

2614 
case 3: 
2615 
s>mv_dir = MV_DIR_FORWARD; 
2616 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
2617 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
2618 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
2619 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
2620 
PRINT_MB_TYPE("F");

2621 
break;

2622 
default:

2623 
printf("illegal MB_type\n");

2624 
return 1; 
2625 
} 
2626 
} else { /* IFrame */ 
2627 
cbpc = get_vlc(&s>gb, &intra_MCBPC_vlc); 
2628 
if (cbpc < 0) 
2629 
return 1; 
2630 
dquant = cbpc & 4;

2631 
s>mb_intra = 1;

2632 
intra:

2633 
PRINT_MB_TYPE("I");

2634 
s>ac_pred = 0;

2635 
if (s>h263_pred  s>h263_aic) {

2636 
s>ac_pred = get_bits1(&s>gb); 
2637 
if (s>ac_pred && s>h263_aic)

2638 
s>h263_aic_dir = get_bits1(&s>gb); 
2639 
} 
2640 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
2641 
if(cbpy<0) return 1; 
2642 
cbp = (cbpc & 3)  (cbpy << 2); 
2643 
if (dquant) {

2644 
s>qscale += quant_tab[get_bits(&s>gb, 2)];

2645 
if (s>qscale < 1) 
2646 
s>qscale = 1;

2647 
else if (s>qscale > 31) 
2648 
s>qscale = 31;

2649 
h263_dc_scale(s); 
2650 
} 
2651 
} 
2652  
2653 
/* decode each block */

2654 
if (s>h263_pred) {

2655 
for (i = 0; i < 6; i++) { 
2656 
if (mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
2657 
return 1; 
2658 
} 
2659 
} else {

2660 
for (i = 0; i < 6; i++) { 
2661 
if (h263_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
2662 
return 1; 
2663 
} 
2664 
} 
2665 
return 0; 
2666 
} 
2667  
2668 
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 
2669 
{ 
2670 
int code, val, sign, shift, l, m;

2671  
2672 
code = get_vlc(&s>gb, &mv_vlc); 
2673 
if (code < 0) 
2674 
return 0xffff; 
2675  
2676 
if (code == 0) 
2677 
return pred;

2678 
sign = get_bits1(&s>gb); 
2679 
shift = f_code  1;

2680 
val = (code  1) << shift;

2681 
if (shift > 0) 
2682 
val = get_bits(&s>gb, shift); 
2683 
val++; 
2684 
if (sign)

2685 
val = val; 
2686 
val += pred; 
2687  
2688 
/* modulo decoding */

2689 
if (!s>h263_long_vectors) {

2690 
l = (1 << (f_code  1)) * 32; 
2691 
m = 2 * l;

2692 
if (val < l) {

2693 
val += m; 
2694 
} else if (val >= l) { 
2695 
val = m; 
2696 
} 
2697 
} else {

2698 
/* horrible h263 long vector mode */

2699 
if (pred < 31 && val < 63) 
2700 
val += 64;

2701 
if (pred > 32 && val > 63) 
2702 
val = 64;

2703 

2704 
} 
2705 
return val;

2706 
} 
2707  
2708 
/* Decodes RVLC of H.263+ UMV */

2709 
static int h263p_decode_umotion(MpegEncContext * s, int pred) 
2710 
{ 
2711 
int code = 0, sign; 
2712 

2713 
if (get_bits1(&s>gb)) /* Motion difference = 0 */ 
2714 
return pred;

2715 

2716 
code = 2 + get_bits1(&s>gb);

2717 

2718 
while (get_bits1(&s>gb))

2719 
{ 
2720 
code <<= 1;

2721 
code += get_bits1(&s>gb); 
2722 
} 
2723 
sign = code & 1;

2724 
code >>= 1;

2725 

2726 
code = (sign) ? (pred  code) : (pred + code); 
2727 
#ifdef DEBUG

2728 
fprintf(stderr,"H.263+ UMV Motion = %d\n", code);

2729 
#endif

2730 
return code;

2731  
2732 
} 
2733  
2734 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
2735 
int n, int coded) 
2736 
{ 
2737 
int code, level, i, j, last, run;

2738 
RLTable *rl = &rl_inter; 
2739 
const UINT8 *scan_table;

2740  
2741 
scan_table = zigzag_direct; 
2742 
if (s>h263_aic && s>mb_intra) {

2743 
rl = &rl_intra_aic; 
2744 
i = 0;

2745 
if (s>ac_pred) {

2746 
if (s>h263_aic_dir)

2747 
scan_table = ff_alternate_vertical_scan; /* left */

2748 
else

2749 
scan_table = ff_alternate_horizontal_scan; /* top */

2750 
} 
2751 
} else if (s>mb_intra) { 
2752 
/* DC coef */

2753 
if (s>h263_rv10 && s>rv10_version == 3 && s>pict_type == I_TYPE) { 
2754 
int component, diff;

2755 
component = (n <= 3 ? 0 : n  4 + 1); 
2756 
level = s>last_dc[component]; 
2757 
if (s>rv10_first_dc_coded[component]) {

2758 
diff = rv_decode_dc(s, n); 
2759 
if (diff == 0xffff) 
2760 
return 1; 
2761 
level += diff; 
2762 
level = level & 0xff; /* handle wrap round */ 
2763 
s>last_dc[component] = level; 
2764 
} else {

2765 
s>rv10_first_dc_coded[component] = 1;

2766 
} 
2767 
} else {

2768 
level = get_bits(&s>gb, 8);

2769 
if (level == 255) 
2770 
level = 128;

2771 
} 
2772 
block[0] = level;

2773 
i = 1;

2774 
} else {

2775 
i = 0;

2776 
} 
2777 
if (!coded) {

2778 
if (s>mb_intra && s>h263_aic)

2779 
goto not_coded;

2780 
s>block_last_index[n] = i  1;

2781 
return 0; 
2782 
} 
2783  
2784 
for(;;) {

2785 
code = get_vlc(&s>gb, &rl>vlc); 
2786 
if (code < 0) 
2787 
return 1; 
2788 
if (code == rl>n) {

2789 
/* escape */

2790 
last = get_bits1(&s>gb); 
2791 
run = get_bits(&s>gb, 6);

2792 
level = (INT8)get_bits(&s>gb, 8);

2793 
if (s>h263_rv10 && level == 128) { 
2794 
/* XXX: should patch encoder too */

2795 
level = get_bits(&s>gb, 12);

2796 
level = (level << 20) >> 20; 
2797 
} 
2798 
} else {

2799 
run = rl>table_run[code]; 
2800 
level = rl>table_level[code]; 
2801 
last = code >= rl>last; 
2802 
if (get_bits1(&s>gb))

2803 
level = level; 
2804 
} 
2805 
i += run; 
2806 
if (i >= 64) 
2807 
return 1; 
2808 
j = scan_table[i]; 
2809 
block[j] = level; 
2810 
if (last)

2811 
break;

2812 
i++; 
2813 
} 
2814 
not_coded:

2815 
if (s>mb_intra && s>h263_aic) {

2816 
h263_pred_acdc(s, block, n); 
2817 
i = 63;

2818 
} 
2819 
s>block_last_index[n] = i; 
2820 
return 0; 
2821 
} 
2822  
2823 
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
2824 
{ 
2825 
int level, pred, code;

2826 
UINT16 *dc_val; 
2827  
2828 
if (n < 4) 
2829 
code = get_vlc(&s>gb, &dc_lum); 
2830 
else

2831 
code = get_vlc(&s>gb, &dc_chrom); 
2832 
if (code < 0  code > 9 /* && s>nbit<9 */){ 
2833 
fprintf(stderr, "illegal dc vlc\n");

2834 
return 1; 
2835 
} 
2836 
if (code == 0) { 
2837 
level = 0;

2838 
} else {

2839 
level = get_bits(&s>gb, code); 
2840 
if ((level >> (code  1)) == 0) /* if MSB not set it is negative*/ 
2841 
level =  (level ^ ((1 << code)  1)); 
2842 
if (code > 8){ 
2843 
if(get_bits1(&s>gb)==0){ /* marker */ 
2844 
fprintf(stderr, "dc marker bit missing\n");

2845 
return 1; 
2846 
} 
2847 
} 
2848 
} 
2849  
2850 
pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
2851 
level += pred; 
2852 
if (level < 0) 
2853 
level = 0;

2854 
if (n < 4) { 
2855 
*dc_val = level * s>y_dc_scale; 
2856 
} else {

2857 
*dc_val = level * s>c_dc_scale; 
2858 
} 
2859 
return level;

2860 
} 
2861  
2862 
/**

2863 
* decode a block

2864 
* returns 0 if everything went ok

2865 
* returns DECODING_AC_LOST if an error was detected during AC decoding

2866 
* returns DECODING_ACDC_LOST if an error was detected during DC decoding

2867 
*/

2868 
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
2869 
int n, int coded) 
2870 
{ 
2871 
int code, level, i, j, last, run;

2872 
int dc_pred_dir;

2873 
RLTable *rl; 
2874 
const UINT8 *scan_table;

2875  
2876 
if (s>mb_intra) {

2877 
/* DC coef */

2878 
if(s>data_partitioning && s>pict_type!=B_TYPE){

2879 
level = s>dc_val[0][ s>block_index[n] ];

2880 
if(n<4) level= (level + (s>y_dc_scale>>1))/s>y_dc_scale; //FIXME optimizs 
2881 
else level= (level + (s>c_dc_scale>>1))/s>c_dc_scale; 
2882 
dc_pred_dir= (s>pred_dir_table[s>mb_x + s>mb_y*s>mb_width]<<n)&32;

2883 
}else{

2884 
level = mpeg4_decode_dc(s, n, &dc_pred_dir); 
2885 
if (level < 0) 
2886 
return DECODING_ACDC_LOST;

2887 
} 
2888 
block[0] = level;

2889 
i = 1;

2890 
if (!coded)

2891 
goto not_coded;

2892 
rl = &rl_intra; 
2893 
if (s>ac_pred) {

2894 
if (dc_pred_dir == 0) 
2895 
scan_table = ff_alternate_vertical_scan; /* left */

2896 
else

2897 
scan_table = ff_alternate_horizontal_scan; /* top */

2898 
} else {

2899 
scan_table = zigzag_direct; 
2900 
} 
2901 
} else {

2902 
i = 0;

2903 
if (!coded) {

2904 
s>block_last_index[n] = i  1;

2905 
return 0; 
2906 
} 
2907 
rl = &rl_inter; 
2908 
scan_table = zigzag_direct; 
2909 
} 
2910  
2911 
for(;;) {

2912 
code = get_vlc(&s>gb, &rl>vlc); 
2913 
if (code < 0) 
2914 
return DECODING_AC_LOST;

2915 
if (code == rl>n) {

2916 
/* escape */

2917 
if (get_bits1(&s>gb) != 0) { 
2918 
if (get_bits1(&s>gb) != 0) { 
2919 
/* third escape */

2920 
last = get_bits1(&s>gb); 
2921 
run = get_bits(&s>gb, 6);

2922 
if(get_bits1(&s>gb)==0){ 
2923 
fprintf(stderr, "1. marker bit missing in 3. esc\n");

2924 
return DECODING_AC_LOST;

2925 
} 
2926 
level = get_bits(&s>gb, 12);

2927 
level = (level << 20) >> 20; /* sign extend */ 
2928 
if(get_bits1(&s>gb)==0){ 
2929 
fprintf(stderr, "2. marker bit missing in 3. esc\n");

2930 
return DECODING_AC_LOST;

2931 
} 
2932 
if(level>512  level<512){ //FIXME check that QP=1 is ok with this too 
2933 
fprintf(stderr, "level overflow in 3. esc\n");

2934 
return DECODING_AC_LOST;

2935 
} 
2936 
#if 1 
2937 
{ 
2938 
const int abs_level= ABS(level); 
2939 
if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s>error_resilience>=0){ 
2940 
const int run1= run  rl>max_run[last][abs_level]  1; 
2941 
if(abs_level <= rl>max_level[last][run]){

2942 
fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");

2943 
return DECODING_AC_LOST;

2944 
} 
2945 
if(abs_level <= rl>max_level[last][run]*2){ 
2946 
fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");

2947 
return DECODING_AC_LOST;

2948 
} 
2949 
if(run1 >= 0 && abs_level <= rl>max_level[last][run1]){ 
2950 
fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");

2951 
return DECODING_AC_LOST;

2952 
} 
2953 
} 
2954 
} 
2955 
#endif

2956 
} else {

2957 
/* second escape */

2958 
code = get_vlc(&s>gb, &rl>vlc); 
2959 
if (code < 0  code >= rl>n) 
2960 
return DECODING_AC_LOST;

2961 
run = rl>table_run[code]; 
2962 
level = rl>table_level[code]; 
2963 
last = code >= rl>last; 
2964 
run += rl>max_run[last][level] + 1;

2965 
if (get_bits1(&s>gb))

2966 
level = level; 
2967 
} 
2968 
} else {

2969 
/* first escape */

2970 
code = get_vlc(&s>gb, &rl>vlc); 
2971 
if (code < 0  code >= rl>n) 
2972 
return DECODING_AC_LOST;

2973 
run = rl>table_run[code]; 
2974 
level = rl>table_level[code]; 
2975 
last = code >= rl>last; 
2976 
level += rl>max_level[last][run]; 
2977 
if (get_bits1(&s>gb))

2978 
level = level; 
2979 
} 
2980 
} else {

2981 
run = rl>table_run[code]; 
2982 
level = rl>table_level[code]; 
2983 
last = code >= rl>last; 
2984 
if (get_bits1(&s>gb))

2985 
level = level; 
2986 
} 
2987 
i += run; 
2988 
if (i >= 64) 
2989 
return DECODING_AC_LOST;

2990 
j = scan_table[i]; 
2991 
block[j] = level; 
2992 
i++; 
2993 
if (last)

2994 
break;

2995 
} 
2996 
not_coded:

2997 
if (s>mb_intra) {

2998 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
2999 
if (s>ac_pred) {

3000 
i = 64; /* XXX: not optimal */ 
3001 
} 
3002 
} 
3003 
s>block_last_index[n] = i  1;

3004 
return 0; 
3005 
} 
3006  
3007 
/* most is hardcoded. should extend to handle all h263 streams */

3008 
int h263_decode_picture_header(MpegEncContext *s)

3009 
{ 
3010 
int format, width, height;

3011  
3012 
/* picture start code */

3013 
if (get_bits(&s>gb, 22) != 0x20) { 
3014 
fprintf(stderr, "Bad picture start code\n");

3015 
return 1; 
3016 
} 
3017 
/* temporal reference */

3018 
s>picture_number = get_bits(&s>gb, 8); /* picture timestamp */ 
3019  
3020 
/* PTYPE starts here */

3021 
if (get_bits1(&s>gb) != 1) { 
3022 
/* marker */

3023 
fprintf(stderr, "Bad marker\n");

3024 
return 1; 
3025 
} 
3026 
if (get_bits1(&s>gb) != 0) { 
3027 
fprintf(stderr, "Bad H263 id\n");

3028 
return 1; /* h263 id */ 
3029 
} 
3030 
skip_bits1(&s>gb); /* split screen off */

3031 
skip_bits1(&s>gb); /* camera off */

3032 
skip_bits1(&s>gb); /* freeze picture release off */

3033  
3034 
/* Reset GOB number */

3035 
s>gob_number = 0;

3036 

3037 
format = get_bits(&s>gb, 3);

3038 
/*

3039 
0 forbidden

3040 
1 subQCIF

3041 
10 QCIF

3042 
7 extended PTYPE (PLUSPTYPE)

3043 
*/

3044  
3045 
if (format != 7 && format != 6) { 
3046 
s>h263_plus = 0;

3047 
/* H.263v1 */

3048 
width = h263_format[format][0];

3049 
height = h263_format[format][1];

3050 
if (!width)

3051 
return 1; 
3052 

3053 
s>width = width; 
3054 
s>height = height; 
3055 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
3056  
3057 
s>unrestricted_mv = get_bits1(&s>gb); 
3058 
s>h263_long_vectors = s>unrestricted_mv; 
3059  
3060 
if (get_bits1(&s>gb) != 0) { 
3061 
fprintf(stderr, "H263 SAC not supported\n");

3062 
return 1; /* SAC: off */ 
3063 
} 
3064 
if (get_bits1(&s>gb) != 0) { 
3065 
s>mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

3066 
} 
3067 

3068 
if (get_bits1(&s>gb) != 0) { 
3069 
fprintf(stderr, "H263 PB frame not supported\n");

3070 
return 1; /* not PB frame */ 
3071 
} 
3072 
s>qscale = get_bits(&s>gb, 5);

3073 
skip_bits1(&s>gb); /* Continuous Presence Multipoint mode: off */

3074 
} else {

3075 
int ufep;

3076 

3077 
/* H.263v2 */

3078 
s>h263_plus = 1;

3079 
ufep = get_bits(&s>gb, 3); /* Update Full Extended PTYPE */ 
3080  
3081 
/* ufep other than 0 and 1 are reserved */

3082 
if (ufep == 1) { 
3083 
/* OPPTYPE */

3084 
format = get_bits(&s>gb, 3);

3085 
dprintf("ufep=1, format: %d\n", format);

3086 
skip_bits(&s>gb,1); /* Custom PCF */ 
3087 
s>umvplus_dec = get_bits(&s>gb, 1); /* Unrestricted Motion Vector */ 
3088 
skip_bits1(&s>gb); /* Syntaxbased Arithmetic Coding (SAC) */

3089 
if (get_bits1(&s>gb) != 0) { 
3090 
s>mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

3091 
} 
3092 
if (get_bits1(&s>gb) != 0) { /* Advanced Intra Coding (AIC) */ 
3093 
s>h263_aic = 1;

3094 
} 
3095 

3096 
skip_bits(&s>gb, 7);

3097 
/* these are the 7 bits: (in order of appearence */

3098 
/* Deblocking Filter */

3099 
/* Slice Structured */

3100 
/* Reference Picture Selection */

3101 
/* Independent Segment Decoding */

3102 
/* Alternative Inter VLC */

3103 
/* Modified Quantization */

3104 
/* Prevent start code emulation */

3105  
3106 
skip_bits(&s>gb, 3); /* Reserved */ 
3107 
} else if (ufep != 0) { 
3108 
fprintf(stderr, "Bad UFEP type (%d)\n", ufep);

3109 
return 1; 
3110 
} 
3111 

3112 
/* MPPTYPE */

3113 
s>pict_type = get_bits(&s>gb, 3) + I_TYPE;

3114 
dprintf("pict_type: %d\n", s>pict_type);

3115 
if (s>pict_type != I_TYPE &&

3116 
s>pict_type != P_TYPE) 
3117 
return 1; 
3118 
skip_bits(&s>gb, 2);

3119 
s>no_rounding = get_bits1(&s>gb); 
3120 
dprintf("RTYPE: %d\n", s>no_rounding);

3121 
skip_bits(&s>gb, 4);

3122 

3123 
/* Get the picture dimensions */

3124 
if (ufep) {

3125 
if (format == 6) { 
3126 
/* Custom Picture Format (CPFMT) */

3127 
s>aspect_ratio_info = get_bits(&s>gb, 4);

3128 
dprintf("aspect: %d\n", s>aspect_ratio_info);

3129 
/* aspect ratios:

3130 
0  forbidden

3131 
1  1:1

3132 
2  12:11 (CIF 4:3)

3133 
3  10:11 (525type 4:3)

3134 
4  16:11 (CIF 16:9)

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

3136 
614  reserved

3137 
*/

3138 
width = (get_bits(&s>gb, 9) + 1) * 4; 
3139 
skip_bits1(&s>gb); 
3140 
height = get_bits(&s>gb, 9) * 4; 
3141 
dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);

3142 
if (s>aspect_ratio_info == EXTENDED_PAR) {

3143 
/* aspected dimensions */

3144 
skip_bits(&s>gb, 8); /* width */ 
3145 
skip_bits(&s>gb, 8); /* height */ 
3146 
} 
3147 
} else {

3148 
width = h263_format[format][0];

3149 
height = h263_format[format][1];

3150 
} 
3151 
if ((width == 0)  (height == 0)) 
3152 
return 1; 
3153 
s>width = width; 
3154 
s>height = height; 
3155 
if (s>umvplus_dec) {

3156 
skip_bits1(&s>gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

3157 
} 
3158 
} 
3159 

3160 
s>qscale = get_bits(&s>gb, 5);

3161 
} 
3162 
/* PEI */

3163 
while (get_bits1(&s>gb) != 0) { 
3164 
skip_bits(&s>gb, 8);

3165 
} 
3166 
s>f_code = 1;

3167 

3168 
if(s>h263_aic){

3169 
s>y_dc_scale_table= 
3170 
s>c_dc_scale_table= h263_aic_dc_scale_table; 
3171 
}else{

3172 
s>y_dc_scale_table= 
3173 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
3174 
} 
3175  
3176 
return 0; 
3177 
} 
3178  
3179 
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) 
3180 
{ 
3181 
int i;

3182 
int a= 2<<s>sprite_warping_accuracy; 
3183 
int rho= 3s>sprite_warping_accuracy; 
3184 
int r=16/a; 
3185 
const int vop_ref[4][2]= {{0,0}, {s>width,0}, {0, s>height}, {s>width, s>height}}; // only true for rectangle shapes 
3186 
int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; 
3187 
int sprite_ref[4][2]; 
3188 
int virtual_ref[2][2]; 
3189 
int w2, h2;

3190 
int alpha=0, beta=0; 
3191 
int w= s>width;

3192 
int h= s>height;

3193 
//printf("SP %d\n", s>sprite_warping_accuracy);

3194 
for(i=0; i<s>num_sprite_warping_points; i++){ 
3195 
int length;

3196 
int x=0, y=0; 
3197  
3198 
length= get_vlc(&s>gb, &sprite_trajectory); 
3199 
if(length){

3200 
x= get_bits(&s>gb, length); 
3201 
//printf("lx %d %d\n", length, x);

3202 
if ((x >> (length  1)) == 0) /* if MSB not set it is negative*/ 
3203 
x =  (x ^ ((1 << length)  1)); 
3204 
} 
3205 
if(!(s>divx_version==500 && s>divx_build==413)) skip_bits1(&s>gb); /* marker bit */ 
3206 

3207 
length= get_vlc(&s>gb, &sprite_trajectory); 
3208 
if(length){

3209 
y=get_bits(&s>gb, length); 
3210 
//printf("ly %d %d\n", length, y);

3211 
if ((y >> (length  1)) == 0) /* if MSB not set it is negative*/ 
3212 
y =  (y ^ ((1 << length)  1)); 
3213 
} 
3214 
skip_bits1(&s>gb); /* marker bit */

3215 
//printf("%d %d %d %d\n", x, y, i, s>sprite_warping_accuracy);

3216 
//if(i>0 && (x!=0  y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");

3217 
//x=y=0;

3218 
d[i][0]= x;

3219 
d[i][1]= y;

3220 
} 
3221  
3222 
while((1<<alpha)<w) alpha++; 
3223 
while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' 
3224 
w2= 1<<alpha;

3225 
h2= 1<<beta;

3226  
3227 
// Note, the 4th point isnt used for GMC

3228 
if(s>divx_version==500 && s>divx_build==413){ 
3229 
sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; 
3230 
sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; 
3231 
sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; 
3232 
sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; 
3233 
sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; 
3234 
sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; 
3235 
} else {

3236 
sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); 
3237 
sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); 
3238 
sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); 
3239 
sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); 
3240 
sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); 
3241 
sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); 
3242 
} 
3243 
/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

3244 
sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */

3245 

3246 
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)

3247 
// perhaps it should be reordered to be more readable ...

3248 
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides

3249 
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form

3250 
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
3251 
+ ROUNDED_DIV(((w  w2)*(r*sprite_ref[0][0]  16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0]  16*vop_ref[1][0])),w); 
3252 
virtual_ref[0][1]= 16*vop_ref[0][1] 
3253 
+ ROUNDED_DIV(((w  w2)*(r*sprite_ref[0][1]  16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1]  16*vop_ref[1][1])),w); 
3254 
virtual_ref[1][0]= 16*vop_ref[0][0] 
3255 
+ ROUNDED_DIV(((h  h2)*(r*sprite_ref[0][0]  16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0]  16*vop_ref[2][0])),h); 
3256 
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
3257 
+ ROUNDED_DIV(((h  h2)*(r*sprite_ref[0][1]  16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1]  16*vop_ref[2][1])),h); 
3258  
3259 
switch(s>num_sprite_warping_points)

3260 
{ 
3261 
case 0: 
3262 
s>sprite_offset[0][0]= 0; 
3263 
s>sprite_offset[0][1]= 0; 
3264 
s>sprite_offset[1][0]= 0; 
3265 
s>sprite_offset[1][1]= 0; 
3266 
s>sprite_delta[0][0][0]= a; 
3267 
s>sprite_delta[0][0][1]= 0; 
3268 
s>sprite_delta[0][1][0]= 0; 
3269 
s>sprite_delta[0][1][1]= a; 
3270 
s>sprite_delta[1][0][0]= a; 
3271 
s>sprite_delta[1][0][1]= 0; 
3272 
s>sprite_delta[1][1][0]= 0; 
3273 
s>sprite_delta[1][1][1]= a; 
3274 
s>sprite_shift[0][0]= 0; 
3275 
s>sprite_shift[0][1]= 0; 
3276 
s>sprite_shift[1][0]= 0; 
3277 
s>sprite_shift[1][1]= 0; 
3278 
break;

3279 
case 1: //GMC only 
3280 
s>sprite_offset[0][0]= sprite_ref[0][0]  a*vop_ref[0][0]; 
3281 
s>sprite_offset[0][1]= sprite_ref[0][1]  a*vop_ref[0][1]; 
3282 
s>sprite_offset[1][0]= ((sprite_ref[0][0]>>1)(sprite_ref[0][0]&1))  a*(vop_ref[0][0]/2); 
3283 
s>sprite_offset[1][1]= ((sprite_ref[0][1]>>1)(sprite_ref[0][1]&1))  a*(vop_ref[0][1]/2); 
3284 
s>sprite_delta[0][0][0]= a; 
3285 
s>sprite_delta[0][0][1]= 0; 
3286 
s>sprite_delta[0][1][0]= 0; 
3287 
s>sprite_delta[0][1][1]= a; 
3288 
s>sprite_delta[1][0][0]= a; 
3289 
s>sprite_delta[1][0][1]= 0; 
3290 
s>sprite_delta[1][1][0]= 0; 
3291 
s>sprite_delta[1][1][1]= a; 
3292 
s>sprite_shift[0][0]= 0; 
3293 
s>sprite_shift[0][1]= 0; 
3294 
s>sprite_shift[1][0]= 0; 
3295 
s>sprite_shift[1][1]= 0; 
3296 
break;

3297 
case 2: 
3298 
case 3: //FIXME 
3299 
s>sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) 
3300 
+ ((r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][0]) 
3301 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(vop_ref[0][1])); 
3302 
s>sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) 
3303 
+ ((r*sprite_ref[0][1] + virtual_ref[0][1])*(vop_ref[0][0]) 
3304 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][1])); 
3305 
s>sprite_offset[1][0]= ((r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][0] + 1) 
3306 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(2*vop_ref[0][1] + 1) 
3307 
+2*w2*r*sprite_ref[0][0]  16*w2); 
3308 
s>sprite_offset[1][1]= ((r*sprite_ref[0][1] + virtual_ref[0][1])*(2*vop_ref[0][0] + 1) 
3309 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][1] + 1) 
3310 
+2*w2*r*sprite_ref[0][1]  16*w2); 
3311 
s>sprite_delta[0][0][0]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
3312 
s>sprite_delta[0][0][1]= ( r*sprite_ref[0][1]  virtual_ref[0][1]); 
3313 
s>sprite_delta[0][1][0]= (r*sprite_ref[0][1] + virtual_ref[0][1]); 
3314 
s>sprite_delta[0][1][1]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
3315 
s>sprite_delta[1][0][0]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
3316 
s>sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1]  virtual_ref[0][1]); 
3317 
s>sprite_delta[1][1][0]= 4*(r*sprite_ref[0][1] + virtual_ref[0][1]); 
3318 
s>sprite_delta[1][1][1]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
3319 
s>sprite_shift[0][0]= alpha+rho; 
3320 
s>sprite_shift[0][1]= alpha+rho; 
3321 
s>sprite_shift[1][0]= alpha+rho+2; 
3322 
s>sprite_shift[1][1]= alpha+rho+2; 
3323 
break;

3324 
// case 3:

3325 
break;

3326 
} 
3327 
/*printf("%d %d\n", s>sprite_delta[0][0][0], a<<s>sprite_shift[0][0]);

3328 
printf("%d %d\n", s>sprite_delta[0][0][1], 0);

3329 
printf("%d %d\n", s>sprite_delta[0][1][0], 0);

3330 
printf("%d %d\n", s>sprite_delta[0][1][1], a<<s>sprite_shift[0][1]);

3331 
printf("%d %d\n", s>sprite_delta[1][0][0], a<<s>sprite_shift[1][0]);

3332 
printf("%d %d\n", s>sprite_delta[1][0][1], 0);

3333 
printf("%d %d\n", s>sprite_delta[1][1][0], 0);

3334 
printf("%d %d\n", s>sprite_delta[1][1][1], a<<s>sprite_shift[1][1]);*/

3335 
/* try to simplify the situation */

3336 
if( s>sprite_delta[0][0][0] == a<<s>sprite_shift[0][0] 
3337 
&& s>sprite_delta[0][0][1] == 0 
3338 
&& s>sprite_delta[0][1][0] == 0 
3339 
&& s>sprite_delta[0][1][1] == a<<s>sprite_shift[0][1] 
3340 
&& s>sprite_delta[1][0][0] == a<<s>sprite_shift[1][0] 
3341 
&& s>sprite_delta[1][0][1] == 0 
3342 
&& s>sprite_delta[1][1][0] == 0 
3343 
&& s>sprite_delta[1][1][1] == a<<s>sprite_shift[1][1]) 
3344 
{ 
3345 
s>sprite_offset[0][0]>>=s>sprite_shift[0][0]; 
3346 
s>sprite_offset[0][1]>>=s>sprite_shift[0][1]; 
3347 
s>sprite_offset[1][0]>>=s>sprite_shift[1][0]; 
3348 
s>sprite_offset[1][1]>>=s>sprite_shift[1][1]; 
3349 
s>sprite_delta[0][0][0]= a; 
3350 
s>sprite_delta[0][0][1]= 0; 
3351 
s>sprite_delta[0][1][0]= 0; 
3352 
s>sprite_delta[0][1][1]= a; 
3353 
s>sprite_delta[1][0][0]= a; 
3354 
s>sprite_delta[1][0][1]= 0; 
3355 
s>sprite_delta[1][1][0]= 0; 
3356 
s>sprite_delta[1][1][1]= a; 
3357 
s>sprite_shift[0][0]= 0; 
3358 
s>sprite_shift[0][1]= 0; 
3359 
s>sprite_shift[1][0]= 0; 
3360 
s>sprite_shift[1][1]= 0; 
3361 
s>real_sprite_warping_points=1;

3362 
} 
3363 
else

3364 
s>real_sprite_warping_points= s>num_sprite_warping_points; 
3365  
3366 
//printf("%d %d %d %d\n", d[0][0], d[0][1], s>sprite_offset[0][0], s>sprite_offset[0][1]);

3367 
} 
3368  
3369 
/* decode mpeg4 VOP header */

3370 
int mpeg4_decode_picture_header(MpegEncContext * s)

3371 
{ 
3372 
int time_incr, startcode, state, v;

3373 
int time_increment;

3374  
3375 
redo:

3376 
/* search next start code */

3377 
align_get_bits(&s>gb); 
3378 
state = 0xff;

3379 
for(;;) {

3380 
v = get_bits(&s>gb, 8);

3381 
if (state == 0x000001) { 
3382 
state = ((state << 8)  v) & 0xffffff; 
3383 
startcode = state; 
3384 
break;

3385 
} 
3386 
state = ((state << 8)  v) & 0xffffff; 
3387 
if( get_bits_count(&s>gb) > s>gb.size*832){ 
3388 
if(s>gb.size>50){ 
3389 
printf("no VOP startcode found, frame size was=%d\n", s>gb.size);

3390 
return 1; 
3391 
}else{

3392 
printf("frame skip\n");

3393 
return FRAME_SKIPED;

3394 
} 
3395 
} 
3396 
} 
3397 
//printf("startcode %X %d\n", startcode, get_bits_count(&s>gb));

3398 
if (startcode == 0x120) { // Video Object Layer 
3399 
int width, height, vo_ver_id;

3400  
3401 
/* vol header */

3402 
skip_bits(&s>gb, 1); /* random access */ 
3403 
s>vo_type= get_bits(&s>gb, 8);

3404 
if (get_bits1(&s>gb) != 0) { /* is_ol_id */ 
3405 
vo_ver_id = get_bits(&s>gb, 4); /* vo_ver_id */ 
3406 
skip_bits(&s>gb, 3); /* vo_priority */ 
3407 
} else {

3408 
vo_ver_id = 1;

3409 
} 
3410 
//printf("vo type:%d\n",s>vo_type);

3411 
s>aspect_ratio_info= get_bits(&s>gb, 4);

3412 
if(s>aspect_ratio_info == EXTENDED_PAR){

3413 
skip_bits(&s>gb, 8); //par_width 
3414 
skip_bits(&s>gb, 8); // par_height 
3415 
} 
3416  
3417 
if ((s>vol_control_parameters=get_bits1(&s>gb))) { /* vol control parameter */ 
3418 
int chroma_format= get_bits(&s>gb, 2); 
3419 
if(chroma_format!=1){ 
3420 
printf("illegal chroma format\n");

3421 
} 
3422 
s>low_delay= get_bits1(&s>gb); 
3423 
if(get_bits1(&s>gb)){ /* vbv parameters */ 
3424 
printf("vbv parameters not supported\n");

3425 
return 1; 
3426 
} 
3427 
}else{

3428 
s>low_delay=0;

3429 
} 
3430  
3431 
s>shape = get_bits(&s>gb, 2); /* vol shape */ 
3432 
if(s>shape != RECT_SHAPE) printf("only rectangular vol supported\n"); 
3433 
if(s>shape == GRAY_SHAPE && vo_ver_id != 1){ 
3434 
printf("Gray shape not supported\n");

3435 
skip_bits(&s>gb, 4); //video_object_layer_shape_extension 
3436 
} 
3437  
3438 
skip_bits1(&s>gb); /* marker */

3439 

3440 
s>time_increment_resolution = get_bits(&s>gb, 16);

3441 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
3442 
if (s>time_increment_bits < 1) 
3443 
s>time_increment_bits = 1;

3444 
skip_bits1(&s>gb); /* marker */

3445  
3446 
if (get_bits1(&s>gb) != 0) { /* fixed_vop_rate */ 
3447 
skip_bits(&s>gb, s>time_increment_bits); 
3448 
} 
3449  
3450 
if (s>shape != BIN_ONLY_SHAPE) {

3451 
if (s>shape == RECT_SHAPE) {

3452 
skip_bits1(&s>gb); /* marker */

3453 
width = get_bits(&s>gb, 13);

3454 
skip_bits1(&s>gb); /* marker */

3455 
height = get_bits(&s>gb, 13);

3456 
skip_bits1(&s>gb); /* marker */

3457 
if(width && height){ /* they should be non zero but who knows ... */ 
3458 
s>width = width; 
3459 
s>height = height; 
3460 
// printf("width/height: %d %d\n", width, height);

3461 
} 
3462 
} 
3463 

3464 
if(get_bits1(&s>gb)) printf("interlaced not supported\n"); /* interlaced */ 
3465 
if(!get_bits1(&s>gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ 
3466 
if (vo_ver_id == 1) { 
3467 
s>vol_sprite_usage = get_bits1(&s>gb); /* vol_sprite_usage */

3468 
} else {

3469 
s>vol_sprite_usage = get_bits(&s>gb, 2); /* vol_sprite_usage */ 
3470 
} 
3471 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); 
3472 
if(s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE){

3473 
if(s>vol_sprite_usage==STATIC_SPRITE){

3474 
s>sprite_width = get_bits(&s>gb, 13);

3475 
skip_bits1(&s>gb); /* marker */

3476 
s>sprite_height= get_bits(&s>gb, 13);

3477 
skip_bits1(&s>gb); /* marker */

3478 
s>sprite_left = get_bits(&s>gb, 13);

3479 
skip_bits1(&s>gb); /* marker */

3480 
s>sprite_top = get_bits(&s>gb, 13);

3481 
skip_bits1(&s>gb); /* marker */

3482 
} 
3483 
s>num_sprite_warping_points= get_bits(&s>gb, 6);

3484 
s>sprite_warping_accuracy = get_bits(&s>gb, 2);

3485 
s>sprite_brightness_change= get_bits1(&s>gb); 
3486 
if(s>vol_sprite_usage==STATIC_SPRITE)

3487 
s>low_latency_sprite= get_bits1(&s>gb); 
3488 
} 
3489 
// FIXME sadct disable bit if verid!=1 && shape not rect

3490 

3491 
if (get_bits1(&s>gb) == 1) { /* not_8_bit */ 
3492 
s>quant_precision = get_bits(&s>gb, 4); /* quant_precision */ 
3493 
if(get_bits(&s>gb, 4)!=8) printf("Nbit not supported\n"); /* bits_per_pixel */ 
3494 
if(s>quant_precision!=5) printf("quant precission %d\n", s>quant_precision); 
3495 
} else {

3496 
s>quant_precision = 5;

3497 
} 
3498 

3499 
// FIXME a bunch of grayscale shape things

3500  
3501 
if(get_bits1(&s>gb)){ /* vol_quant_type */ 
3502 
int i, j, v;

3503 
/* load default matrixes */

3504 
for(i=0; i<64; i++){ 
3505 
v= ff_mpeg4_default_intra_matrix[i]; 
3506 
s>intra_matrix[i]= v; 
3507 
s>chroma_intra_matrix[i]= v; 
3508 

3509 
v= ff_mpeg4_default_non_intra_matrix[i]; 
3510 
s>inter_matrix[i]= v; 
3511 
s>chroma_inter_matrix[i]= v; 
3512 
} 
3513  
3514 
/* load custom intra matrix */

3515 
if(get_bits1(&s>gb)){

3516 
for(i=0; i<64; i++){ 
3517 
v= get_bits(&s>gb, 8);

3518 
if(v==0) break; 
3519  
3520 
j= zigzag_direct[i]; 
3521 
s>intra_matrix[j]= v; 
3522 
s>chroma_intra_matrix[j]= v; 
3523 
} 
3524 
} 
3525  
3526 
/* load custom non intra matrix */

3527 
if(get_bits1(&s>gb)){

3528 
for(i=0; i<64; i++){ 
3529 
v= get_bits(&s>gb, 8);

3530 
if(v==0) break; 
3531  
3532 
j= zigzag_direct[i]; 
3533 
s>inter_matrix[j]= v; 
3534 
s>chroma_inter_matrix[j]= v; 
3535 
} 
3536  
3537 
/* replicate last value */

3538 
for(; i<64; i++){ 
3539 
j= zigzag_direct[i]; 
3540 
s>inter_matrix[j]= v; 
3541 
s>chroma_inter_matrix[j]= v; 
3542 
} 
3543 
} 
3544  
3545 
s>dct_unquantize= s>dct_unquantize_mpeg2; 
3546  
3547 
// FIXME a bunch of grayscale shape things

3548 
}else

3549 
s>dct_unquantize= s>dct_unquantize_h263; 
3550  
3551 
if(vo_ver_id != 1) 
3552 
s>quarter_sample= get_bits1(&s>gb); 
3553 
else s>quarter_sample=0; 
3554  
3555 
if(!get_bits1(&s>gb)) printf("Complexity estimation not supported\n"); 
3556  
3557 
s>resync_marker= !get_bits1(&s>gb); /* resync_marker_disabled */

3558  
3559 
s>data_partitioning= get_bits1(&s>gb); 
3560 
if(s>data_partitioning){

3561 
s>rvlc= get_bits1(&s>gb); 
3562 
if(s>rvlc){

3563 
printf("reversible vlc not supported\n");

3564 
} 
3565 
} 
3566 

3567 
if(vo_ver_id != 1) { 
3568 
s>new_pred= get_bits1(&s>gb); 
3569 
if(s>new_pred){

3570 
printf("new pred not supported\n");

3571 
skip_bits(&s>gb, 2); /* requested upstream message type */ 
3572 
skip_bits1(&s>gb); /* newpred segment type */

3573 
} 
3574 
s>reduced_res_vop= get_bits1(&s>gb); 
3575 
if(s>reduced_res_vop) printf("reduced resolution VOP not supported\n"); 
3576 
} 
3577 
else{

3578 
s>new_pred=0;

3579 
s>reduced_res_vop= 0;

3580 
} 
3581  
3582 
s>scalability= get_bits1(&s>gb); 
3583 
if (s>scalability) {

3584 
printf("scalability not supported\n");

3585 
} 
3586 
} 
3587 
//printf("end Data %X %d\n", show_bits(&s>gb, 32), get_bits_count(&s>gb)&0x7);

3588 
goto redo;

3589 
} else if (startcode == 0x1b2) { //userdata 
3590 
char buf[256]; 
3591 
int i;

3592 
int e;

3593 
int ver, build;

3594  
3595 
//printf("user Data %X\n", show_bits(&s>gb, 32));

3596 
buf[0]= show_bits(&s>gb, 8); 
3597 
for(i=1; i<256; i++){ 
3598 
buf[i]= show_bits(&s>gb, 16)&0xFF; 
3599 
if(buf[i]==0) break; 
3600 
skip_bits(&s>gb, 8);

3601 
} 
3602 
buf[255]=0; 
3603 
e=sscanf(buf, "DivX%dBuild%d", &ver, &build);

3604 
if(e!=2) 
3605 
e=sscanf(buf, "DivX%db%d", &ver, &build);

3606 
if(e==2){ 
3607 
s>divx_version= ver; 
3608 
s>divx_build= build; 
3609 
if(s>picture_number==0){ 
3610 
printf("This file was encoded with DivX%d Build%d\n", ver, build);

3611 
if(ver==500 && build==413){ 
3612 
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");

3613 
#if 0

3614 
}else{

3615 
printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"

3616 
"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");

3617 
#endif

3618 
} 
3619 
} 
3620 
} 
3621 
//printf("User Data: %s\n", buf);

3622 
goto redo;

3623 
} else if (startcode != 0x1b6) { //VOP 
3624 
goto redo;

3625 
} 
3626  
3627 
s>pict_type = get_bits(&s>gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ 
3628 
//if(s>pict_type!=I_TYPE) return FRAME_SKIPED;

3629 
if(s>pict_type==B_TYPE && s>low_delay && s>vol_control_parameters==0){ 
3630 
printf("low_delay flag set, but shouldnt, clearing it\n");

3631 
s>low_delay=0;

3632 
} 
3633 
// printf("pic: %d, qpel:%d\n", s>pict_type, s>quarter_sample);

3634 
//printf("%d", s>pict_type);

3635 
time_incr=0;

3636 
while (get_bits1(&s>gb) != 0) 
3637 
time_incr++; 
3638  
3639 
check_marker(&s>gb, "before time_increment");

3640 
time_increment= get_bits(&s>gb, s>time_increment_bits); 
3641 
//printf(" type:%d incr:%d increment:%d\n", s>pict_type, time_incr, time_increment);

3642 
if(s>pict_type!=B_TYPE){

3643 
s>last_time_base= s>time_base; 
3644 
s>time_base+= time_incr; 
3645 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
3646 
s>pp_time= s>time  s>last_non_b_time; 
3647 
s>last_non_b_time= s>time; 
3648 
}else{

3649 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
3650 
s>bp_time= s>last_non_b_time  s>time; 
3651 
if(s>pp_time <=s>bp_time){

3652 
// printf("messed up order, seeking?, skiping current b frame\n");

3653 
return FRAME_SKIPED;

3654 
} 
3655 
} 
3656  
3657 
if(check_marker(&s>gb, "before vop_coded")==0 && s>picture_number==0){ 
3658 
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");

3659 
for(s>time_increment_bits++ ;s>time_increment_bits<16; s>time_increment_bits++){ 
3660 
if(get_bits1(&s>gb)) break; 
3661 
} 
3662 
printf("my guess is %d bits ;)\n",s>time_increment_bits);

3663 
} 
3664 
/* vop coded */

3665 
if (get_bits1(&s>gb) != 1) 
3666 
goto redo;

3667 
//printf("time %d %d %d  %d %d %d\n", s>time_increment_bits, s>time_increment, s>time_base,

3668 
//s>time, s>last_non_b_time[0], s>last_non_b_time[1]);

3669 
if (s>shape != BIN_ONLY_SHAPE && ( s>pict_type == P_TYPE

3670 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE))) { 
3671 
/* rounding type for motion estimation */

3672 
s>no_rounding = get_bits1(&s>gb); 
3673 
} else {

3674 
s>no_rounding = 0;

3675 
} 
3676 
//FIXME reduced res stuff

3677  
3678 
if (s>shape != RECT_SHAPE) {

3679 
if (s>vol_sprite_usage != 1  s>pict_type != I_TYPE) { 
3680 
int width, height, hor_spat_ref, ver_spat_ref;

3681 

3682 
width = get_bits(&s>gb, 13);

3683 
skip_bits1(&s>gb); /* marker */

3684 
height = get_bits(&s>gb, 13);

3685 
skip_bits1(&s>gb); /* marker */

3686 
hor_spat_ref = get_bits(&s>gb, 13); /* hor_spat_ref */ 
3687 
skip_bits1(&s>gb); /* marker */

3688 
ver_spat_ref = get_bits(&s>gb, 13); /* ver_spat_ref */ 
3689 
} 
3690 
skip_bits1(&s>gb); /* change_CR_disable */

3691 

3692 
if (get_bits1(&s>gb) != 0) { 
3693 
skip_bits(&s>gb, 8); /* constant_alpha_value */ 
3694 
} 
3695 
} 
3696 
//FIXME complexity estimation stuff

3697 

3698 
if (s>shape != BIN_ONLY_SHAPE) {

3699 
int t;

3700 
t=get_bits(&s>gb, 3); /* intra dc VLC threshold */ 
3701 
//printf("threshold %d\n", t);

3702 
//FIXME interlaced specific bits

3703 
} 
3704  
3705 
if(s>pict_type == S_TYPE && (s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE)){

3706 
if(s>num_sprite_warping_points){

3707 
mpeg4_decode_sprite_trajectory(s); 
3708 
} 
3709 
if(s>sprite_brightness_change) printf("sprite_brightness_change not supported\n"); 
3710 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); 
3711 
} 
3712  
3713 
if (s>shape != BIN_ONLY_SHAPE) {

3714 
/* note: we do not use quant_precision to avoid problem if no

3715 
MPEG4 vol header as it is found on some old opendivx

3716 
movies */

3717 
s>qscale = get_bits(&s>gb, 5);

3718 
if(s>qscale==0){ 
3719 
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");

3720 
return 1; // makes no sense to continue, as there is nothing left from the image then 
3721 
} 
3722 

3723 
if (s>pict_type != I_TYPE) {

3724 
s>f_code = get_bits(&s>gb, 3); /* fcode_for */ 
3725 
if(s>f_code==0){ 
3726 
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");

3727 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
3728 
} 
3729 
} 
3730 
if (s>pict_type == B_TYPE) {

3731 
s>b_code = get_bits(&s>gb, 3);

3732 
//printf("bcode %d\n", s>b_code);

3733 
} 
3734 
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s>qscale, s>f_code, s>b_code, s>pict_type);

3735 
if(!s>scalability){

3736 
if (s>shape!=RECT_SHAPE && s>pict_type!=I_TYPE) {

3737 
skip_bits1(&s>gb); // vop shape coding type

3738 
} 
3739 
} 
3740 
} 
3741 
/* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/

3742 
// note we cannot detect divx5 without bframes easyly (allthough its buggy too)

3743 
if(s>vo_type==0 && s>vol_control_parameters==0 && s>divx_version==0 && s>picture_number==0){ 
3744 
printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) > forcing low_delay flag\n");

3745 
s>low_delay=1;

3746 
} 
3747  
3748 
s>picture_number++; // better than pic number==0 allways ;)

3749 
//printf("done\n");

3750  
3751 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support

3752 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
3753  
3754 
return 0; 
3755 
} 
3756  
3757 
/* don't understand why they choose a different header ! */

3758 
int intel_h263_decode_picture_header(MpegEncContext *s)

3759 
{ 
3760 
int format;

3761  
3762 
/* picture header */

3763 
if (get_bits(&s>gb, 22) != 0x20) { 
3764 
fprintf(stderr, "Bad picture start code\n");

3765 
return 1; 
3766 
} 
3767 
s>picture_number = get_bits(&s>gb, 8); /* picture timestamp */ 
3768  
3769 
if (get_bits1(&s>gb) != 1) { 
3770 
fprintf(stderr, "Bad marker\n");

3771 
return 1; /* marker */ 
3772 
} 
3773 
if (get_bits1(&s>gb) != 0) { 
3774 
fprintf(stderr, "Bad H263 id\n");

3775 
return 1; /* h263 id */ 
3776 
} 
3777 
skip_bits1(&s>gb); /* split screen off */

3778 
skip_bits1(&s>gb); /* camera off */

3779 
skip_bits1(&s>gb); /* freeze picture release off */

3780  
3781 
format = get_bits(&s>gb, 3);

3782 
if (format != 7) { 
3783 
fprintf(stderr, "Intel H263 free format not supported\n");

3784 
return 1; 
3785 
} 
3786 
s>h263_plus = 0;

3787  
3788 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
3789 

3790 
s>unrestricted_mv = get_bits1(&s>gb); 
3791 
s>h263_long_vectors = s>unrestricted_mv; 
3792  
3793 
if (get_bits1(&s>gb) != 0) { 
3794 
fprintf(stderr, "SAC not supported\n");

3795 
return 1; /* SAC: off */ 
3796 
} 
3797 
if (get_bits1(&s>gb) != 0) { 
3798 
fprintf(stderr, "Advanced Prediction Mode not supported\n");

3799 
return 1; /* advanced prediction mode: off */ 
3800 
} 
3801 
if (get_bits1(&s>gb) != 0) { 
3802 
fprintf(stderr, "PB frame mode no supported\n");

3803 
return 1; /* PB frame mode */ 
3804 
} 
3805  
3806 
/* skip unknown header garbage */

3807 
skip_bits(&s>gb, 41);

3808  
3809 
s>qscale = get_bits(&s>gb, 5);

3810 
skip_bits1(&s>gb); /* Continuous Presence Multipoint mode: off */

3811  
3812 
/* PEI */

3813 
while (get_bits1(&s>gb) != 0) { 
3814 
skip_bits(&s>gb, 8);

3815 
} 
3816 
s>f_code = 1;

3817 
return 0; 
3818 
} 
3819 