ffmpeg / libavcodec / h263.c @ bb71e317
History  View  Annotate  Download (99.5 KB)
1 
/*


2 
* H263/MPEG4 backend for ffmpeg encoder and decoder

3 
* Copyright (c) 2000,2001 Gerard Lantau.

4 
* H263+ support.

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

6 
*

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

8 
* it under the terms of the GNU General Public License as published by

9 
* the Free Software Foundation; either version 2 of the License, or

10 
* (at your option) any later version.

11 
*

12 
* This program 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

15 
* GNU General Public License for more details.

16 
*

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

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

19 
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

20 
*

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

22 
*/

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

31 
#define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)((b)>>1))/(b)) 
32 
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)1)))>>(b) : ((a) + (1<<((b)1))1)>>(b)) 
33 
#define ABS(a) (((a)>=0)?(a):((a))) 
34 
#define MAX(a,b) ((a) > (b) ? (a) : (b))

35 
#define MIN(a,b) ((a) < (b) ? (a) : (b))

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

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

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

66  
67 
if (width == 128 && height == 96) 
68 
format = 1;

69 
else if (width == 176 && height == 144) 
70 
format = 2;

71 
else if (width == 352 && height == 288) 
72 
format = 3;

73 
else if (width == 704 && height == 576) 
74 
format = 4;

75 
else if (width == 1408 && height == 1152) 
76 
format = 5;

77 
else

78 
format = 7;

79 
return format;

80 
} 
81  
82 
void h263_encode_picture_header(MpegEncContext * s, int picture_number) 
83 
{ 
84 
int format;

85  
86 
align_put_bits(&s>pb); 
87  
88 
/* Update the pointer to last GOB */

89 
s>ptr_lastgob = pbBufPtr(&s>pb); 
90 
s>gob_number = 0;

91  
92 
put_bits(&s>pb, 22, 0x20); /* PSC */ 
93 
put_bits(&s>pb, 8, (((INT64)s>picture_number * 30 * FRAME_RATE_BASE) / 
94 
s>frame_rate) & 0xff);

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

102 
format = h263_get_picture_format(s>width, s>height); 
103 
if (!s>h263_plus) {

104 
/* H.263v1 */

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

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

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

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

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

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

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

117 
/* H.263v2 */

118 
/* H.263 Plus PTYPE */

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

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

125 

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

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

142 

143 
put_bits(&s>pb,1,0); /* Reference Picture Resampling: off */ 
144 
put_bits(&s>pb,1,0); /* ReducedResolution Update: off */ 
145 
put_bits(&s>pb,1,0); /* Rounding Type */ 
146 
put_bits(&s>pb,2,0); /* Reserved */ 
147 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
148 

149 
/* This should be here if PLUSPTYPE */

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

152 
if (format == 7) { 
153 
/* Custom Picture Format (CPFMT) */

154 

155 
put_bits(&s>pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */ 
156 
put_bits(&s>pb,9,(s>width >> 2)  1); 
157 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
158 
put_bits(&s>pb,9,(s>height >> 2)); 
159 
} 
160 

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

162 
if (s>umvplus)

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

165 
} 
166  
167 
put_bits(&s>pb, 1, 0); /* no PEI */ 
168 
} 
169  
170 
int h263_encode_gob_header(MpegEncContext * s, int mb_line) 
171 
{ 
172 
int pdif=0; 
173 

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

175 
/* for RTP packetization */

176 
if (s>rtp_mode) {

177 
pdif = pbBufPtr(&s>pb)  s>ptr_lastgob; 
178 
if (pdif >= s>rtp_payload_size) {

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

180 
align_put_bits(&s>pb); 
181 
flush_put_bits(&s>pb); 
182 
/* Call the RTP callback to send the last GOB */

183 
if (s>rtp_callback) {

184 
pdif = pbBufPtr(&s>pb)  s>ptr_lastgob; 
185 
s>rtp_callback(s>ptr_lastgob, pdif, s>gob_number); 
186 
} 
187 
s>ptr_lastgob = pbBufPtr(&s>pb); 
188 
put_bits(&s>pb, 17, 1); /* GBSC */ 
189 
s>gob_number = mb_line / s>gob_index; 
190 
put_bits(&s>pb, 5, s>gob_number); /* GN */ 
191 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
192 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
193 
//fprintf(stderr,"\nGOB: %2d size: %d", s>gob_number  1, pdif);

194 
return pdif;

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

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

200 
if (s>rtp_callback) {

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

211 
return pdif;

212 
} 
213 
} 
214 
return 0; 
215 
} 
216  
217 
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6]) 
218 
{ 
219 
int score0=0, score1=0; 
220 
int i, n;

221  
222 
for(n=0; n<6; n++){ 
223 
INT16 *ac_val, *ac_val1; 
224  
225 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
226 
ac_val1= ac_val; 
227 
if(dir[n]){

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

229 
for(i=1; i<8; i++){ 
230 
const int level= block[n][block_permute_op(i )]; 
231 
score0+= ABS(level); 
232 
score1+= ABS(level  ac_val[i+8]);

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

234 
ac_val1[i+8]= level;

235 
} 
236 
}else{

237 
ac_val= 16;

238 
for(i=1; i<8; i++){ 
239 
const int level= block[n][block_permute_op(i<<3)]; 
240 
score0+= ABS(level); 
241 
score1+= ABS(level  ac_val[i]); 
242 
ac_val1[i ]= level; 
243 
ac_val1[i+8]= block[n][block_permute_op(i )];

244 
} 
245 
} 
246 
} 
247  
248 
return score0 > score1 ? 1 : 0; 
249 
} 
250  
251 
void mpeg4_encode_mb(MpegEncContext * s,

252 
DCTELEM block[6][64], 
253 
int motion_x, int motion_y) 
254 
{ 
255 
int cbpc, cbpy, i, pred_x, pred_y;

256 
int bits;

257 

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

259 
if (!s>mb_intra) {

260 
/* compute cbp */

261 
int cbp = 0; 
262 
for (i = 0; i < 6; i++) { 
263 
if (s>block_last_index[i] >= 0) 
264 
cbp = 1 << (5  i); 
265 
} 
266  
267 
if(s>pict_type==B_TYPE){

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

270 

271 
if(s>mb_x==0){ 
272 
s>last_mv[0][0][0]= 
273 
s>last_mv[0][0][1]= 
274 
s>last_mv[1][0][0]= 
275 
s>last_mv[1][0][1]= 0; 
276 
} 
277  
278 
/* nothing to do if this MB was skiped in the next P Frame */

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

280 
s>skip_count++; 
281 
s>mv[0][0][0]= 
282 
s>mv[0][0][1]= 
283 
s>mv[1][0][0]= 
284 
s>mv[1][0][1]= 0; 
285 
s>mv_dir= MV_DIR_FORWARD; //doesnt matter

286 
return;

287 
} 
288  
289 
if ((cbp  motion_x  motion_y  mb_type) ==0) { 
290 
/* direct MB with MV={0,0} */

291 
put_bits(&s>pb, 1, 1); /* mb not coded modb1=1 */ 
292 
s>misc_bits++; 
293 
s>last_bits++; 
294 
s>skip_count++; 
295 
return;

296 
} 
297 
put_bits(&s>pb, 1, 0); /* mb coded modb1=0 */ 
298 
put_bits(&s>pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge 
299 
put_bits(&s>pb, mb_type+1, 1); // this table is so simple that we dont need it :) 
300 
if(cbp) put_bits(&s>pb, 6, cbp); 
301 

302 
if(cbp && mb_type)

303 
put_bits(&s>pb, 1, 0); /* no qscale change */ 
304  
305 
bits= get_bit_count(&s>pb); 
306 
s>misc_bits+= bits  s>last_bits; 
307 
s>last_bits=bits; 
308  
309 
switch(mb_type)

310 
{ 
311 
case 0: /* direct */ 
312 
h263_encode_motion(s, motion_x, 1);

313 
h263_encode_motion(s, motion_y, 1);

314 
break;

315 
case 1: /* bidir */ 
316 
h263_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
317 
h263_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
318 
h263_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
319 
h263_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
320 
s>last_mv[0][0][0]= s>mv[0][0][0]; 
321 
s>last_mv[0][0][1]= s>mv[0][0][1]; 
322 
s>last_mv[1][0][0]= s>mv[1][0][0]; 
323 
s>last_mv[1][0][1]= s>mv[1][0][1]; 
324 
break;

325 
case 2: /* backward */ 
326 
h263_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
327 
h263_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
328 
s>last_mv[1][0][0]= motion_x; 
329 
s>last_mv[1][0][1]= motion_y; 
330 
break;

331 
case 3: /* forward */ 
332 
h263_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
333 
h263_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
334 
s>last_mv[0][0][0]= motion_x; 
335 
s>last_mv[0][0][1]= motion_y; 
336 
break;

337 
default:

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

339 
return;

340 
} 
341 
bits= get_bit_count(&s>pb); 
342 
s>mv_bits+= bits  s>last_bits; 
343 
s>last_bits=bits; 
344  
345 
/* encode each block */

346 
for (i = 0; i < 6; i++) { 
347 
mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);

348 
} 
349 
bits= get_bit_count(&s>pb); 
350 
s>p_tex_bits+= bits  s>last_bits; 
351 
s>last_bits=bits; 
352 
}else{ /* s>pict_type==B_TYPE */ 
353 
if ((cbp  motion_x  motion_y) == 0 && s>mv_type==MV_TYPE_16X16) { 
354 
/* check if the B frames can skip it too, as we must skip it if we skip here

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

356 
if(s>max_b_frames>0){ 
357 
int i;

358 
const int offset= (s>mb_x + s>mb_y*s>linesize)*16; 
359 
uint8_t *p_pic= s>new_picture[0] + offset;

360 
s>mb_skiped=1;

361 
for(i=0; i<s>max_b_frames; i++){ 
362 
uint8_t *b_pic; 
363 
int diff;

364  
365 
if(s>coded_order[i+1].pict_type!=B_TYPE) break; 
366  
367 
b_pic= s>coded_order[i+1].picture[0] + offset; 
368 
diff= pix_abs16x16(p_pic, b_pic, s>linesize); 
369 
if(diff>s>qscale*70){ 
370 
s>mb_skiped=0;

371 
break;

372 
} 
373 
} 
374 
}else

375 
s>mb_skiped=1;

376  
377 
if(s>mb_skiped==1){ 
378 
/* skip macroblock */

379 
put_bits(&s>pb, 1, 1); 
380 
s>misc_bits++; 
381 
s>last_bits++; 
382 
s>skip_count++; 
383 
return;

384 
} 
385 
} 
386 
put_bits(&s>pb, 1, 0); /* mb coded */ 
387 
if(s>mv_type==MV_TYPE_16X16){

388 
cbpc = cbp & 3;

389 
put_bits(&s>pb, 
390 
inter_MCBPC_bits[cbpc], 
391 
inter_MCBPC_code[cbpc]); 
392 
cbpy = cbp >> 2;

393 
cbpy ^= 0xf;

394 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
395 

396 
bits= get_bit_count(&s>pb); 
397 
s>misc_bits+= bits  s>last_bits; 
398 
s>last_bits=bits; 
399  
400 
/* motion vectors: 16x16 mode */

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

402 

403 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
404 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
405 
}else{

406 
cbpc = (cbp & 3)+16; 
407 
put_bits(&s>pb, 
408 
inter_MCBPC_bits[cbpc], 
409 
inter_MCBPC_code[cbpc]); 
410 
cbpy = cbp >> 2;

411 
cbpy ^= 0xf;

412 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
413  
414 
bits= get_bit_count(&s>pb); 
415 
s>misc_bits+= bits  s>last_bits; 
416 
s>last_bits=bits; 
417  
418 
for(i=0; i<4; i++){ 
419 
/* motion vectors: 8x8 mode*/

420 
h263_pred_motion(s, i, &pred_x, &pred_y); 
421  
422 
h263_encode_motion(s, s>motion_val[ s>block_index[i] ][0]  pred_x, s>f_code);

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

424 
} 
425 
} 
426 
bits= get_bit_count(&s>pb); 
427 
s>mv_bits+= bits  s>last_bits; 
428 
s>last_bits=bits; 
429  
430 
/* encode each block */

431 
for (i = 0; i < 6; i++) { 
432 
mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);

433 
} 
434 
bits= get_bit_count(&s>pb); 
435 
s>p_tex_bits+= bits  s>last_bits; 
436 
s>last_bits=bits; 
437 
s>p_count++; 
438 
} 
439 
} else {

440 
int cbp;

441 
int dc_diff[6]; //dc values with the dc prediction subtracted 
442 
int dir[6]; //prediction direction 
443 
int zigzag_last_index[6]; 
444 
UINT8 *scan_table[6];

445  
446 
for(i=0; i<6; i++){ 
447 
const int level= block[i][0]; 
448 
UINT16 *dc_ptr; 
449  
450 
dc_diff[i]= level  mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); 
451 
if (i < 4) { 
452 
*dc_ptr = level * s>y_dc_scale; 
453 
} else {

454 
*dc_ptr = level * s>c_dc_scale; 
455 
} 
456 
} 
457  
458 
s>ac_pred= decide_ac_pred(s, block, dir); 
459  
460 
if(s>ac_pred){

461 
for(i=0; i<6; i++){ 
462 
UINT8 *st; 
463 
int last_index;

464  
465 
mpeg4_inv_pred_ac(s, block[i], i, dir[i]); 
466 
if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */ 
467 
else st = ff_alternate_horizontal_scan; /* top */ 
468  
469 
for(last_index=63; last_index>=0; last_index) //FIXME optimize 
470 
if(block[i][st[last_index]]) break; 
471 
zigzag_last_index[i]= s>block_last_index[i]; 
472 
s>block_last_index[i]= last_index; 
473 
scan_table[i]= st; 
474 
} 
475 
}else{

476 
for(i=0; i<6; i++) 
477 
scan_table[i]= zigzag_direct; 
478 
} 
479  
480 
/* compute cbp */

481 
cbp = 0;

482 
for (i = 0; i < 6; i++) { 
483 
if (s>block_last_index[i] >= 1) 
484 
cbp = 1 << (5  i); 
485 
} 
486  
487 
cbpc = cbp & 3;

488 
if (s>pict_type == I_TYPE) {

489 
put_bits(&s>pb, 
490 
intra_MCBPC_bits[cbpc], 
491 
intra_MCBPC_code[cbpc]); 
492 
} else {

493 
put_bits(&s>pb, 1, 0); /* mb coded */ 
494 
put_bits(&s>pb, 
495 
inter_MCBPC_bits[cbpc + 4],

496 
inter_MCBPC_code[cbpc + 4]);

497 
} 
498 
put_bits(&s>pb, 1, s>ac_pred);

499 
cbpy = cbp >> 2;

500 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
501  
502 
bits= get_bit_count(&s>pb); 
503 
s>misc_bits+= bits  s>last_bits; 
504 
s>last_bits=bits; 
505  
506 
/* encode each block */

507 
for (i = 0; i < 6; i++) { 
508 
mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]); 
509 
} 
510  
511 
bits= get_bit_count(&s>pb); 
512 
s>i_tex_bits+= bits  s>last_bits; 
513 
s>last_bits=bits; 
514 
s>i_count++; 
515  
516 
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */

517 
if(s>ac_pred){

518 
for(i=0; i<6; i++){ 
519 
int j;

520 
INT16 *ac_val; 
521  
522 
ac_val = s>ac_val[0][0] + s>block_index[i] * 16; 
523  
524 
if(dir[i]){

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

527 
}else{

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

530 
} 
531 
s>block_last_index[i]= zigzag_last_index[i]; 
532 
} 
533 
} 
534 
} 
535 
} 
536  
537 
void h263_encode_mb(MpegEncContext * s,

538 
DCTELEM block[6][64], 
539 
int motion_x, int motion_y) 
540 
{ 
541 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

542 

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

544 
if (!s>mb_intra) {

545 
/* compute cbp */

546 
cbp = 0;

547 
for (i = 0; i < 6; i++) { 
548 
if (s>block_last_index[i] >= 0) 
549 
cbp = 1 << (5  i); 
550 
} 
551 
if ((cbp  motion_x  motion_y) == 0) { 
552 
/* skip macroblock */

553 
put_bits(&s>pb, 1, 1); 
554 
return;

555 
} 
556 
put_bits(&s>pb, 1, 0); /* mb coded */ 
557 
cbpc = cbp & 3;

558 
put_bits(&s>pb, 
559 
inter_MCBPC_bits[cbpc], 
560 
inter_MCBPC_code[cbpc]); 
561 
cbpy = cbp >> 2;

562 
cbpy ^= 0xf;

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

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

567 

568 
if (!s>umvplus) {

569 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
570 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
571 
} 
572 
else {

573 
h263p_encode_umotion(s, motion_x  pred_x); 
574 
h263p_encode_umotion(s, motion_y  pred_y); 
575 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
576 
/* To prevent Start Code emulation */

577 
put_bits(&s>pb,1,1); 
578 
} 
579 
} else {

580 
/* compute cbp */

581 
cbp = 0;

582 
for (i = 0; i < 6; i++) { 
583 
if (s>block_last_index[i] >= 1) 
584 
cbp = 1 << (5  i); 
585 
} 
586  
587 
cbpc = cbp & 3;

588 
if (s>pict_type == I_TYPE) {

589 
put_bits(&s>pb, 
590 
intra_MCBPC_bits[cbpc], 
591 
intra_MCBPC_code[cbpc]); 
592 
} else {

593 
put_bits(&s>pb, 1, 0); /* mb coded */ 
594 
put_bits(&s>pb, 
595 
inter_MCBPC_bits[cbpc + 4],

596 
inter_MCBPC_code[cbpc + 4]);

597 
} 
598 
if (s>h263_pred) {

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

600 
put_bits(&s>pb, 1, 0); /* no ac prediction */ 
601 
} 
602 
cbpy = cbp >> 2;

603 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
604 
} 
605  
606 
/* encode each block */

607 
for (i = 0; i < 6; i++) { 
608 
h263_encode_block(s, block[i], i); 
609 
} 
610 
} 
611  
612 
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n) 
613 
{ 
614 
int x, y, wrap, a, c, pred_dc, scale, i;

615 
INT16 *dc_val, *ac_val, *ac_val1; 
616  
617 
/* find prediction */

618 
if (n < 4) { 
619 
x = 2 * s>mb_x + 1 + (n & 1); 
620 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
621 
wrap = s>mb_width * 2 + 2; 
622 
dc_val = s>dc_val[0];

623 
ac_val = s>ac_val[0][0]; 
624 
scale = s>y_dc_scale; 
625 
} else {

626 
x = s>mb_x + 1;

627 
y = s>mb_y + 1;

628 
wrap = s>mb_width + 2;

629 
dc_val = s>dc_val[n  4 + 1]; 
630 
ac_val = s>ac_val[n  4 + 1][0]; 
631 
scale = s>c_dc_scale; 
632 
} 
633 

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

635 
ac_val1 = ac_val; 
636 

637 
/* B C

638 
* A X

639 
*/

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

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

642 

643 
pred_dc = 1024;

644 
if (s>ac_pred) {

645 
if (s>h263_aic_dir) {

646 
/* left prediction */

647 
if (a != 1024) { 
648 
ac_val = 16;

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

651 
} 
652 
pred_dc = a; 
653 
} 
654 
} else {

655 
/* top prediction */

656 
if (c != 1024) { 
657 
ac_val = 16 * wrap;

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

660 
} 
661 
pred_dc = c; 
662 
} 
663 
} 
664 
} else {

665 
/* just DC prediction */

666 
if (a != 1024 && c != 1024) 
667 
pred_dc = (a + c) >> 1;

668 
else if (a != 1024) 
669 
pred_dc = a; 
670 
else

671 
pred_dc = c; 
672 
} 
673 

674 
/* we assume pred is positive */

675 
block[0]=block[0]*scale + pred_dc; 
676 

677 
if (block[0] < 0) 
678 
block[0] = 0; 
679 
else if (!(block[0] & 1)) 
680 
block[0]++;

681 

682 
/* Update AC/DC tables */

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

684 

685 
/* left copy */

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

688 
/* top copy */

689 
for(i=1;i<8;i++) 
690 
ac_val1[8 + i] = block[block_permute_op(i)];

691 
} 
692  
693 
INT16 *h263_pred_motion(MpegEncContext * s, int block,

694 
int *px, int *py) 
695 
{ 
696 
int xy, wrap;

697 
INT16 *A, *B, *C, *mot_val; 
698 
static const int off[4]= {2, 1, 1, 1}; 
699  
700 
wrap = s>block_wrap[0];

701 
xy = s>block_index[block]; 
702  
703 
mot_val = s>motion_val[xy]; 
704  
705 
/* special case for first line */

706 
if ((s>mb_y == 0  s>first_slice_line  s>first_gob_line) && block<2) { 
707 
A = s>motion_val[xy  1];

708 
*px = A[0];

709 
*py = A[1];

710 
} else {

711 
A = s>motion_val[xy  1];

712 
B = s>motion_val[xy  wrap]; 
713 
C = s>motion_val[xy + off[block]  wrap]; 
714 
*px = mid_pred(A[0], B[0], C[0]); 
715 
*py = mid_pred(A[1], B[1], C[1]); 
716 
} 
717 
return mot_val;

718 
} 
719  
720 
static void h263_encode_motion(MpegEncContext * s, int val, int f_code) 
721 
{ 
722 
int range, l, m, bit_size, sign, code, bits;

723  
724 
if (val == 0) { 
725 
/* zero vector */

726 
code = 0;

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

729 
bit_size = f_code  1;

730 
range = 1 << bit_size;

731 
/* modulo encoding */

732 
l = range * 32;

733 
m = 2 * l;

734 
if (val < l) {

735 
val += m; 
736 
} else if (val >= l) { 
737 
val = m; 
738 
} 
739  
740 
if (val >= 0) { 
741 
sign = 0;

742 
} else {

743 
val = val; 
744 
sign = 1;

745 
} 
746 
val; 
747 
code = (val >> bit_size) + 1;

748 
bits = val & (range  1);

749  
750 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
751 
if (bit_size > 0) { 
752 
put_bits(&s>pb, bit_size, bits); 
753 
} 
754 
} 
755 
} 
756  
757 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

758 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
759 
{ 
760 
short sval = 0; 
761 
short i = 0; 
762 
short n_bits = 0; 
763 
short temp_val;

764 
int code = 0; 
765 
int tcode;

766 

767 
if ( val == 0) 
768 
put_bits(&s>pb, 1, 1); 
769 
else if (val == 1) 
770 
put_bits(&s>pb, 3, 0); 
771 
else if (val == 1) 
772 
put_bits(&s>pb, 3, 2); 
773 
else {

774 

775 
sval = ((val < 0) ? (short)(val):(short)val); 
776 
temp_val = sval; 
777 

778 
while (temp_val != 0) { 
779 
temp_val = temp_val >> 1;

780 
n_bits++; 
781 
} 
782 

783 
i = n_bits  1;

784 
while (i > 0) { 
785 
tcode = (sval & (1 << (i1))) >> (i1); 
786 
tcode = (tcode << 1)  1; 
787 
code = (code << 2)  tcode;

788 
i; 
789 
} 
790 
code = ((code << 1)  (val < 0)) << 1; 
791 
put_bits(&s>pb, (2*n_bits)+1, code); 
792 
//printf("\nVal = %d\tCode = %d", sval, code);

793 
} 
794 
} 
795  
796 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
797 
{ 
798 
int f_code;

799 
int mv;

800 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
801 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

802 
int len;

803  
804 
if(mv==0) len= mvtab[0][1]; 
805 
else{

806 
int val, bit_size, range, code;

807  
808 
bit_size = s>f_code  1;

809 
range = 1 << bit_size;

810  
811 
val=mv; 
812 
if (val < 0) 
813 
val = val; 
814 
val; 
815 
code = (val >> bit_size) + 1;

816 
if(code<33){ 
817 
len= mvtab[code][1] + 1 + bit_size; 
818 
}else{

819 
len= mvtab[32][1] + 2 + bit_size; 
820 
} 
821 
} 
822  
823 
mv_penalty[f_code][mv+MAX_MV]= len; 
824 
} 
825 
} 
826  
827 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
828 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
829 
fcode_tab[mv+MAX_MV]= f_code; 
830 
} 
831 
} 
832  
833 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
834 
umv_fcode_tab[mv]= 1;

835 
} 
836 
} 
837  
838 
static void init_uni_dc_tab() 
839 
{ 
840 
int level, uni_code, uni_len;

841  
842 
for(level=256; level<256; level++){ 
843 
int size, v, l;

844 
/* find number of bits */

845 
size = 0;

846 
v = abs(level); 
847 
while (v) {

848 
v >>= 1;

849 
size++; 
850 
} 
851  
852 
if (level < 0) 
853 
l= (level) ^ ((1 << size)  1); 
854 
else

855 
l= level; 
856  
857 
/* luminance */

858 
uni_code= DCtab_lum[size][0];

859 
uni_len = DCtab_lum[size][1];

860  
861 
if (size > 0) { 
862 
uni_code<<=size; uni_code=l; 
863 
uni_len+=size; 
864 
if (size > 8){ 
865 
uni_code<<=1; uni_code=1; 
866 
uni_len++; 
867 
} 
868 
} 
869 
uni_DCtab_lum[level+256][0]= uni_code; 
870 
uni_DCtab_lum[level+256][1]= uni_len; 
871  
872 
/* chrominance */

873 
uni_code= DCtab_chrom[size][0];

874 
uni_len = DCtab_chrom[size][1];

875 

876 
if (size > 0) { 
877 
uni_code<<=size; uni_code=l; 
878 
uni_len+=size; 
879 
if (size > 8){ 
880 
uni_code<<=1; uni_code=1; 
881 
uni_len++; 
882 
} 
883 
} 
884 
uni_DCtab_chrom[level+256][0]= uni_code; 
885 
uni_DCtab_chrom[level+256][1]= uni_len; 
886  
887 
} 
888 
} 
889  
890 
void h263_encode_init(MpegEncContext *s)

891 
{ 
892 
static int done = 0; 
893  
894 
if (!done) {

895 
done = 1;

896  
897 
init_uni_dc_tab(); 
898  
899 
init_rl(&rl_inter); 
900 
init_rl(&rl_intra); 
901  
902 
init_mv_penalty_and_fcode(s); 
903 
} 
904 
s>mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

905 

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

907 
switch(s>codec_id){

908 
case CODEC_ID_MPEG4:

909 
s>fcode_tab= fcode_tab; 
910 
s>min_qcoeff= 2048;

911 
s>max_qcoeff= 2047;

912 
break;

913 
case CODEC_ID_H263P:

914 
s>fcode_tab= umv_fcode_tab; 
915 
s>min_qcoeff= 128;

916 
s>max_qcoeff= 127;

917 
break;

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

920 
s>max_qcoeff= 127;

921 
} 
922  
923 
/* h263 type bias */

924 
//FIXME mpeg4 mpeg quantizer

925 
s>intra_quant_bias=0;

926 
s>inter_quant_bias=(1<<(QUANT_BIAS_SHIFT2)); //(a  x/4)/x 
927 
} 
928  
929 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
930 
{ 
931 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

932 
int code;

933 
RLTable *rl = &rl_inter; 
934  
935 
if (s>mb_intra) {

936 
/* DC coef */

937 
level = block[0];

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

939 
if (level > 254) { 
940 
level = 254;

941 
block[0] = 254; 
942 
} 
943 
/* 0 cannot be represented also */

944 
else if (!level) { 
945 
level = 1;

946 
block[0] = 1; 
947 
} 
948 
if (level == 128) 
949 
put_bits(&s>pb, 8, 0xff); 
950 
else

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

953 
} else {

954 
i = 0;

955 
} 
956  
957 
/* AC coefs */

958 
last_index = s>block_last_index[n]; 
959 
last_non_zero = i  1;

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

961 
j = zigzag_direct[i]; 
962 
level = block[j]; 
963 
if (level) {

964 
run = i  last_non_zero  1;

965 
last = (i == last_index); 
966 
sign = 0;

967 
slevel = level; 
968 
if (level < 0) { 
969 
sign = 1;

970 
level = level; 
971 
} 
972 
code = get_rl_index(rl, last, run, level); 
973 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
974 
if (code == rl>n) {

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

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

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

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

980 
} 
981 
last_non_zero = i; 
982 
} 
983 
} 
984 
} 
985  
986 
/***************************************************/

987  
988 
static void mpeg4_stuffing(PutBitContext * pbc) 
989 
{ 
990 
int length;

991 
put_bits(pbc, 1, 0); 
992 
length= (get_bit_count(pbc))&7;

993 
put_bits(pbc, length, (1<<length)1); 
994 
} 
995  
996 
static void put_string(PutBitContext * pbc, char *s) 
997 
{ 
998 
while(*s){

999 
put_bits(pbc, 8, *s);

1000 
s++; 
1001 
} 
1002 
put_bits(pbc, 8, 0); 
1003 
} 
1004  
1005 
/* must be called before writing the header */

1006 
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ 
1007 
int time_div, time_mod;

1008  
1009 
if(s>pict_type==I_TYPE){ //we will encode a vol header 
1010 
s>time_increment_resolution= s>frame_rate/ff_gcd(s>frame_rate, FRAME_RATE_BASE); 
1011 
if(s>time_increment_resolution>=256*256) s>time_increment_resolution= 256*128; 
1012  
1013 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
1014 
} 
1015  
1016 
s>time= picture_number*(int64_t)FRAME_RATE_BASE*s>time_increment_resolution/s>frame_rate; 
1017 
time_div= s>time/s>time_increment_resolution; 
1018 
time_mod= s>time%s>time_increment_resolution; 
1019  
1020 
if(s>pict_type==B_TYPE){

1021 
s>bp_time= s>last_non_b_time  s>time; 
1022 
}else{

1023 
s>last_time_base= s>time_base; 
1024 
s>time_base= time_div; 
1025 
s>pp_time= s>time  s>last_non_b_time; 
1026 
s>last_non_b_time= s>time; 
1027 
} 
1028 
} 
1029  
1030 
static void mpeg4_encode_vol_header(MpegEncContext * s) 
1031 
{ 
1032 
int vo_ver_id=1; //must be 2 if we want GMC or qpel 
1033 
char buf[255]; 
1034  
1035 
s>vo_type= s>has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE; 
1036  
1037 
if(get_bit_count(&s>pb)!=0) mpeg4_stuffing(&s>pb); 
1038 
put_bits(&s>pb, 16, 0); 
1039 
put_bits(&s>pb, 16, 0x100); /* video obj */ 
1040 
put_bits(&s>pb, 16, 0); 
1041 
put_bits(&s>pb, 16, 0x120); /* video obj layer */ 
1042  
1043 
put_bits(&s>pb, 1, 0); /* random access vol */ 
1044 
put_bits(&s>pb, 8, s>vo_type); /* video obj type indication */ 
1045 
put_bits(&s>pb, 1, 1); /* is obj layer id= yes */ 
1046 
put_bits(&s>pb, 4, vo_ver_id); /* is obj layer ver id */ 
1047 
put_bits(&s>pb, 3, 1); /* is obj layer priority */ 
1048 
if(s>aspect_ratio_info)

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

1051 
put_bits(&s>pb, 4, 1); /* aspect ratio info= sqare pixel */ 
1052  
1053 
if(s>low_delay){

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

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

1059 
put_bits(&s>pb, 1, 0); /* vol control parameters= no */ 
1060 
} 
1061  
1062 
put_bits(&s>pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 
1063 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1064 

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

1066 
if (s>time_increment_bits < 1) 
1067 
s>time_increment_bits = 1;

1068 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1069 
put_bits(&s>pb, 1, 0); /* fixed vop rate=no */ 
1070 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1071 
put_bits(&s>pb, 13, s>width); /* vol width */ 
1072 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1073 
put_bits(&s>pb, 13, s>height); /* vol height */ 
1074 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1075 
put_bits(&s>pb, 1, 0); /* interlace */ 
1076 
put_bits(&s>pb, 1, 1); /* obmc disable */ 
1077 
if (vo_ver_id == 1) { 
1078 
put_bits(&s>pb, 1, s>vol_sprite_usage=0); /* sprite enable */ 
1079 
}else{ /* vo_ver_id == 2 */ 
1080 
put_bits(&s>pb, 2, s>vol_sprite_usage=0); /* sprite enable */ 
1081 
} 
1082 
put_bits(&s>pb, 1, 0); /* not 8 bit */ 
1083 
put_bits(&s>pb, 1, 0); /* quant type= h263 style*/ 
1084 
if (vo_ver_id != 1) 
1085 
put_bits(&s>pb, 1, s>quarter_sample=0); 
1086 
put_bits(&s>pb, 1, 1); /* complexity estimation disable */ 
1087 
put_bits(&s>pb, 1, 1); /* resync marker disable */ 
1088 
put_bits(&s>pb, 1, 0); /* data partitioned */ 
1089 
if (vo_ver_id != 1){ 
1090 
put_bits(&s>pb, 1, 0); /* newpred */ 
1091 
put_bits(&s>pb, 1, 0); /* reduced res vop */ 
1092 
} 
1093 
put_bits(&s>pb, 1, 0); /* scalability */ 
1094  
1095 
mpeg4_stuffing(&s>pb); 
1096 
put_bits(&s>pb, 16, 0); 
1097 
put_bits(&s>pb, 16, 0x1B2); /* user_data */ 
1098 
sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);

1099 
put_string(&s>pb, buf); 
1100  
1101 
s>no_rounding = 0;

1102 
} 
1103  
1104 
/* write mpeg4 VOP header */

1105 
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
1106 
{ 
1107 
int time_incr;

1108 
int time_div, time_mod;

1109 

1110 
if(s>pict_type==I_TYPE) mpeg4_encode_vol_header(s);

1111 

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

1113 

1114 
if(get_bit_count(&s>pb)!=0) mpeg4_stuffing(&s>pb); 
1115 
put_bits(&s>pb, 16, 0); /* vop header */ 
1116 
put_bits(&s>pb, 16, 0x1B6); /* vop header */ 
1117 
put_bits(&s>pb, 2, s>pict_type  1); /* pict type: I = 0 , P = 1 */ 
1118  
1119 
time_div= s>time/s>time_increment_resolution; 
1120 
time_mod= s>time%s>time_increment_resolution; 
1121 
time_incr= time_div  s>last_time_base; 
1122 
while(time_incr)

1123 
put_bits(&s>pb, 1, 1); 
1124 

1125 
put_bits(&s>pb, 1, 0); 
1126  
1127 
put_bits(&s>pb, 1, 1); /* marker */ 
1128 
put_bits(&s>pb, s>time_increment_bits, time_mod); /* time increment */

1129 
put_bits(&s>pb, 1, 1); /* marker */ 
1130 
put_bits(&s>pb, 1, 1); /* vop coded */ 
1131 
if ( s>pict_type == P_TYPE

1132 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE)) { 
1133 
s>no_rounding ^= 1;

1134 
put_bits(&s>pb, 1, s>no_rounding); /* rounding type */ 
1135 
} 
1136 
put_bits(&s>pb, 3, 0); /* intra dc VLC threshold */ 
1137 
//FIXME sprite stuff

1138  
1139 
put_bits(&s>pb, 5, s>qscale);

1140  
1141 
if (s>pict_type != I_TYPE)

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

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

1146 
} 
1147  
1148 
void h263_dc_scale(MpegEncContext * s)

1149 
{ 
1150 
#if 1 
1151 
const static UINT8 y_tab[32]={ 
1152 
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

1153 
0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46 
1154 
}; 
1155 
const static UINT8 c_tab[32]={ 
1156 
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

1157 
0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25 
1158 
}; 
1159 
s>y_dc_scale = y_tab[s>qscale]; 
1160 
s>c_dc_scale = c_tab[s>qscale]; 
1161 
#else

1162 
int quant;

1163 
quant = s>qscale; 
1164 
/* luminance */

1165 
if (quant < 5) 
1166 
s>y_dc_scale = 8;

1167 
else if (quant > 4 && quant < 9) 
1168 
s>y_dc_scale = (2 * quant);

1169 
else if (quant > 8 && quant < 25) 
1170 
s>y_dc_scale = (quant + 8);

1171 
else

1172 
s>y_dc_scale = (2 * quant  16); 
1173 
/* chrominance */

1174 
if (quant < 5) 
1175 
s>c_dc_scale = 8;

1176 
else if (quant > 4 && quant < 25) 
1177 
s>c_dc_scale = ((quant + 13) / 2); 
1178 
else

1179 
s>c_dc_scale = (quant  6);

1180 
#endif

1181 
} 
1182  
1183 
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) 
1184 
{ 
1185 
int a, b, c, wrap, pred, scale;

1186 
UINT16 *dc_val; 
1187 
int dummy;

1188  
1189 
/* find prediction */

1190 
if (n < 4) { 
1191 
scale = s>y_dc_scale; 
1192 
} else {

1193 
scale = s>c_dc_scale; 
1194 
} 
1195 
wrap= s>block_wrap[n]; 
1196 
dc_val = s>dc_val[0] + s>block_index[n];

1197  
1198 
/* B C

1199 
* A X

1200 
*/

1201 
a = dc_val[  1];

1202 
b = dc_val[  1  wrap];

1203 
c = dc_val[  wrap]; 
1204  
1205 
if (abs(a  b) < abs(b  c)) {

1206 
pred = c; 
1207 
*dir_ptr = 1; /* top */ 
1208 
} else {

1209 
pred = a; 
1210 
*dir_ptr = 0; /* left */ 
1211 
} 
1212 
/* we assume pred is positive */

1213 
#ifdef ARCH_X86

1214 
asm volatile ( 
1215 
"xorl %%edx, %%edx \n\t"

1216 
"mul %%ecx \n\t"

1217 
: "=d" (pred), "=a"(dummy) 
1218 
: "a" (pred + (scale >> 1)), "c" (inverse[scale]) 
1219 
); 
1220 
#else

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

1222 
#endif

1223  
1224 
/* prepare address for prediction update */

1225 
*dc_val_ptr = &dc_val[0];

1226  
1227 
return pred;

1228 
} 
1229  
1230 
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1231 
int dir)

1232 
{ 
1233 
int i;

1234 
INT16 *ac_val, *ac_val1; 
1235  
1236 
/* find prediction */

1237 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1238 
ac_val1 = ac_val; 
1239 
if (s>ac_pred) {

1240 
if (dir == 0) { 
1241 
/* left prediction */

1242 
ac_val = 16;

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

1245 
} 
1246 
} else {

1247 
/* top prediction */

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

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

1251 
} 
1252 
} 
1253 
} 
1254 
/* left copy */

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

1257 
/* top copy */

1258 
for(i=1;i<8;i++) 
1259 
ac_val1[8 + i] = block[block_permute_op(i)];

1260 
} 
1261  
1262 
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1263 
int dir)

1264 
{ 
1265 
int i;

1266 
INT16 *ac_val; 
1267  
1268 
/* find prediction */

1269 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1270 

1271 
if (dir == 0) { 
1272 
/* left prediction */

1273 
ac_val = 16;

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

1276 
} 
1277 
} else {

1278 
/* top prediction */

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

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

1282 
} 
1283 
} 
1284 
} 
1285  
1286 
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n) 
1287 
{ 
1288 
#if 1 
1289 
level+=256;

1290 
if (n < 4) { 
1291 
/* luminance */

1292 
put_bits(&s>pb, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]); 
1293 
} else {

1294 
/* chrominance */

1295 
put_bits(&s>pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]); 
1296 
} 
1297 
#else

1298 
int size, v;

1299 
/* find number of bits */

1300 
size = 0;

1301 
v = abs(level); 
1302 
while (v) {

1303 
v >>= 1;

1304 
size++; 
1305 
} 
1306  
1307 
if (n < 4) { 
1308 
/* luminance */

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

1311 
/* chrominance */

1312 
put_bits(&s>pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 
1313 
} 
1314  
1315 
/* encode remaining bits */

1316 
if (size > 0) { 
1317 
if (level < 0) 
1318 
level = (level) ^ ((1 << size)  1); 
1319 
put_bits(&s>pb, size, level); 
1320 
if (size > 8) 
1321 
put_bits(&s>pb, 1, 1); 
1322 
} 
1323 
#endif

1324 
} 
1325  
1326 
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table) 
1327 
{ 
1328 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

1329 
int code;

1330 
const RLTable *rl;

1331  
1332 
if (s>mb_intra) {

1333 
/* mpeg4 based DC predictor */

1334 
mpeg4_encode_dc(s, intra_dc, n); 
1335 
i = 1;

1336 
rl = &rl_intra; 
1337 
} else {

1338 
i = 0;

1339 
rl = &rl_inter; 
1340 
} 
1341  
1342 
/* AC coefs */

1343 
last_index = s>block_last_index[n]; 
1344 
last_non_zero = i  1;

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

1346 
j = scan_table[i]; 
1347 
level = block[j]; 
1348 
if (level) {

1349 
run = i  last_non_zero  1;

1350 
last = (i == last_index); 
1351 
sign = 0;

1352 
slevel = level; 
1353 
if (level < 0) { 
1354 
sign = 1;

1355 
level = level; 
1356 
} 
1357 
code = get_rl_index(rl, last, run, level); 
1358 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1359 
if (code == rl>n) {

1360 
int level1, run1;

1361 
level1 = level  rl>max_level[last][run]; 
1362 
if (level1 < 1) 
1363 
goto esc2;

1364 
code = get_rl_index(rl, last, run, level1); 
1365 
if (code == rl>n) {

1366 
esc2:

1367 
put_bits(&s>pb, 1, 1); 
1368 
if (level > MAX_LEVEL)

1369 
goto esc3;

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

1371 
if (run1 < 0) 
1372 
goto esc3;

1373 
code = get_rl_index(rl, last, run1, level); 
1374 
if (code == rl>n) {

1375 
esc3:

1376 
/* third escape */

1377 
put_bits(&s>pb, 1, 1); 
1378 
put_bits(&s>pb, 1, last);

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

1380 
put_bits(&s>pb, 1, 1); 
1381 
put_bits(&s>pb, 12, slevel & 0xfff); 
1382 
put_bits(&s>pb, 1, 1); 
1383 
} else {

1384 
/* second escape */

1385 
put_bits(&s>pb, 1, 0); 
1386 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1387 
put_bits(&s>pb, 1, sign);

1388 
} 
1389 
} else {

1390 
/* first escape */

1391 
put_bits(&s>pb, 1, 0); 
1392 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1393 
put_bits(&s>pb, 1, sign);

1394 
} 
1395 
} else {

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

1397 
} 
1398 
last_non_zero = i; 
1399 
} 
1400 
} 
1401 
} 
1402  
1403  
1404  
1405 
/***********************************************/

1406 
/* decoding */

1407  
1408 
static VLC intra_MCBPC_vlc;

1409 
static VLC inter_MCBPC_vlc;

1410 
static VLC cbpy_vlc;

1411 
static VLC mv_vlc;

1412 
static VLC dc_lum, dc_chrom;

1413 
static VLC sprite_trajectory;

1414 
static VLC mb_type_b_vlc;

1415  
1416 
void init_rl(RLTable *rl)

1417 
{ 
1418 
INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; 
1419 
UINT8 index_run[MAX_RUN+1];

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

1421  
1422 
/* compute max_level[], max_run[] and index_run[] */

1423 
for(last=0;last<2;last++) { 
1424 
if (last == 0) { 
1425 
start = 0;

1426 
end = rl>last; 
1427 
} else {

1428 
start = rl>last; 
1429 
end = rl>n; 
1430 
} 
1431  
1432 
memset(max_level, 0, MAX_RUN + 1); 
1433 
memset(max_run, 0, MAX_LEVEL + 1); 
1434 
memset(index_run, rl>n, MAX_RUN + 1);

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

1436 
run = rl>table_run[i]; 
1437 
level = rl>table_level[i]; 
1438 
if (index_run[run] == rl>n)

1439 
index_run[run] = i; 
1440 
if (level > max_level[run])

1441 
max_level[run] = level; 
1442 
if (run > max_run[level])

1443 
max_run[level] = run; 
1444 
} 
1445 
rl>max_level[last] = malloc(MAX_RUN + 1);

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

1447 
rl>max_run[last] = malloc(MAX_LEVEL + 1);

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

1449 
rl>index_run[last] = malloc(MAX_RUN + 1);

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

1451 
} 
1452 
} 
1453  
1454 
void init_vlc_rl(RLTable *rl)

1455 
{ 
1456 
init_vlc(&rl>vlc, 9, rl>n + 1, 
1457 
&rl>table_vlc[0][1], 4, 2, 
1458 
&rl>table_vlc[0][0], 4, 2); 
1459 
} 
1460  
1461 
/* init vlcs */

1462  
1463 
/* XXX: find a better solution to handle static init */

1464 
void h263_decode_init_vlc(MpegEncContext *s)

1465 
{ 
1466 
static int done = 0; 
1467  
1468 
if (!done) {

1469 
done = 1;

1470  
1471 
init_vlc(&intra_MCBPC_vlc, 6, 8, 
1472 
intra_MCBPC_bits, 1, 1, 
1473 
intra_MCBPC_code, 1, 1); 
1474 
init_vlc(&inter_MCBPC_vlc, 9, 25, 
1475 
inter_MCBPC_bits, 1, 1, 
1476 
inter_MCBPC_code, 1, 1); 
1477 
init_vlc(&cbpy_vlc, 6, 16, 
1478 
&cbpy_tab[0][1], 2, 1, 
1479 
&cbpy_tab[0][0], 2, 1); 
1480 
init_vlc(&mv_vlc, 9, 33, 
1481 
&mvtab[0][1], 2, 1, 
1482 
&mvtab[0][0], 2, 1); 
1483 
init_rl(&rl_inter); 
1484 
init_rl(&rl_intra); 
1485 
init_rl(&rl_intra_aic); 
1486 
init_vlc_rl(&rl_inter); 
1487 
init_vlc_rl(&rl_intra); 
1488 
init_vlc_rl(&rl_intra_aic); 
1489 
init_vlc(&dc_lum, 9, 13, 
1490 
&DCtab_lum[0][1], 2, 1, 
1491 
&DCtab_lum[0][0], 2, 1); 
1492 
init_vlc(&dc_chrom, 9, 13, 
1493 
&DCtab_chrom[0][1], 2, 1, 
1494 
&DCtab_chrom[0][0], 2, 1); 
1495 
init_vlc(&sprite_trajectory, 9, 15, 
1496 
&sprite_trajectory_tab[0][1], 4, 2, 
1497 
&sprite_trajectory_tab[0][0], 4, 2); 
1498 
init_vlc(&mb_type_b_vlc, 4, 4, 
1499 
&mb_type_b_tab[0][1], 2, 1, 
1500 
&mb_type_b_tab[0][0], 2, 1); 
1501 
} 
1502 
} 
1503  
1504 
int h263_decode_gob_header(MpegEncContext *s)

1505 
{ 
1506 
unsigned int val, gfid; 
1507 

1508 
/* Check for GOB Start Code */

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

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

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

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

1516 
#endif

1517 
s>gob_number = get_bits(&s>gb, 5); /* GN */ 
1518 
gfid = get_bits(&s>gb, 2); /* GFID */ 
1519 
s>qscale = get_bits(&s>gb, 5); /* GQUANT */ 
1520 
#ifdef DEBUG

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

1522 
#endif

1523 
return 1; 
1524 
} 
1525 
return 0; 
1526 

1527 
} 
1528  
1529 
static inline void memsetw(short *tab, int val, int n) 
1530 
{ 
1531 
int i;

1532 
for(i=0;i<n;i++) 
1533 
tab[i] = val; 
1534 
} 
1535  
1536 
static int mpeg4_resync(MpegEncContext *s) 
1537 
{ 
1538 
int state, v, bits;

1539 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
1540 
int header_extension=0, mb_num; 
1541 
int c_wrap, c_xy, l_wrap, l_xy;

1542 
int time_increment;

1543 
//printf("resync at %d %d\n", s>mb_x, s>mb_y);

1544 
//printf("%X\n", show_bits(&s>gb, 24));

1545  
1546 
if( get_bits_count(&s>gb) > s>gb.size*832) 
1547 
return 0; 
1548  
1549 
align_get_bits(&s>gb); 
1550 
state = 0xff;

1551 
for(;;) {

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

1553 
//printf("%X ", v);

1554 
state = ((state << 8)  v) & 0xffff; 
1555 
if (state == 0) break; 
1556 
if( get_bits_count(&s>gb) > s>gb.size*832){ 
1557 
printf("resync failed\n");

1558 
return 1; 
1559 
} 
1560 
} 
1561 
//printf("%X\n", show_bits(&s>gb, 24));

1562 
bits=0;

1563 
while(!get_bits1(&s>gb) && bits<30) bits++; 
1564 
if(s>pict_type == P_TYPE && bits != s>f_code1) 
1565 
printf("marker does not match f_code\n");

1566 
//FIXME check bits for Bframess

1567 
//printf("%X\n", show_bits(&s>gb, 24));

1568  
1569 
if(s>shape != RECT_SHAPE){

1570 
header_extension= get_bits1(&s>gb); 
1571 
//FIXME more stuff here

1572 
} 
1573  
1574 
mb_num= get_bits(&s>gb, mb_num_bits); 
1575 
if(mb_num != s>mb_x + s>mb_y*s>mb_width){

1576 
printf("MBnum change not supported %d %d\n", mb_num, s>mb_x + s>mb_y*s>mb_width);

1577 
// s>mb_x= mb_num % s>mb_width;

1578 
// s>mb_y= mb_num / s>mb_width;

1579 
//FIXME many vars are wrong now

1580 
} 
1581  
1582 
if(s>shape != BIN_ONLY_SHAPE){

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

1584 
h263_dc_scale(s); 
1585 
} 
1586  
1587 
if(s>shape == RECT_SHAPE){

1588 
header_extension= get_bits1(&s>gb); 
1589 
} 
1590 
if(header_extension){

1591 
int time_incr=0; 
1592 
printf("header extension not really supported\n");

1593 
while (get_bits1(&s>gb) != 0) 
1594 
time_incr++; 
1595  
1596 
check_marker(&s>gb, "before time_increment in video packed header");

1597 
time_increment= get_bits(&s>gb, s>time_increment_bits); 
1598 
if(s>pict_type!=B_TYPE){

1599 
s>last_time_base= s>time_base; 
1600 
s>time_base+= time_incr; 
1601 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
1602 
s>pp_time= s>time  s>last_non_b_time; 
1603 
s>last_non_b_time= s>time; 
1604 
}else{

1605 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
1606 
s>bp_time= s>last_non_b_time  s>time; 
1607 
} 
1608 
check_marker(&s>gb, "before vop_coding_type in video packed header");

1609 

1610 
skip_bits(&s>gb, 2); /* vop coding type */ 
1611 
//FIXME not rect stuff here

1612  
1613 
if(s>shape != BIN_ONLY_SHAPE){

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

1617 
mpeg4_decode_sprite_trajectory(s); 
1618 
} 
1619  
1620 
//FIXME reduced res stuff here

1621 

1622 
if (s>pict_type != I_TYPE) {

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

1626 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
1627 
} 
1628 
} 
1629 
if (s>pict_type == B_TYPE) {

1630 
s>b_code = get_bits(&s>gb, 3);

1631 
} 
1632 
} 
1633  
1634 
} 
1635 
//FIXME newpred stuff

1636  
1637 
l_wrap= s>block_wrap[0];

1638 
l_xy= s>mb_y*l_wrap*2;

1639 
c_wrap= s>block_wrap[4];

1640 
c_xy= s>mb_y*c_wrap; 
1641  
1642 
/* clean DC */

1643 
memsetw(s>dc_val[0] + l_xy, 1024, l_wrap*3); 
1644 
memsetw(s>dc_val[1] + c_xy, 1024, c_wrap*2); 
1645 
memsetw(s>dc_val[2] + c_xy, 1024, c_wrap*2); 
1646  
1647 
/* clean AC */

1648 
memset(s>ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16)); 
1649 
memset(s>ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); 
1650 
memset(s>ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); 
1651  
1652 
/* clean MV */

1653 
memset(s>motion_val + l_xy, 0, l_wrap*3*2*sizeof(INT16)); 
1654 
// memset(s>motion_val, 0, 2*sizeof(INT16)*(2 + s>mb_width*2)*(2 + s>mb_height*2));

1655 
s>resync_x_pos= s>mb_x; 
1656 
s>first_slice_line=1;

1657  
1658 
return 0; 
1659 
} 
1660  
1661 
int h263_decode_mb(MpegEncContext *s,

1662 
DCTELEM block[6][64]) 
1663 
{ 
1664 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

1665 
INT16 *mot_val; 
1666 
static INT8 quant_tab[4] = { 1, 2, 1, 2 }; 
1667  
1668 
if(s>resync_marker){

1669 
if( s>resync_x_pos == s>mb_x+1 
1670 
 s>resync_x_pos == s>mb_x){ 
1671 
/* f*ck mpeg4

1672 
this is here so we dont need to slowdown h263_pred_motion with it */

1673 
if(s>resync_x_pos == s>mb_x+1 && s>mb_x==0){ 
1674 
int xy= s>block_index[0]  s>block_wrap[0]; 
1675 
s>motion_val[xy][0]= s>motion_val[xy+2][0]; 
1676 
s>motion_val[xy][1]= s>motion_val[xy+2][1]; 
1677 
} 
1678  
1679 
s>first_slice_line=0;

1680 
s>resync_x_pos=0; // isnt needed but for cleanness sake ;) 
1681 
} 
1682  
1683 
if(show_aligned_bits(&s>gb, 1, 16) == 0){ 
1684 
if( mpeg4_resync(s) < 0 ) return 1; 
1685 

1686 
} 
1687 
} 
1688  
1689 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

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

1691 
/* skip mb */

1692 
s>mb_intra = 0;

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

1695 
s>mv_dir = MV_DIR_FORWARD; 
1696 
s>mv_type = MV_TYPE_16X16; 
1697 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

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

1700  
1701 
s>mcsel=1;

1702 
if(s>divx_version==500 && s>divx_build==413){ 
1703 
s>mv[0][0][0] = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
1704 
s>mv[0][0][1] = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
1705 
}else{

1706 
s>mv[0][0][0] = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
1707 
s>mv[0][0][1] = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
1708 
} 
1709 
/* if (s>mv[0][0][0] < l) s>mv[0][0][0]= l;

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

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

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

1713  
1714 
s>mb_skiped = 0;

1715 
}else{

1716 
s>mcsel=0;

1717 
s>mv[0][0][0] = 0; 
1718 
s>mv[0][0][1] = 0; 
1719 
s>mb_skiped = 1;

1720 
} 
1721 
return 0; 
1722 
} 
1723 
cbpc = get_vlc(&s>gb, &inter_MCBPC_vlc); 
1724 
//fprintf(stderr, "\tCBPC: %d", cbpc);

1725 
if (cbpc < 0) 
1726 
return 1; 
1727 
if (cbpc > 20) 
1728 
cbpc+=3;

1729 
else if (cbpc == 20) 
1730 
fprintf(stderr, "Stuffing !");

1731 

1732 
dquant = cbpc & 8;

1733 
s>mb_intra = ((cbpc & 4) != 0); 
1734 
if (s>mb_intra) goto intra; 
1735 

1736 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
1737 
s>mcsel= get_bits1(&s>gb); 
1738 
else s>mcsel= 0; 
1739 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
1740 
cbp = (cbpc & 3)  ((cbpy ^ 0xf) << 2); 
1741 
if (dquant) {

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

1743 
if (s>qscale < 1) 
1744 
s>qscale = 1;

1745 
else if (s>qscale > 31) 
1746 
s>qscale = 31;

1747 
h263_dc_scale(s); 
1748 
} 
1749 
s>mv_dir = MV_DIR_FORWARD; 
1750 
if ((cbpc & 16) == 0) { 
1751 
/* 16x16 motion prediction */

1752 
s>mv_type = MV_TYPE_16X16; 
1753 
h263_pred_motion(s, 0, &pred_x, &pred_y);

1754 
if (s>umvplus_dec)

1755 
mx = h263p_decode_umotion(s, pred_x); 
1756 
else if(!s>mcsel) 
1757 
mx = h263_decode_motion(s, pred_x, s>f_code); 
1758 
else {

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

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

1764 
mx = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
1765 
} 
1766 
// if (mx < l) mx= l, printf("C");

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

1768 
} 
1769 
if (mx >= 0xffff) 
1770 
return 1; 
1771 

1772 
if (s>umvplus_dec)

1773 
my = h263p_decode_umotion(s, pred_y); 
1774 
else if(!s>mcsel) 
1775 
my = h263_decode_motion(s, pred_y, s>f_code); 
1776 
else{

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

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

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

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

1786 
} 
1787 
if (my >= 0xffff) 
1788 
return 1; 
1789 
s>mv[0][0][0] = mx; 
1790 
s>mv[0][0][1] = my; 
1791 
/*fprintf(stderr, "\n MB %d", (s>mb_y * s>mb_width) + s>mb_x);

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

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

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

1796 

1797 
} else {

1798 
s>mv_type = MV_TYPE_8X8; 
1799 
for(i=0;i<4;i++) { 
1800 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
1801 
if (s>umvplus_dec)

1802 
mx = h263p_decode_umotion(s, pred_x); 
1803 
else

1804 
mx = h263_decode_motion(s, pred_x, s>f_code); 
1805 
if (mx >= 0xffff) 
1806 
return 1; 
1807 

1808 
if (s>umvplus_dec)

1809 
my = h263p_decode_umotion(s, pred_y); 
1810 
else

1811 
my = h263_decode_motion(s, pred_y, s>f_code); 
1812 
if (my >= 0xffff) 
1813 
return 1; 
1814 
s>mv[0][i][0] = mx; 
1815 
s>mv[0][i][1] = my; 
1816 
if (s>umvplus_dec && (mx  pred_x) == 1 && (my  pred_y) == 1) 
1817 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

1818 
mot_val[0] = mx;

1819 
mot_val[1] = my;

1820 
} 
1821 
} 
1822 
} else if(s>pict_type==B_TYPE) { 
1823 
int modb1; // first bit of modb 
1824 
int modb2; // second bit of modb 
1825 
int mb_type;

1826 
uint16_t time_pp; 
1827 
uint16_t time_pb; 
1828 
int xy;

1829  
1830 
s>mb_intra = 0; //Bframes never contain intra blocks 
1831 
s>mcsel=0; // ... true gmc blocks 
1832  
1833 
if(s>mb_x==0){ 
1834 
s>last_mv[0][0][0]= 
1835 
s>last_mv[0][0][1]= 
1836 
s>last_mv[1][0][0]= 
1837 
s>last_mv[1][0][1]= 0; 
1838 
// printf("\n");

1839 
} 
1840  
1841 
/* if we skipped it in the future P Frame than skip it now too */

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

1843  
1844 
if(s>mb_skiped){

1845 
/* skip mb */

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

1848  
1849 
s>mv_dir = MV_DIR_FORWARD; 
1850 
s>mv_type = MV_TYPE_16X16; 
1851 
s>mv[0][0][0] = 0; 
1852 
s>mv[0][0][1] = 0; 
1853 
s>mv[1][0][0] = 0; 
1854 
s>mv[1][0][1] = 0; 
1855 
//FIXME is this correct?

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

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

1858 
// printf("S");

1859 
return 0; 
1860 
} 
1861  
1862 
modb1= get_bits1(&s>gb); 
1863 
if(modb1==0){ 
1864 
modb2= get_bits1(&s>gb); 
1865 
mb_type= get_vlc(&s>gb, &mb_type_b_vlc); 
1866 
if(modb2==0) cbp= get_bits(&s>gb, 6); 
1867 
else cbp=0; 
1868 
if (mb_type && cbp) {

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

1870 
s>qscale +=get_bits1(&s>gb)*4  2; 
1871 
if (s>qscale < 1) 
1872 
s>qscale = 1;

1873 
else if (s>qscale > 31) 
1874 
s>qscale = 31;

1875 
h263_dc_scale(s); 
1876 
} 
1877 
} 
1878 
}else{

1879 
mb_type=4; //like 0 but no vectors coded 
1880 
cbp=0;

1881 
} 
1882 
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

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

1885 
{ 
1886 
case 0: /* direct */ 
1887 
mx = h263_decode_motion(s, 0, 1); 
1888 
my = h263_decode_motion(s, 0, 1); 
1889 
case 4: /* direct with mx=my=0 */ 
1890 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
1891 
xy= s>block_index[0];

1892 
time_pp= s>pp_time; 
1893 
time_pb= time_pp  s>bp_time; 
1894 
//if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);

1895 
//FIXME 4MV

1896 
//FIXME avoid divides

1897 
s>mv[0][0][0] = s>motion_val[xy][0]*time_pb/time_pp + mx; 
1898 
s>mv[0][0][1] = s>motion_val[xy][1]*time_pb/time_pp + my; 
1899 
s>mv[1][0][0] = mx ? s>mv[0][0][0]  s>motion_val[xy][0] 
1900 
: s>motion_val[xy][0]*(time_pb  time_pp)/time_pp + mx;

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

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

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

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

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

1907 
// printf("D");

1908 
break;

1909 
case 1: 
1910 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD; 
1911 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
1912 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
1913 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
1914 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
1915  
1916 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
1917 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
1918 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
1919 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
1920 
// printf("I");

1921 
break;

1922 
case 2: 
1923 
s>mv_dir = MV_DIR_BACKWARD; 
1924 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
1925 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
1926 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
1927 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
1928 
// printf("B");

1929 
break;

1930 
case 3: 
1931 
s>mv_dir = MV_DIR_FORWARD; 
1932 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
1933 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
1934 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
1935 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
1936 
// printf("F");

1937 
break;

1938 
default: return 1; 
1939 
} 
1940 
} else { /* IFrame */ 
1941 
cbpc = get_vlc(&s>gb, &intra_MCBPC_vlc); 
1942 
if (cbpc < 0) 
1943 
return 1; 
1944 
dquant = cbpc & 4;

1945 
s>mb_intra = 1;

1946 
intra:

1947 
s>ac_pred = 0;

1948 
if (s>h263_pred  s>h263_aic) {

1949 
s>ac_pred = get_bits1(&s>gb); 
1950 
if (s>ac_pred && s>h263_aic)

1951 
s>h263_aic_dir = get_bits1(&s>gb); 
1952 
} 
1953 
if (s>h263_aic) {

1954 
s>y_dc_scale = 2 * s>qscale;

1955 
s>c_dc_scale = 2 * s>qscale;

1956 
} 
1957 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
1958 
cbp = (cbpc & 3)  (cbpy << 2); 
1959 
if (dquant) {

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

1961 
if (s>qscale < 1) 
1962 
s>qscale = 1;

1963 
else if (s>qscale > 31) 
1964 
s>qscale = 31;

1965 
h263_dc_scale(s); 
1966 
} 
1967 
} 
1968  
1969 
/* decode each block */

1970 
if (s>h263_pred) {

1971 
for (i = 0; i < 6; i++) { 
1972 
if (mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
1973 
return 1; 
1974 
} 
1975 
} else {

1976 
for (i = 0; i < 6; i++) { 
1977 
if (h263_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
1978 
return 1; 
1979 
} 
1980 
} 
1981 
return 0; 
1982 
} 
1983  
1984 
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 
1985 
{ 
1986 
int code, val, sign, shift, l, m;

1987  
1988 
code = get_vlc(&s>gb, &mv_vlc); 
1989 
if (code < 0) 
1990 
return 0xffff; 
1991  
1992 
if (code == 0) 
1993 
return pred;

1994 
sign = get_bits1(&s>gb); 
1995 
shift = f_code  1;

1996 
val = (code  1) << shift;

1997 
if (shift > 0) 
1998 
val = get_bits(&s>gb, shift); 
1999 
val++; 
2000 
if (sign)

2001 
val = val; 
2002 
val += pred; 
2003 

2004 
/* modulo decoding */

2005 
if (!s>h263_long_vectors) {

2006 
l = (1 << (f_code  1)) * 32; 
2007 
m = 2 * l;

2008 
if (val < l) {

2009 
val += m; 
2010 
} else if (val >= l) { 
2011 
val = m; 
2012 
} 
2013 
} else {

2014 
/* horrible h263 long vector mode */

2015 
if (pred < 31 && val < 63) 
2016 
val += 64;

2017 
if (pred > 32 && val > 63) 
2018 
val = 64;

2019 

2020 
} 
2021 
return val;

2022 
} 
2023  
2024 
/* Decodes RVLC of H.263+ UMV */

2025 
static int h263p_decode_umotion(MpegEncContext * s, int pred) 
2026 
{ 
2027 
int code = 0, sign; 
2028 

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

2031 

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

2033 

2034 
while (get_bits1(&s>gb))

2035 
{ 
2036 
code <<= 1;

2037 
code += get_bits1(&s>gb); 
2038 
} 
2039 
sign = code & 1;

2040 
code >>= 1;

2041 

2042 
code = (sign) ? (pred  code) : (pred + code); 
2043 
#ifdef DEBUG

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

2045 
#endif

2046 
return code;

2047  
2048 
} 
2049  
2050 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
2051 
int n, int coded) 
2052 
{ 
2053 
int code, level, i, j, last, run;

2054 
RLTable *rl = &rl_inter; 
2055 
const UINT8 *scan_table;

2056  
2057 
scan_table = zigzag_direct; 
2058 
if (s>h263_aic && s>mb_intra) {

2059 
rl = &rl_intra_aic; 
2060 
i = 0;

2061 
if (s>ac_pred) {

2062 
if (s>h263_aic_dir)

2063 
scan_table = ff_alternate_vertical_scan; /* left */

2064 
else

2065 
scan_table = ff_alternate_horizontal_scan; /* top */

2066 
} 
2067 
} else if (s>mb_intra) { 
2068 
/* DC coef */

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

2071 
component = (n <= 3 ? 0 : n  4 + 1); 
2072 
level = s>last_dc[component]; 
2073 
if (s>rv10_first_dc_coded[component]) {

2074 
diff = rv_decode_dc(s, n); 
2075 
if (diff == 0xffff) 
2076 
return 1; 
2077 
level += diff; 
2078 
level = level & 0xff; /* handle wrap round */ 
2079 
s>last_dc[component] = level; 
2080 
} else {

2081 
s>rv10_first_dc_coded[component] = 1;

2082 
} 
2083 
} else {

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

2085 
if (level == 255) 
2086 
level = 128;

2087 
} 
2088 
block[0] = level;

2089 
i = 1;

2090 
} else {

2091 
i = 0;

2092 
} 
2093 
if (!coded) {

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

2095 
goto not_coded;

2096 
s>block_last_index[n] = i  1;

2097 
return 0; 
2098 
} 
2099  
2100 
for(;;) {

2101 
code = get_vlc(&s>gb, &rl>vlc); 
2102 
if (code < 0) 
2103 
return 1; 
2104 
if (code == rl>n) {

2105 
/* escape */

2106 
last = get_bits1(&s>gb); 
2107 
run = get_bits(&s>gb, 6);

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

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

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

2112 
level = (level << 20) >> 20; 
2113 
} 
2114 
} else {

2115 
run = rl>table_run[code]; 
2116 
level = rl>table_level[code]; 
2117 
last = code >= rl>last; 
2118 
if (get_bits1(&s>gb))

2119 
level = level; 
2120 
} 
2121 
i += run; 
2122 
if (i >= 64) 
2123 
return 1; 
2124 
j = scan_table[i]; 
2125 
block[j] = level; 
2126 
if (last)

2127 
break;

2128 
i++; 
2129 
} 
2130 
not_coded:

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

2132 
h263_pred_acdc(s, block, n); 
2133 
i = 63;

2134 
} 
2135 
s>block_last_index[n] = i; 
2136 
return 0; 
2137 
} 
2138  
2139 
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
2140 
{ 
2141 
int level, pred, code;

2142 
UINT16 *dc_val; 
2143  
2144 
if (n < 4) 
2145 
code = get_vlc(&s>gb, &dc_lum); 
2146 
else

2147 
code = get_vlc(&s>gb, &dc_chrom); 
2148 
if (code < 0) 
2149 
return 1; 
2150 
if (code == 0) { 
2151 
level = 0;

2152 
} else {

2153 
level = get_bits(&s>gb, code); 
2154 
if ((level >> (code  1)) == 0) /* if MSB not set it is negative*/ 
2155 
level =  (level ^ ((1 << code)  1)); 
2156 
if (code > 8) 
2157 
skip_bits1(&s>gb); /* marker */

2158 
} 
2159  
2160 
pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
2161 
level += pred; 
2162 
if (level < 0) 
2163 
level = 0;

2164 
if (n < 4) { 
2165 
*dc_val = level * s>y_dc_scale; 
2166 
} else {

2167 
*dc_val = level * s>c_dc_scale; 
2168 
} 
2169 
return level;

2170 
} 
2171  
2172 
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
2173 
int n, int coded) 
2174 
{ 
2175 
int code, level, i, j, last, run;

2176 
int dc_pred_dir;

2177 
RLTable *rl; 
2178 
const UINT8 *scan_table;

2179  
2180 
if (s>mb_intra) {

2181 
/* DC coef */

2182 
level = mpeg4_decode_dc(s, n, &dc_pred_dir); 
2183 
if (level < 0) 
2184 
return 1; 
2185 
block[0] = level;

2186 
i = 1;

2187 
if (!coded)

2188 
goto not_coded;

2189 
rl = &rl_intra; 
2190 
if (s>ac_pred) {

2191 
if (dc_pred_dir == 0) 
2192 
scan_table = ff_alternate_vertical_scan; /* left */

2193 
else

2194 
scan_table = ff_alternate_horizontal_scan; /* top */

2195 
} else {

2196 
scan_table = zigzag_direct; 
2197 
} 
2198 
} else {

2199 
i = 0;

2200 
if (!coded) {

2201 
s>block_last_index[n] = i  1;

2202 
return 0; 
2203 
} 
2204 
rl = &rl_inter; 
2205 
scan_table = zigzag_direct; 
2206 
} 
2207  
2208 
for(;;) {

2209 
code = get_vlc(&s>gb, &rl>vlc); 
2210 
if (code < 0) 
2211 
return 1; 
2212 
if (code == rl>n) {

2213 
/* escape */

2214 
if (get_bits1(&s>gb) != 0) { 
2215 
if (get_bits1(&s>gb) != 0) { 
2216 
/* third escape */

2217 
last = get_bits1(&s>gb); 
2218 
run = get_bits(&s>gb, 6);

2219 
get_bits1(&s>gb); /* marker */

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

2221 
level = (level << 20) >> 20; /* sign extend */ 
2222 
skip_bits1(&s>gb); /* marker */

2223 
} else {

2224 
/* second escape */

2225 
code = get_vlc(&s>gb, &rl>vlc); 
2226 
if (code < 0  code >= rl>n) 
2227 
return 1; 
2228 
run = rl>table_run[code]; 
2229 
level = rl>table_level[code]; 
2230 
last = code >= rl>last; 
2231 
run += rl>max_run[last][level] + 1;

2232 
if (get_bits1(&s>gb))

2233 
level = level; 
2234 
} 
2235 
} else {

2236 
/* first escape */

2237 
code = get_vlc(&s>gb, &rl>vlc); 
2238 
if (code < 0  code >= rl>n) 
2239 
return 1; 
2240 
run = rl>table_run[code]; 
2241 
level = rl>table_level[code]; 
2242 
last = code >= rl>last; 
2243 
level += rl>max_level[last][run]; 
2244 
if (get_bits1(&s>gb))

2245 
level = level; 
2246 
} 
2247 
} else {

2248 
run = rl>table_run[code]; 
2249 
level = rl>table_level[code]; 
2250 
last = code >= rl>last; 
2251 
if (get_bits1(&s>gb))

2252 
level = level; 
2253 
} 
2254 
i += run; 
2255 
if (i >= 64) 
2256 
return 1; 
2257 
j = scan_table[i]; 
2258 
block[j] = level; 
2259 
i++; 
2260 
if (last)

2261 
break;

2262 
} 
2263 
not_coded:

2264 
if (s>mb_intra) {

2265 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
2266 
if (s>ac_pred) {

2267 
i = 64; /* XXX: not optimal */ 
2268 
} 
2269 
} 
2270 
s>block_last_index[n] = i  1;

2271 
return 0; 
2272 
} 
2273  
2274 
/* most is hardcoded. should extend to handle all h263 streams */

2275 
int h263_decode_picture_header(MpegEncContext *s)

2276 
{ 
2277 
int format, width, height;

2278  
2279 
/* picture header */

2280 
if (get_bits(&s>gb, 22) != 0x20) 
2281 
return 1; 
2282 
s>picture_number = get_bits(&s>gb, 8); /* picture timestamp */ 
2283 

2284 
if (get_bits1(&s>gb) != 1) 
2285 
return 1; /* marker */ 
2286 
if (get_bits1(&s>gb) != 0) 
2287 
return 1; /* h263 id */ 
2288 
skip_bits1(&s>gb); /* split screen off */

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

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

2291  
2292 
/* Reset GOB number */

2293 
s>gob_number = 0;

2294 

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

2296  
2297 
if (format != 7 && format != 6) { 
2298 
s>h263_plus = 0;

2299 
/* H.263v1 */

2300 
width = h263_format[format][0];

2301 
height = h263_format[format][1];

2302 
if (!width)

2303 
return 1; 
2304 

2305 
s>width = width; 
2306 
s>height = height; 
2307 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
2308  
2309 
s>unrestricted_mv = get_bits1(&s>gb); 
2310 
s>h263_long_vectors = s>unrestricted_mv; 
2311  
2312 
if (get_bits1(&s>gb) != 0) 
2313 
return 1; /* SAC: off */ 
2314 
if (get_bits1(&s>gb) != 0) { 
2315 
s>mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

2316 
} 
2317 

2318 
if (get_bits1(&s>gb) != 0) 
2319 
return 1; /* not PB frame */ 
2320  
2321 
s>qscale = get_bits(&s>gb, 5);

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

2323 
} else {

2324 
int ufep;

2325 

2326 
/* H.263v2 */

2327 
s>h263_plus = 1;

2328 
ufep = get_bits(&s>gb, 3); /* Update Full Extended PTYPE */ 
2329 

2330 
if (ufep == 1) { 
2331 
/* OPPTYPE */

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

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

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

2338 
} 
2339 
if (get_bits1(&s>gb) != 0) { /* Advanced Intra Coding (AIC) */ 
2340 
s>h263_aic = 1;

2341 
} 
2342 
skip_bits(&s>gb, 7);

2343 
skip_bits(&s>gb, 3); /* Reserved */ 
2344 
} else if (ufep != 0) 
2345 
return 1; 
2346 

2347 
/* MPPTYPE */

2348 
s>pict_type = get_bits(&s>gb, 3) + 1; 
2349 
if (s>pict_type != I_TYPE &&

2350 
s>pict_type != P_TYPE) 
2351 
return 1; 
2352 
skip_bits(&s>gb, 2);

2353 
s>no_rounding = get_bits1(&s>gb); 
2354 
//fprintf(stderr, "\nRTYPE: %d", s>no_rounding);

2355 
skip_bits(&s>gb, 4);

2356 

2357 
/* Get the picture dimensions */

2358 
if (ufep) {

2359 
if (format == 6) { 
2360 
/* Custom Picture Format (CPFMT) */

2361 
skip_bits(&s>gb, 4); /* aspect ratio */ 
2362 
width = (get_bits(&s>gb, 9) + 1) * 4; 
2363 
skip_bits1(&s>gb); 
2364 
height = get_bits(&s>gb, 9) * 4; 
2365 
#ifdef DEBUG

2366 
fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);

2367 
#endif

2368 
} 
2369 
else {

2370 
width = h263_format[format][0];

2371 
height = h263_format[format][1];

2372 
} 
2373 
if ((width == 0)  (height == 0)) 
2374 
return 1; 
2375 
s>width = width; 
2376 
s>height = height; 
2377 
if (s>umvplus_dec) {

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

2379 
} 
2380 
} 
2381 

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

2383 
} 
2384 
/* PEI */

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

2387 
} 
2388 
s>f_code = 1;

2389 
return 0; 
2390 
} 
2391  
2392 
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) 
2393 
{ 
2394 
int i;

2395 
int a= 2<<s>sprite_warping_accuracy; 
2396 
int rho= 3s>sprite_warping_accuracy; 
2397 
int r=16/a; 
2398 
const int vop_ref[4][2]= {{0,0}, {s>width,0}, {0, s>height}, {s>width, s>height}}; // only true for rectangle shapes 
2399 
int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; 
2400 
int sprite_ref[4][2]; 
2401 
int virtual_ref[2][2]; 
2402 
int w2, h2;

2403 
int alpha=0, beta=0; 
2404 
int w= s>width;

2405 
int h= s>height;

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

2407 
for(i=0; i<s>num_sprite_warping_points; i++){ 
2408 
int length;

2409 
int x=0, y=0; 
2410  
2411 
length= get_vlc(&s>gb, &sprite_trajectory); 
2412 
if(length){

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

2415 
if ((x >> (length  1)) == 0) /* if MSB not set it is negative*/ 
2416 
x =  (x ^ ((1 << length)  1)); 
2417 
} 
2418 
if(!(s>divx_version==500 && s>divx_build==413)) skip_bits1(&s>gb); /* marker bit */ 
2419 

2420 
length= get_vlc(&s>gb, &sprite_trajectory); 
2421 
if(length){

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

2424 
if ((y >> (length  1)) == 0) /* if MSB not set it is negative*/ 
2425 
y =  (y ^ ((1 << length)  1)); 
2426 
} 
2427 
skip_bits1(&s>gb); /* marker bit */

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

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

2430 
//x=y=0;

2431 
d[i][0]= x;

2432 
d[i][1]= y;

2433 
} 
2434  
2435 
while((1<<alpha)<w) alpha++; 
2436 
while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' 
2437 
w2= 1<<alpha;

2438 
h2= 1<<beta;

2439  
2440 
// Note, the 4th point isnt used for GMC

2441 
if(s>divx_version==500 && s>divx_build==413){ 
2442 
sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; 
2443 
sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; 
2444 
sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; 
2445 
sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; 
2446 
sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; 
2447 
sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; 
2448 
} else {

2449 
sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); 
2450 
sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); 
2451 
sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); 
2452 
sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); 
2453 
sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); 
2454 
sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); 
2455 
} 
2456 
/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

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

2458 

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

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

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

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

2463 
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2464 
+ RDIV(((w  w2)*(r*sprite_ref[0][0]  16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0]  16*vop_ref[1][0])),w); 
2465 
virtual_ref[0][1]= 16*vop_ref[0][1] 
2466 
+ RDIV(((w  w2)*(r*sprite_ref[0][1]  16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1]  16*vop_ref[1][1])),w); 
2467 
virtual_ref[1][0]= 16*vop_ref[0][0] 
2468 
+ RDIV(((h  h2)*(r*sprite_ref[0][0]  16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0]  16*vop_ref[2][0])),h); 
2469 
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2470 
+ RDIV(((h  h2)*(r*sprite_ref[0][1]  16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1]  16*vop_ref[2][1])),h); 
2471  
2472 
switch(s>num_sprite_warping_points)

2473 
{ 
2474 
case 0: 
2475 
s>sprite_offset[0][0]= 0; 
2476 
s>sprite_offset[0][1]= 0; 
2477 
s>sprite_offset[1][0]= 0; 
2478 
s>sprite_offset[1][1]= 0; 
2479 
s>sprite_delta[0][0][0]= a; 
2480 
s>sprite_delta[0][0][1]= 0; 
2481 
s>sprite_delta[0][1][0]= 0; 
2482 
s>sprite_delta[0][1][1]= a; 
2483 
s>sprite_delta[1][0][0]= a; 
2484 
s>sprite_delta[1][0][1]= 0; 
2485 
s>sprite_delta[1][1][0]= 0; 
2486 
s>sprite_delta[1][1][1]= a; 
2487 
s>sprite_shift[0][0]= 0; 
2488 
s>sprite_shift[0][1]= 0; 
2489 
s>sprite_shift[1][0]= 0; 
2490 
s>sprite_shift[1][1]= 0; 
2491 
break;

2492 
case 1: //GMC only 
2493 
s>sprite_offset[0][0]= sprite_ref[0][0]  a*vop_ref[0][0]; 
2494 
s>sprite_offset[0][1]= sprite_ref[0][1]  a*vop_ref[0][1]; 
2495 
s>sprite_offset[1][0]= ((sprite_ref[0][0]>>1)(sprite_ref[0][0]&1))  a*(vop_ref[0][0]/2); 
2496 
s>sprite_offset[1][1]= ((sprite_ref[0][1]>>1)(sprite_ref[0][1]&1))  a*(vop_ref[0][1]/2); 
2497 
s>sprite_delta[0][0][0]= a; 
2498 
s>sprite_delta[0][0][1]= 0; 
2499 
s>sprite_delta[0][1][0]= 0; 
2500 
s>sprite_delta[0][1][1]= a; 
2501 
s>sprite_delta[1][0][0]= a; 
2502 
s>sprite_delta[1][0][1]= 0; 
2503 
s>sprite_delta[1][1][0]= 0; 
2504 
s>sprite_delta[1][1][1]= a; 
2505 
s>sprite_shift[0][0]= 0; 
2506 
s>sprite_shift[0][1]= 0; 
2507 
s>sprite_shift[1][0]= 0; 
2508 
s>sprite_shift[1][1]= 0; 
2509 
break;

2510 
case 2: 
2511 
case 3: //FIXME 
2512 
s>sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) 
2513 
+ ((r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][0]) 
2514 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(vop_ref[0][1])); 
2515 
s>sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) 
2516 
+ ((r*sprite_ref[0][1] + virtual_ref[0][1])*(vop_ref[0][0]) 
2517 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][1])); 
2518 
s>sprite_offset[1][0]= ((r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][0] + 1) 
2519 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(2*vop_ref[0][1] + 1) 
2520 
+2*w2*r*sprite_ref[0][0]  16*w2); 
2521 
s>sprite_offset[1][1]= ((r*sprite_ref[0][1] + virtual_ref[0][1])*(2*vop_ref[0][0] + 1) 
2522 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][1] + 1) 
2523 
+2*w2*r*sprite_ref[0][1]  16*w2); 
2524 
s>sprite_delta[0][0][0]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
2525 
s>sprite_delta[0][0][1]= ( r*sprite_ref[0][1]  virtual_ref[0][1]); 
2526 
s>sprite_delta[0][1][0]= (r*sprite_ref[0][1] + virtual_ref[0][1]); 
2527 
s>sprite_delta[0][1][1]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
2528 
s>sprite_delta[1][0][0]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
2529 
s>sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1]  virtual_ref[0][1]); 
2530 
s>sprite_delta[1][1][0]= 4*(r*sprite_ref[0][1] + virtual_ref[0][1]); 
2531 
s>sprite_delta[1][1][1]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
2532 
s>sprite_shift[0][0]= alpha+rho; 
2533 
s>sprite_shift[0][1]= alpha+rho; 
2534 
s>sprite_shift[1][0]= alpha+rho+2; 
2535 
s>sprite_shift[1][1]= alpha+rho+2; 
2536 
break;

2537 
// case 3:

2538 
break;

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

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

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

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

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

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

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

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

2548 
/* try to simplify the situation */

2549 
if( s>sprite_delta[0][0][0] == a<<s>sprite_shift[0][0] 
2550 
&& s>sprite_delta[0][0][1] == 0 
2551 
&& s>sprite_delta[0][1][0] == 0 
2552 
&& s>sprite_delta[0][1][1] == a<<s>sprite_shift[0][1] 
2553 
&& s>sprite_delta[1][0][0] == a<<s>sprite_shift[1][0] 
2554 
&& s>sprite_delta[1][0][1] == 0 
2555 
&& s>sprite_delta[1][1][0] == 0 
2556 
&& s>sprite_delta[1][1][1] == a<<s>sprite_shift[1][1]) 
2557 
{ 
2558 
s>sprite_offset[0][0]>>=s>sprite_shift[0][0]; 
2559 
s>sprite_offset[0][1]>>=s>sprite_shift[0][1]; 
2560 
s>sprite_offset[1][0]>>=s>sprite_shift[1][0]; 
2561 
s>sprite_offset[1][1]>>=s>sprite_shift[1][1]; 
2562 
s>sprite_delta[0][0][0]= a; 
2563 
s>sprite_delta[0][0][1]= 0; 
2564 
s>sprite_delta[0][1][0]= 0; 
2565 
s>sprite_delta[0][1][1]= a; 
2566 
s>sprite_delta[1][0][0]= a; 
2567 
s>sprite_delta[1][0][1]= 0; 
2568 
s>sprite_delta[1][1][0]= 0; 
2569 
s>sprite_delta[1][1][1]= a; 
2570 
s>sprite_shift[0][0]= 0; 
2571 
s>sprite_shift[0][1]= 0; 
2572 
s>sprite_shift[1][0]= 0; 
2573 
s>sprite_shift[1][1]= 0; 
2574 
s>real_sprite_warping_points=1;

2575 
} 
2576 
else

2577 
s>real_sprite_warping_points= s>num_sprite_warping_points; 
2578  
2579 
//printf("%d %d %d %d\n", d[0][0], d[0][1], s>sprite_offset[0][0], s>sprite_offset[0][1]);

2580 
} 
2581  
2582 
/* decode mpeg4 VOP header */

2583 
int mpeg4_decode_picture_header(MpegEncContext * s)

2584 
{ 
2585 
int time_incr, startcode, state, v;

2586 
int time_increment;

2587 
int vol_control=1; 
2588  
2589 
redo:

2590 
/* search next start code */

2591 
align_get_bits(&s>gb); 
2592 
state = 0xff;

2593 
for(;;) {

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

2595 
if (state == 0x000001) { 
2596 
state = ((state << 8)  v) & 0xffffff; 
2597 
startcode = state; 
2598 
break;

2599 
} 
2600 
state = ((state << 8)  v) & 0xffffff; 
2601 
if( get_bits_count(&s>gb) > s>gb.size*832){ 
2602 
if(s>gb.size>50){ 
2603 
printf("no VOP startcode found, frame size was=%d\n", s>gb.size);

2604 
return 1; 
2605 
}else{

2606 
printf("frame skip\n");

2607 
return FRAME_SKIPED;

2608 
} 
2609 
} 
2610 
} 
2611 
//printf("startcode %X %d\n", startcode, get_bits_count(&s>gb));

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

2614  
2615 
/* vol header */

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

2618 
if (get_bits1(&s>gb) != 0) { /* is_ol_id */ 
2619 
vo_ver_id = get_bits(&s>gb, 4); /* vo_ver_id */ 
2620 
skip_bits(&s>gb, 3); /* vo_priority */ 
2621 
} else {

2622 
vo_ver_id = 1;

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

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

2626 
if(s>aspect_ratio_info == EXTENDET_PAR){

2627 
skip_bits(&s>gb, 8); //par_width 
2628 
skip_bits(&s>gb, 8); // par_height 
2629 
} 
2630  
2631 
if(vol_control=get_bits1(&s>gb)){ /* vol control parameter */ 
2632 
int chroma_format= get_bits(&s>gb, 2); 
2633 
if(chroma_format!=1){ 
2634 
printf("illegal chroma format\n");

2635 
} 
2636 
s>low_delay= get_bits1(&s>gb); 
2637 
if(get_bits1(&s>gb)){ /* vbv parameters */ 
2638 
printf("vbv parameters not supported\n");

2639 
return 1; 
2640 
} 
2641 
}else{

2642 
s>low_delay=0;

2643 
} 
2644  
2645 
s>shape = get_bits(&s>gb, 2); /* vol shape */ 
2646 
if(s>shape != RECT_SHAPE) printf("only rectangular vol supported\n"); 
2647 
if(s>shape == GRAY_SHAPE && vo_ver_id != 1){ 
2648 
printf("Gray shape not supported\n");

2649 
skip_bits(&s>gb, 4); //video_object_layer_shape_extension 
2650 
} 
2651  
2652 
skip_bits1(&s>gb); /* marker */

2653 

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

2655 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
2656 
if (s>time_increment_bits < 1) 
2657 
s>time_increment_bits = 1;

2658 
skip_bits1(&s>gb); /* marker */

2659  
2660 
if (get_bits1(&s>gb) != 0) { /* fixed_vop_rate */ 
2661 
skip_bits(&s>gb, s>time_increment_bits); 
2662 
} 
2663  
2664 
if (s>shape != BIN_ONLY_SHAPE) {

2665 
if (s>shape == RECT_SHAPE) {

2666 
skip_bits1(&s>gb); /* marker */

2667 
width = get_bits(&s>gb, 13);

2668 
skip_bits1(&s>gb); /* marker */

2669 
height = get_bits(&s>gb, 13);

2670 
skip_bits1(&s>gb); /* marker */

2671 
if(width && height){ /* they should be non zero but who knows ... */ 
2672 
s>width = width; 
2673 
s>height = height; 
2674 
// printf("width/height: %d %d\n", width, height);

2675 
} 
2676 
} 
2677 

2678 
if(get_bits1(&s>gb)) printf("interlaced not supported\n"); /* interlaced */ 
2679 
if(!get_bits1(&s>gb)) printf("OBMC not supported\n"); /* OBMC Disable */ 
2680 
if (vo_ver_id == 1) { 
2681 
s>vol_sprite_usage = get_bits1(&s>gb); /* vol_sprite_usage */

2682 
} else {

2683 
s>vol_sprite_usage = get_bits(&s>gb, 2); /* vol_sprite_usage */ 
2684 
} 
2685 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); 
2686 
if(s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE){

2687 
if(s>vol_sprite_usage==STATIC_SPRITE){

2688 
s>sprite_width = get_bits(&s>gb, 13);

2689 
skip_bits1(&s>gb); /* marker */

2690 
s>sprite_height= get_bits(&s>gb, 13);

2691 
skip_bits1(&s>gb); /* marker */

2692 
s>sprite_left = get_bits(&s>gb, 13);

2693 
skip_bits1(&s>gb); /* marker */

2694 
s>sprite_top = get_bits(&s>gb, 13);

2695 
skip_bits1(&s>gb); /* marker */

2696 
} 
2697 
s>num_sprite_warping_points= get_bits(&s>gb, 6);

2698 
s>sprite_warping_accuracy = get_bits(&s>gb, 2);

2699 
s>sprite_brightness_change= get_bits1(&s>gb); 
2700 
if(s>vol_sprite_usage==STATIC_SPRITE)

2701 
s>low_latency_sprite= get_bits1(&s>gb); 
2702 
} 
2703 
// FIXME sadct disable bit if verid!=1 && shape not rect

2704 

2705 
if (get_bits1(&s>gb) == 1) { /* not_8_bit */ 
2706 
s>quant_precision = get_bits(&s>gb, 4); /* quant_precision */ 
2707 
if(get_bits(&s>gb, 4)!=8) printf("Nbit not supported\n"); /* bits_per_pixel */ 
2708 
if(s>quant_precision!=5) printf("quant precission %d\n", s>quant_precision); 
2709 
} else {

2710 
s>quant_precision = 5;

2711 
} 
2712 

2713 
// FIXME a bunch of grayscale shape things

2714  
2715 
if(get_bits1(&s>gb)){ /* vol_quant_type */ 
2716 
int i, j, v;

2717 
/* load default matrixes */

2718 
for(i=0; i<64; i++){ 
2719 
v= ff_mpeg4_default_intra_matrix[i]; 
2720 
s>intra_matrix[i]= v; 
2721 
s>chroma_intra_matrix[i]= v; 
2722 

2723 
v= ff_mpeg4_default_non_intra_matrix[i]; 
2724 
s>inter_matrix[i]= v; 
2725 
s>chroma_inter_matrix[i]= v; 
2726 
} 
2727  
2728 
/* load custom intra matrix */

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

2730 
for(i=0; i<64; i++){ 
2731 
v= get_bits(&s>gb, 8);

2732 
if(v==0) break; 
2733  
2734 
j= zigzag_direct[i]; 
2735 
s>intra_matrix[j]= v; 
2736 
s>chroma_intra_matrix[j]= v; 
2737 
} 
2738 
} 
2739  
2740 
/* load custom non intra matrix */

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

2742 
for(i=0; i<64; i++){ 
2743 
v= get_bits(&s>gb, 8);

2744 
if(v==0) break; 
2745  
2746 
j= zigzag_direct[i]; 
2747 
s>inter_matrix[j]= v; 
2748 
s>chroma_inter_matrix[j]= v; 
2749 
} 
2750  
2751 
/* replicate last value */

2752 
for(; i<64; i++){ 
2753 
j= zigzag_direct[i]; 
2754 
s>inter_matrix[j]= v; 
2755 
s>chroma_inter_matrix[j]= v; 
2756 
} 
2757 
} 
2758  
2759 
s>dct_unquantize= s>dct_unquantize_mpeg2; 
2760  
2761 
// FIXME a bunch of grayscale shape things

2762 
}else

2763 
s>dct_unquantize= s>dct_unquantize_h263; 
2764  
2765 
if(vo_ver_id != 1) 
2766 
s>quarter_sample= get_bits1(&s>gb); 
2767 
else s>quarter_sample=0; 
2768  
2769 
if(!get_bits1(&s>gb)) printf("Complexity estimation not supported\n"); 
2770  
2771 
s>resync_marker= !get_bits1(&s>gb); /* resync_marker_disabled */

2772  
2773 
s>data_partioning= get_bits1(&s>gb); 
2774 
if(s>data_partioning){

2775 
printf("data partitioning not supported\n");

2776 
skip_bits1(&s>gb); // reversible vlc

2777 
} 
2778 

2779 
if(vo_ver_id != 1) { 
2780 
s>new_pred= get_bits1(&s>gb); 
2781 
if(s>new_pred){

2782 
printf("new pred not supported\n");

2783 
skip_bits(&s>gb, 2); /* requested upstream message type */ 
2784 
skip_bits1(&s>gb); /* newpred segment type */

2785 
} 
2786 
s>reduced_res_vop= get_bits1(&s>gb); 
2787 
if(s>reduced_res_vop) printf("reduced resolution VOP not supported\n"); 
2788 
} 
2789 
else{

2790 
s>new_pred=0;

2791 
s>reduced_res_vop= 0;

2792 
} 
2793  
2794 
s>scalability= get_bits1(&s>gb); 
2795 
if (s>scalability) {

2796 
printf("scalability not supported\n");

2797 
} 
2798 
} 
2799 
//printf("end Data %X %d\n", show_bits(&s>gb, 32), get_bits_count(&s>gb)&0x7);

2800 
goto redo;

2801 
} else if (startcode == 0x1b2) { //userdata 
2802 
char buf[256]; 
2803 
int i;

2804 
int e;

2805 
int ver, build;

2806  
2807 
//printf("user Data %X\n", show_bits(&s>gb, 32));

2808 
buf[0]= show_bits(&s>gb, 8); 
2809 
for(i=1; i<256; i++){ 
2810 
buf[i]= show_bits(&s>gb, 16)&0xFF; 
2811 
if(buf[i]==0) break; 
2812 
skip_bits(&s>gb, 8);

2813 
} 
2814 
buf[255]=0; 
2815 
e=sscanf(buf, "DivX%dBuild%d", &ver, &build);

2816 
if(e!=2) 
2817 
e=sscanf(buf, "DivX%db%d", &ver, &build);

2818 
if(e==2){ 
2819 
s>divx_version= ver; 
2820 
s>divx_build= build; 
2821 
if(s>picture_number==0){ 
2822 
printf("This file was encoded with DivX%d Build%d\n", ver, build);

2823 
if(ver==500 && build==413){ 
2824 
printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");

2825 
#if 0

2826 
}else{

2827 
printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"

2828 
"using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");

2829 
#endif

2830 
} 
2831 
} 
2832 
} 
2833 
//printf("User Data: %s\n", buf);

2834 
goto redo;

2835 
} else if (startcode != 0x1b6) { //VOP 
2836 
goto redo;

2837 
} 
2838  
2839 
s>pict_type = get_bits(&s>gb, 2) + 1; /* pict type: I = 0 , P = 1 */ 
2840 
// printf("pic: %d, qpel:%d\n", s>pict_type, s>quarter_sample);

2841 
time_incr=0;

2842 
while (get_bits1(&s>gb) != 0) 
2843 
time_incr++; 
2844  
2845 
check_marker(&s>gb, "before time_increment");

2846 
time_increment= get_bits(&s>gb, s>time_increment_bits); 
2847 
//printf(" type:%d incr:%d increment:%d\n", s>pict_type, time_incr, time_increment);

2848 
if(s>pict_type!=B_TYPE){

2849 
s>last_time_base= s>time_base; 
2850 
s>time_base+= time_incr; 
2851 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
2852 
s>pp_time= s>time  s>last_non_b_time; 
2853 
s>last_non_b_time= s>time; 
2854 
}else{

2855 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
2856 
s>bp_time= s>last_non_b_time  s>time; 
2857 
if(s>pp_time <=s>bp_time){

2858 
// printf("messed up order, seeking?, skiping current b frame\n");

2859 
return FRAME_SKIPED;

2860 
} 
2861 
} 
2862  
2863 
if(check_marker(&s>gb, "before vop_coded")==0 && s>picture_number==0){ 
2864 
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");

2865 
for(s>time_increment_bits++ ;s>time_increment_bits<16; s>time_increment_bits++){ 
2866 
if(get_bits1(&s>gb)) break; 
2867 
} 
2868 
printf("my guess is %d bits ;)\n",s>time_increment_bits);

2869 
} 
2870 
/* vop coded */

2871 
if (get_bits1(&s>gb) != 1) 
2872 
goto redo;

2873 
//printf("time %d %d %d  %d %d %d\n", s>time_increment_bits, s>time_increment, s>time_base,

2874 
//s>time, s>last_non_b_time[0], s>last_non_b_time[1]);

2875 
if (s>shape != BIN_ONLY_SHAPE && ( s>pict_type == P_TYPE

2876 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE))) { 
2877 
/* rounding type for motion estimation */

2878 
s>no_rounding = get_bits1(&s>gb); 
2879 
} else {

2880 
s>no_rounding = 0;

2881 
} 
2882 
//FIXME reduced res stuff

2883  
2884 
if (s>shape != RECT_SHAPE) {

2885 
if (s>vol_sprite_usage != 1  s>pict_type != I_TYPE) { 
2886 
int width, height, hor_spat_ref, ver_spat_ref;

2887 

2888 
width = get_bits(&s>gb, 13);

2889 
skip_bits1(&s>gb); /* marker */

2890 
height = get_bits(&s>gb, 13);

2891 
skip_bits1(&s>gb); /* marker */

2892 
hor_spat_ref = get_bits(&s>gb, 13); /* hor_spat_ref */ 
2893 
skip_bits1(&s>gb); /* marker */

2894 
ver_spat_ref = get_bits(&s>gb, 13); /* ver_spat_ref */ 
2895 
} 
2896 
skip_bits1(&s>gb); /* change_CR_disable */

2897 

2898 
if (get_bits1(&s>gb) != 0) { 
2899 
skip_bits(&s>gb, 8); /* constant_alpha_value */ 
2900 
} 
2901 
} 
2902 
//FIXME complexity estimation stuff

2903 

2904 
if (s>shape != BIN_ONLY_SHAPE) {

2905 
int t;

2906 
t=get_bits(&s>gb, 3); /* intra dc VLC threshold */ 
2907 
//printf("threshold %d\n", t);

2908 
//FIXME interlaced specific bits

2909 
} 
2910  
2911 
if(s>pict_type == S_TYPE && (s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE)){

2912 
if(s>num_sprite_warping_points){

2913 
mpeg4_decode_sprite_trajectory(s); 
2914 
} 
2915 
if(s>sprite_brightness_change) printf("sprite_brightness_change not supported\n"); 
2916 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); 
2917 
} 
2918  
2919 
if (s>shape != BIN_ONLY_SHAPE) {

2920 
/* note: we do not use quant_precision to avoid problem if no

2921 
MPEG4 vol header as it is found on some old opendivx

2922 
movies */

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

2924 
if(s>qscale==0){ 
2925 
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");

2926 
return 1; // makes no sense to continue, as there is nothing left from the image then 
2927 
} 
2928 

2929 
if (s>pict_type != I_TYPE) {

2930 
s>f_code = get_bits(&s>gb, 3); /* fcode_for */ 
2931 
if(s>f_code==0){ 
2932 
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");

2933 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
2934 
} 
2935 
} 
2936 
if (s>pict_type == B_TYPE) {

2937 
s>b_code = get_bits(&s>gb, 3);

2938 
//printf("bcode %d\n", s>b_code);

2939 
} 
2940 
//printf("quant:%d fcode:%d bcode:%d type:%d\n", s>qscale, s>f_code, s>b_code, s>pict_type);

2941 
if(!s>scalability){

2942 
if (s>shape!=RECT_SHAPE && s>pict_type!=I_TYPE) {

2943 
skip_bits1(&s>gb); // vop shape coding type

2944 
} 
2945 
} 
2946 
} 
2947 
/* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/

2948 
// note we cannot detect divx5 without bframes easyly (allthough its buggy too)

2949 
if(s>vo_type==0 && vol_control==0 && s>divx_version==0){ 
2950 
if(s>picture_number==0) 
2951 
printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) > forcing low_delay flag\n");

2952 
s>low_delay=1;

2953 
} 
2954  
2955 
s>picture_number++; // better than pic number==0 allways ;)

2956 
//printf("done\n");

2957  
2958 
return 0; 
2959 
} 
2960  
2961 
/* don't understand why they choose a different header ! */

2962 
int intel_h263_decode_picture_header(MpegEncContext *s)

2963 
{ 
2964 
int format;

2965  
2966 
/* picture header */

2967 
if (get_bits(&s>gb, 22) != 0x20) 
2968 
return 1; 
2969 
skip_bits(&s>gb, 8); /* picture timestamp */ 
2970  
2971 
if (get_bits1(&s>gb) != 1) 
2972 
return 1; /* marker */ 
2973 
if (get_bits1(&s>gb) != 0) 
2974 
return 1; /* h263 id */ 
2975 
skip_bits1(&s>gb); /* split screen off */

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

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

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

2980 
if (format != 7) 
2981 
return 1; 
2982  
2983 
s>h263_plus = 0;

2984  
2985 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
2986 

2987 
s>unrestricted_mv = get_bits1(&s>gb); 
2988 
s>h263_long_vectors = s>unrestricted_mv; 
2989  
2990 
if (get_bits1(&s>gb) != 0) 
2991 
return 1; /* SAC: off */ 
2992 
if (get_bits1(&s>gb) != 0) 
2993 
return 1; /* advanced prediction mode: off */ 
2994 
if (get_bits1(&s>gb) != 0) 
2995 
return 1; /* not PB frame */ 
2996  
2997 
/* skip unknown header garbage */

2998 
skip_bits(&s>gb, 41);

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

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

3002  
3003 
/* PEI */

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

3006 
} 
3007 
s>f_code = 1;

3008 
return 0; 
3009 
} 
3010 