ffmpeg / libavcodec / h263.c @ eec1c6b9
History  View  Annotate  Download (97.7 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= s>coded_order[i+1].picture[0] + offset; 
363 
int diff= pix_abs16x16(p_pic, b_pic, s>linesize);

364 
if(diff>s>qscale*70){ 
365 
s>mb_skiped=0;

366 
break;

367 
} 
368 
} 
369 
}else

370 
s>mb_skiped=1;

371  
372 
if(s>mb_skiped==1){ 
373 
/* skip macroblock */

374 
put_bits(&s>pb, 1, 1); 
375 
s>misc_bits++; 
376 
s>last_bits++; 
377 
s>skip_count++; 
378 
return;

379 
} 
380 
} 
381 
put_bits(&s>pb, 1, 0); /* mb coded */ 
382 
if(s>mv_type==MV_TYPE_16X16){

383 
cbpc = cbp & 3;

384 
put_bits(&s>pb, 
385 
inter_MCBPC_bits[cbpc], 
386 
inter_MCBPC_code[cbpc]); 
387 
cbpy = cbp >> 2;

388 
cbpy ^= 0xf;

389 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
390 

391 
bits= get_bit_count(&s>pb); 
392 
s>misc_bits+= bits  s>last_bits; 
393 
s>last_bits=bits; 
394  
395 
/* motion vectors: 16x16 mode */

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

397 

398 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
399 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
400 
}else{

401 
cbpc = (cbp & 3)+16; 
402 
put_bits(&s>pb, 
403 
inter_MCBPC_bits[cbpc], 
404 
inter_MCBPC_code[cbpc]); 
405 
cbpy = cbp >> 2;

406 
cbpy ^= 0xf;

407 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
408  
409 
bits= get_bit_count(&s>pb); 
410 
s>misc_bits+= bits  s>last_bits; 
411 
s>last_bits=bits; 
412  
413 
for(i=0; i<4; i++){ 
414 
/* motion vectors: 8x8 mode*/

415 
h263_pred_motion(s, i, &pred_x, &pred_y); 
416  
417 
h263_encode_motion(s, s>motion_val[ s>block_index[i] ][0]  pred_x, s>f_code);

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

419 
} 
420 
} 
421 
bits= get_bit_count(&s>pb); 
422 
s>mv_bits+= bits  s>last_bits; 
423 
s>last_bits=bits; 
424  
425 
/* encode each block */

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

428 
} 
429 
bits= get_bit_count(&s>pb); 
430 
s>p_tex_bits+= bits  s>last_bits; 
431 
s>last_bits=bits; 
432 
s>p_count++; 
433 
} 
434 
} else {

435 
int cbp;

436 
int dc_diff[6]; //dc values with the dc prediction subtracted 
437 
int dir[6]; //prediction direction 
438 
int zigzag_last_index[6]; 
439 
UINT8 *scan_table[6];

440  
441 
for(i=0; i<6; i++){ 
442 
const int level= block[i][0]; 
443 
UINT16 *dc_ptr; 
444  
445 
dc_diff[i]= level  mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); 
446 
if (i < 4) { 
447 
*dc_ptr = level * s>y_dc_scale; 
448 
} else {

449 
*dc_ptr = level * s>c_dc_scale; 
450 
} 
451 
} 
452  
453 
s>ac_pred= decide_ac_pred(s, block, dir); 
454  
455 
if(s>ac_pred){

456 
for(i=0; i<6; i++){ 
457 
UINT8 *st; 
458 
int last_index;

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

471 
for(i=0; i<6; i++) 
472 
scan_table[i]= zigzag_direct; 
473 
} 
474  
475 
/* compute cbp */

476 
cbp = 0;

477 
for (i = 0; i < 6; i++) { 
478 
if (s>block_last_index[i] >= 1) 
479 
cbp = 1 << (5  i); 
480 
} 
481  
482 
cbpc = cbp & 3;

483 
if (s>pict_type == I_TYPE) {

484 
put_bits(&s>pb, 
485 
intra_MCBPC_bits[cbpc], 
486 
intra_MCBPC_code[cbpc]); 
487 
} else {

488 
put_bits(&s>pb, 1, 0); /* mb coded */ 
489 
put_bits(&s>pb, 
490 
inter_MCBPC_bits[cbpc + 4],

491 
inter_MCBPC_code[cbpc + 4]);

492 
} 
493 
put_bits(&s>pb, 1, s>ac_pred);

494 
cbpy = cbp >> 2;

495 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
496  
497 
bits= get_bit_count(&s>pb); 
498 
s>misc_bits+= bits  s>last_bits; 
499 
s>last_bits=bits; 
500  
501 
/* encode each block */

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

512 
if(s>ac_pred){

513 
for(i=0; i<6; i++){ 
514 
int j;

515 
INT16 *ac_val; 
516  
517 
ac_val = s>ac_val[0][0] + s>block_index[i] * 16; 
518  
519 
if(dir[i]){

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

522 
}else{

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

525 
} 
526 
s>block_last_index[i]= zigzag_last_index[i]; 
527 
} 
528 
} 
529 
} 
530 
} 
531  
532 
void h263_encode_mb(MpegEncContext * s,

533 
DCTELEM block[6][64], 
534 
int motion_x, int motion_y) 
535 
{ 
536 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

537 

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

539 
if (!s>mb_intra) {

540 
/* compute cbp */

541 
cbp = 0;

542 
for (i = 0; i < 6; i++) { 
543 
if (s>block_last_index[i] >= 0) 
544 
cbp = 1 << (5  i); 
545 
} 
546 
if ((cbp  motion_x  motion_y) == 0) { 
547 
/* skip macroblock */

548 
put_bits(&s>pb, 1, 1); 
549 
return;

550 
} 
551 
put_bits(&s>pb, 1, 0); /* mb coded */ 
552 
cbpc = cbp & 3;

553 
put_bits(&s>pb, 
554 
inter_MCBPC_bits[cbpc], 
555 
inter_MCBPC_code[cbpc]); 
556 
cbpy = cbp >> 2;

557 
cbpy ^= 0xf;

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

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

562 

563 
if (!s>umvplus) {

564 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
565 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
566 
} 
567 
else {

568 
h263p_encode_umotion(s, motion_x  pred_x); 
569 
h263p_encode_umotion(s, motion_y  pred_y); 
570 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
571 
/* To prevent Start Code emulation */

572 
put_bits(&s>pb,1,1); 
573 
} 
574 
} else {

575 
/* compute cbp */

576 
cbp = 0;

577 
for (i = 0; i < 6; i++) { 
578 
if (s>block_last_index[i] >= 1) 
579 
cbp = 1 << (5  i); 
580 
} 
581  
582 
cbpc = cbp & 3;

583 
if (s>pict_type == I_TYPE) {

584 
put_bits(&s>pb, 
585 
intra_MCBPC_bits[cbpc], 
586 
intra_MCBPC_code[cbpc]); 
587 
} else {

588 
put_bits(&s>pb, 1, 0); /* mb coded */ 
589 
put_bits(&s>pb, 
590 
inter_MCBPC_bits[cbpc + 4],

591 
inter_MCBPC_code[cbpc + 4]);

592 
} 
593 
if (s>h263_pred) {

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

595 
put_bits(&s>pb, 1, 0); /* no ac prediction */ 
596 
} 
597 
cbpy = cbp >> 2;

598 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
599 
} 
600  
601 
/* encode each block */

602 
for (i = 0; i < 6; i++) { 
603 
h263_encode_block(s, block[i], i); 
604 
} 
605 
} 
606  
607 
void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n) 
608 
{ 
609 
int x, y, wrap, a, c, pred_dc, scale, i;

610 
INT16 *dc_val, *ac_val, *ac_val1; 
611  
612 
/* find prediction */

613 
if (n < 4) { 
614 
x = 2 * s>mb_x + 1 + (n & 1); 
615 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
616 
wrap = s>mb_width * 2 + 2; 
617 
dc_val = s>dc_val[0];

618 
ac_val = s>ac_val[0][0]; 
619 
scale = s>y_dc_scale; 
620 
} else {

621 
x = s>mb_x + 1;

622 
y = s>mb_y + 1;

623 
wrap = s>mb_width + 2;

624 
dc_val = s>dc_val[n  4 + 1]; 
625 
ac_val = s>ac_val[n  4 + 1][0]; 
626 
scale = s>c_dc_scale; 
627 
} 
628 

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

630 
ac_val1 = ac_val; 
631 

632 
/* B C

633 
* A X

634 
*/

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

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

637 

638 
pred_dc = 1024;

639 
if (s>ac_pred) {

640 
if (s>h263_aic_dir) {

641 
/* left prediction */

642 
if (a != 1024) { 
643 
ac_val = 16;

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

646 
} 
647 
pred_dc = a; 
648 
} 
649 
} else {

650 
/* top prediction */

651 
if (c != 1024) { 
652 
ac_val = 16 * wrap;

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

655 
} 
656 
pred_dc = c; 
657 
} 
658 
} 
659 
} else {

660 
/* just DC prediction */

661 
if (a != 1024 && c != 1024) 
662 
pred_dc = (a + c) >> 1;

663 
else if (a != 1024) 
664 
pred_dc = a; 
665 
else

666 
pred_dc = c; 
667 
} 
668 

669 
/* we assume pred is positive */

670 
block[0]=block[0]*scale + pred_dc; 
671 

672 
if (block[0] < 0) 
673 
block[0] = 0; 
674 
else if (!(block[0] & 1)) 
675 
block[0]++;

676 

677 
/* Update AC/DC tables */

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

679 

680 
/* left copy */

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

683 
/* top copy */

684 
for(i=1;i<8;i++) 
685 
ac_val1[8 + i] = block[block_permute_op(i)];

686 
} 
687  
688 
INT16 *h263_pred_motion(MpegEncContext * s, int block,

689 
int *px, int *py) 
690 
{ 
691 
int xy, wrap;

692 
INT16 *A, *B, *C, *mot_val; 
693 
static const int off[4]= {2, 1, 1, 1}; 
694  
695 
wrap = s>block_wrap[0];

696 
xy = s>block_index[block]; 
697  
698 
mot_val = s>motion_val[xy]; 
699  
700 
/* special case for first line */

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

703 
*px = A[0];

704 
*py = A[1];

705 
} else {

706 
A = s>motion_val[xy  1];

707 
B = s>motion_val[xy  wrap]; 
708 
C = s>motion_val[xy + off[block]  wrap]; 
709 
*px = mid_pred(A[0], B[0], C[0]); 
710 
*py = mid_pred(A[1], B[1], C[1]); 
711 
} 
712 
return mot_val;

713 
} 
714  
715 
static void h263_encode_motion(MpegEncContext * s, int val, int f_code) 
716 
{ 
717 
int range, l, m, bit_size, sign, code, bits;

718  
719 
if (val == 0) { 
720 
/* zero vector */

721 
code = 0;

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

724 
bit_size = f_code  1;

725 
range = 1 << bit_size;

726 
/* modulo encoding */

727 
l = range * 32;

728 
m = 2 * l;

729 
if (val < l) {

730 
val += m; 
731 
} else if (val >= l) { 
732 
val = m; 
733 
} 
734  
735 
if (val >= 0) { 
736 
sign = 0;

737 
} else {

738 
val = val; 
739 
sign = 1;

740 
} 
741 
val; 
742 
code = (val >> bit_size) + 1;

743 
bits = val & (range  1);

744  
745 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
746 
if (bit_size > 0) { 
747 
put_bits(&s>pb, bit_size, bits); 
748 
} 
749 
} 
750 
} 
751  
752 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

753 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
754 
{ 
755 
short sval = 0; 
756 
short i = 0; 
757 
short n_bits = 0; 
758 
short temp_val;

759 
int code = 0; 
760 
int tcode;

761 

762 
if ( val == 0) 
763 
put_bits(&s>pb, 1, 1); 
764 
else if (val == 1) 
765 
put_bits(&s>pb, 3, 0); 
766 
else if (val == 1) 
767 
put_bits(&s>pb, 3, 2); 
768 
else {

769 

770 
sval = ((val < 0) ? (short)(val):(short)val); 
771 
temp_val = sval; 
772 

773 
while (temp_val != 0) { 
774 
temp_val = temp_val >> 1;

775 
n_bits++; 
776 
} 
777 

778 
i = n_bits  1;

779 
while (i > 0) { 
780 
tcode = (sval & (1 << (i1))) >> (i1); 
781 
tcode = (tcode << 1)  1; 
782 
code = (code << 2)  tcode;

783 
i; 
784 
} 
785 
code = ((code << 1)  (val < 0)) << 1; 
786 
put_bits(&s>pb, (2*n_bits)+1, code); 
787 
//printf("\nVal = %d\tCode = %d", sval, code);

788 
} 
789 
} 
790  
791 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
792 
{ 
793 
int f_code;

794 
int mv;

795 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
796 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

797 
int len;

798  
799 
if(mv==0) len= mvtab[0][1]; 
800 
else{

801 
int val, bit_size, range, code;

802  
803 
bit_size = s>f_code  1;

804 
range = 1 << bit_size;

805  
806 
val=mv; 
807 
if (val < 0) 
808 
val = val; 
809 
val; 
810 
code = (val >> bit_size) + 1;

811 
if(code<33){ 
812 
len= mvtab[code][1] + 1 + bit_size; 
813 
}else{

814 
len= mvtab[32][1] + 2 + bit_size; 
815 
} 
816 
} 
817  
818 
mv_penalty[f_code][mv+MAX_MV]= len; 
819 
} 
820 
} 
821  
822 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
823 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
824 
fcode_tab[mv+MAX_MV]= f_code; 
825 
} 
826 
} 
827  
828 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
829 
umv_fcode_tab[mv]= 1;

830 
} 
831 
} 
832  
833 
static void init_uni_dc_tab() 
834 
{ 
835 
int level, uni_code, uni_len;

836  
837 
for(level=256; level<256; level++){ 
838 
int size, v, l;

839 
/* find number of bits */

840 
size = 0;

841 
v = abs(level); 
842 
while (v) {

843 
v >>= 1;

844 
size++; 
845 
} 
846  
847 
if (level < 0) 
848 
l= (level) ^ ((1 << size)  1); 
849 
else

850 
l= level; 
851  
852 
/* luminance */

853 
uni_code= DCtab_lum[size][0];

854 
uni_len = DCtab_lum[size][1];

855  
856 
if (size > 0) { 
857 
uni_code<<=size; uni_code=l; 
858 
uni_len+=size; 
859 
if (size > 8){ 
860 
uni_code<<=1; uni_code=1; 
861 
uni_len++; 
862 
} 
863 
} 
864 
uni_DCtab_lum[level+256][0]= uni_code; 
865 
uni_DCtab_lum[level+256][1]= uni_len; 
866  
867 
/* chrominance */

868 
uni_code= DCtab_chrom[size][0];

869 
uni_len = DCtab_chrom[size][1];

870 

871 
if (size > 0) { 
872 
uni_code<<=size; uni_code=l; 
873 
uni_len+=size; 
874 
if (size > 8){ 
875 
uni_code<<=1; uni_code=1; 
876 
uni_len++; 
877 
} 
878 
} 
879 
uni_DCtab_chrom[level+256][0]= uni_code; 
880 
uni_DCtab_chrom[level+256][1]= uni_len; 
881  
882 
} 
883 
} 
884  
885 
void h263_encode_init(MpegEncContext *s)

886 
{ 
887 
static int done = 0; 
888  
889 
if (!done) {

890 
done = 1;

891  
892 
init_uni_dc_tab(); 
893  
894 
init_rl(&rl_inter); 
895 
init_rl(&rl_intra); 
896  
897 
init_mv_penalty_and_fcode(s); 
898 
} 
899 
s>mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

900 

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

902 
if(s>h263_plus) s>fcode_tab= umv_fcode_tab;

903 
else if(s>h263_pred && !s>h263_msmpeg4) s>fcode_tab= fcode_tab; 
904 
} 
905  
906 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
907 
{ 
908 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

909 
int code;

910 
RLTable *rl = &rl_inter; 
911  
912 
if (s>mb_intra) {

913 
/* DC coef */

914 
level = block[0];

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

916 
if (level > 254) { 
917 
level = 254;

918 
block[0] = 254; 
919 
} 
920 
/* 0 cannot be represented also */

921 
else if (!level) { 
922 
level = 1;

923 
block[0] = 1; 
924 
} 
925 
if (level == 128) 
926 
put_bits(&s>pb, 8, 0xff); 
927 
else

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

930 
} else {

931 
i = 0;

932 
} 
933  
934 
/* AC coefs */

935 
last_index = s>block_last_index[n]; 
936 
last_non_zero = i  1;

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

938 
j = zigzag_direct[i]; 
939 
level = block[j]; 
940 
if (level) {

941 
run = i  last_non_zero  1;

942 
last = (i == last_index); 
943 
sign = 0;

944 
slevel = level; 
945 
if (level < 0) { 
946 
sign = 1;

947 
level = level; 
948 
} 
949 
code = get_rl_index(rl, last, run, level); 
950 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
951 
if (code == rl>n) {

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

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

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

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

957 
} 
958 
last_non_zero = i; 
959 
} 
960 
} 
961 
} 
962  
963 
/***************************************************/

964  
965 
static void mpeg4_stuffing(PutBitContext * pbc) 
966 
{ 
967 
int length;

968 
put_bits(pbc, 1, 0); 
969 
length= (get_bit_count(pbc))&7;

970 
put_bits(pbc, length, (1<<length)1); 
971 
} 
972  
973 
static void put_string(PutBitContext * pbc, char *s) 
974 
{ 
975 
while(*s){

976 
put_bits(pbc, 8, *s);

977 
s++; 
978 
} 
979 
put_bits(pbc, 8, 0); 
980 
} 
981  
982 
/* must be called before writing the header */

983 
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ 
984 
int time_div, time_mod;

985  
986 
if(s>pict_type==I_TYPE){ //we will encode a vol header 
987 
s>time_increment_resolution= s>frame_rate/ff_gcd(s>frame_rate, FRAME_RATE_BASE); 
988 
if(s>time_increment_resolution>=256*256) s>time_increment_resolution= 256*128; 
989  
990 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
991 
} 
992  
993 
s>time= picture_number*(int64_t)FRAME_RATE_BASE*s>time_increment_resolution/s>frame_rate; 
994 
time_div= s>time/s>time_increment_resolution; 
995 
time_mod= s>time%s>time_increment_resolution; 
996  
997 
if(s>pict_type==B_TYPE){

998 
s>bp_time= s>last_non_b_time  s>time; 
999 
}else{

1000 
s>last_time_base= s>time_base; 
1001 
s>time_base= time_div; 
1002 
s>pp_time= s>time  s>last_non_b_time; 
1003 
s>last_non_b_time= s>time; 
1004 
} 
1005 
} 
1006  
1007 
static void mpeg4_encode_vol_header(MpegEncContext * s) 
1008 
{ 
1009 
int vo_ver_id=1; //must be 2 if we want GMC or qpel 
1010 
char buf[255]; 
1011 

1012 
if(get_bit_count(&s>pb)!=0) mpeg4_stuffing(&s>pb); 
1013 
put_bits(&s>pb, 16, 0); 
1014 
put_bits(&s>pb, 16, 0x100); /* video obj */ 
1015 
put_bits(&s>pb, 16, 0); 
1016 
put_bits(&s>pb, 16, 0x120); /* video obj layer */ 
1017  
1018 
put_bits(&s>pb, 1, 0); /* random access vol */ 
1019 
put_bits(&s>pb, 8, 1); /* video obj type indication= simple obj */ 
1020 
put_bits(&s>pb, 1, 1); /* is obj layer id= yes */ 
1021 
put_bits(&s>pb, 4, vo_ver_id); /* is obj layer ver id */ 
1022 
put_bits(&s>pb, 3, 1); /* is obj layer priority */ 
1023 
if(s>aspect_ratio_info)

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

1026 
put_bits(&s>pb, 4, 1); /* aspect ratio info= sqare pixel */ 
1027 
put_bits(&s>pb, 1, 0); /* vol control parameters= no */ 
1028 
put_bits(&s>pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 
1029 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1030 

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

1032 
if (s>time_increment_bits < 1) 
1033 
s>time_increment_bits = 1;

1034 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1035 
put_bits(&s>pb, 1, 0); /* fixed vop rate=no */ 
1036 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1037 
put_bits(&s>pb, 13, s>width); /* vol width */ 
1038 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1039 
put_bits(&s>pb, 13, s>height); /* vol height */ 
1040 
put_bits(&s>pb, 1, 1); /* marker bit */ 
1041 
put_bits(&s>pb, 1, 0); /* interlace */ 
1042 
put_bits(&s>pb, 1, 1); /* obmc disable */ 
1043 
if (vo_ver_id == 1) { 
1044 
put_bits(&s>pb, 1, s>vol_sprite_usage=0); /* sprite enable */ 
1045 
}else{ /* vo_ver_id == 2 */ 
1046 
put_bits(&s>pb, 2, s>vol_sprite_usage=0); /* sprite enable */ 
1047 
} 
1048 
put_bits(&s>pb, 1, 0); /* not 8 bit */ 
1049 
put_bits(&s>pb, 1, 0); /* quant type= h263 style*/ 
1050 
if (vo_ver_id != 1) 
1051 
put_bits(&s>pb, 1, s>quarter_sample=0); 
1052 
put_bits(&s>pb, 1, 1); /* complexity estimation disable */ 
1053 
put_bits(&s>pb, 1, 1); /* resync marker disable */ 
1054 
put_bits(&s>pb, 1, 0); /* data partitioned */ 
1055 
if (vo_ver_id != 1){ 
1056 
put_bits(&s>pb, 1, 0); /* newpred */ 
1057 
put_bits(&s>pb, 1, 0); /* reduced res vop */ 
1058 
} 
1059 
put_bits(&s>pb, 1, 0); /* scalability */ 
1060  
1061 
mpeg4_stuffing(&s>pb); 
1062 
put_bits(&s>pb, 16, 0); 
1063 
put_bits(&s>pb, 16, 0x1B2); /* user_data */ 
1064 
sprintf(buf, "FFmpeg v%s / libavcodec build: %s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);

1065 
put_string(&s>pb, buf); 
1066  
1067 
s>no_rounding = 0;

1068 
} 
1069  
1070 
/* write mpeg4 VOP header */

1071 
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
1072 
{ 
1073 
int time_incr;

1074 
int time_div, time_mod;

1075 

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

1077 

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

1079 

1080 
if(get_bit_count(&s>pb)!=0) mpeg4_stuffing(&s>pb); 
1081 
put_bits(&s>pb, 16, 0); /* vop header */ 
1082 
put_bits(&s>pb, 16, 0x1B6); /* vop header */ 
1083 
put_bits(&s>pb, 2, s>pict_type  1); /* pict type: I = 0 , P = 1 */ 
1084  
1085 
time_div= s>time/s>time_increment_resolution; 
1086 
time_mod= s>time%s>time_increment_resolution; 
1087 
time_incr= time_div  s>last_time_base; 
1088 
while(time_incr)

1089 
put_bits(&s>pb, 1, 1); 
1090 

1091 
put_bits(&s>pb, 1, 0); 
1092  
1093 
put_bits(&s>pb, 1, 1); /* marker */ 
1094 
put_bits(&s>pb, s>time_increment_bits, time_mod); /* time increment */

1095 
put_bits(&s>pb, 1, 1); /* marker */ 
1096 
put_bits(&s>pb, 1, 1); /* vop coded */ 
1097 
if ( s>pict_type == P_TYPE

1098 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE)) { 
1099 
s>no_rounding ^= 1;

1100 
put_bits(&s>pb, 1, s>no_rounding); /* rounding type */ 
1101 
} 
1102 
put_bits(&s>pb, 3, 0); /* intra dc VLC threshold */ 
1103 
//FIXME sprite stuff

1104  
1105 
put_bits(&s>pb, 5, s>qscale);

1106  
1107 
if (s>pict_type != I_TYPE)

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

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

1112 
} 
1113  
1114 
void h263_dc_scale(MpegEncContext * s)

1115 
{ 
1116 
#if 1 
1117 
const static UINT8 y_tab[32]={ 
1118 
// 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

1119 
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 
1120 
}; 
1121 
const static UINT8 c_tab[32]={ 
1122 
// 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

1123 
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 
1124 
}; 
1125 
s>y_dc_scale = y_tab[s>qscale]; 
1126 
s>c_dc_scale = c_tab[s>qscale]; 
1127 
#else

1128 
int quant;

1129 
quant = s>qscale; 
1130 
/* luminance */

1131 
if (quant < 5) 
1132 
s>y_dc_scale = 8;

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

1135 
else if (quant > 8 && quant < 25) 
1136 
s>y_dc_scale = (quant + 8);

1137 
else

1138 
s>y_dc_scale = (2 * quant  16); 
1139 
/* chrominance */

1140 
if (quant < 5) 
1141 
s>c_dc_scale = 8;

1142 
else if (quant > 4 && quant < 25) 
1143 
s>c_dc_scale = ((quant + 13) / 2); 
1144 
else

1145 
s>c_dc_scale = (quant  6);

1146 
#endif

1147 
} 
1148  
1149 
static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) 
1150 
{ 
1151 
int a, b, c, wrap, pred, scale;

1152 
UINT16 *dc_val; 
1153 
int dummy;

1154  
1155 
/* find prediction */

1156 
if (n < 4) { 
1157 
scale = s>y_dc_scale; 
1158 
} else {

1159 
scale = s>c_dc_scale; 
1160 
} 
1161 
wrap= s>block_wrap[n]; 
1162 
dc_val = s>dc_val[0] + s>block_index[n];

1163  
1164 
/* B C

1165 
* A X

1166 
*/

1167 
a = dc_val[  1];

1168 
b = dc_val[  1  wrap];

1169 
c = dc_val[  wrap]; 
1170  
1171 
if (abs(a  b) < abs(b  c)) {

1172 
pred = c; 
1173 
*dir_ptr = 1; /* top */ 
1174 
} else {

1175 
pred = a; 
1176 
*dir_ptr = 0; /* left */ 
1177 
} 
1178 
/* we assume pred is positive */

1179 
#ifdef ARCH_X86

1180 
asm volatile ( 
1181 
"xorl %%edx, %%edx \n\t"

1182 
"mul %%ecx \n\t"

1183 
: "=d" (pred), "=a"(dummy) 
1184 
: "a" (pred + (scale >> 1)), "c" (inverse[scale]) 
1185 
); 
1186 
#else

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

1188 
#endif

1189  
1190 
/* prepare address for prediction update */

1191 
*dc_val_ptr = &dc_val[0];

1192  
1193 
return pred;

1194 
} 
1195  
1196 
void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1197 
int dir)

1198 
{ 
1199 
int i;

1200 
INT16 *ac_val, *ac_val1; 
1201  
1202 
/* find prediction */

1203 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1204 
ac_val1 = ac_val; 
1205 
if (s>ac_pred) {

1206 
if (dir == 0) { 
1207 
/* left prediction */

1208 
ac_val = 16;

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

1211 
} 
1212 
} else {

1213 
/* top prediction */

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

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

1217 
} 
1218 
} 
1219 
} 
1220 
/* left copy */

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

1223 
/* top copy */

1224 
for(i=1;i<8;i++) 
1225 
ac_val1[8 + i] = block[block_permute_op(i)];

1226 
} 
1227  
1228 
static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, 
1229 
int dir)

1230 
{ 
1231 
int i;

1232 
INT16 *ac_val; 
1233  
1234 
/* find prediction */

1235 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1236 

1237 
if (dir == 0) { 
1238 
/* left prediction */

1239 
ac_val = 16;

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

1242 
} 
1243 
} else {

1244 
/* top prediction */

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

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

1248 
} 
1249 
} 
1250 
} 
1251  
1252 
static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n) 
1253 
{ 
1254 
#if 1 
1255 
level+=256;

1256 
if (n < 4) { 
1257 
/* luminance */

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

1260 
/* chrominance */

1261 
put_bits(&s>pb, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]); 
1262 
} 
1263 
#else

1264 
int size, v;

1265 
/* find number of bits */

1266 
size = 0;

1267 
v = abs(level); 
1268 
while (v) {

1269 
v >>= 1;

1270 
size++; 
1271 
} 
1272  
1273 
if (n < 4) { 
1274 
/* luminance */

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

1277 
/* chrominance */

1278 
put_bits(&s>pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 
1279 
} 
1280  
1281 
/* encode remaining bits */

1282 
if (size > 0) { 
1283 
if (level < 0) 
1284 
level = (level) ^ ((1 << size)  1); 
1285 
put_bits(&s>pb, size, level); 
1286 
if (size > 8) 
1287 
put_bits(&s>pb, 1, 1); 
1288 
} 
1289 
#endif

1290 
} 
1291  
1292 
static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table) 
1293 
{ 
1294 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel;

1295 
int code;

1296 
const RLTable *rl;

1297  
1298 
if (s>mb_intra) {

1299 
/* mpeg4 based DC predictor */

1300 
mpeg4_encode_dc(s, intra_dc, n); 
1301 
i = 1;

1302 
rl = &rl_intra; 
1303 
} else {

1304 
i = 0;

1305 
rl = &rl_inter; 
1306 
} 
1307  
1308 
/* AC coefs */

1309 
last_index = s>block_last_index[n]; 
1310 
last_non_zero = i  1;

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

1312 
j = scan_table[i]; 
1313 
level = block[j]; 
1314 
if (level) {

1315 
run = i  last_non_zero  1;

1316 
last = (i == last_index); 
1317 
sign = 0;

1318 
slevel = level; 
1319 
if (level < 0) { 
1320 
sign = 1;

1321 
level = level; 
1322 
} 
1323 
code = get_rl_index(rl, last, run, level); 
1324 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1325 
if (code == rl>n) {

1326 
int level1, run1;

1327 
level1 = level  rl>max_level[last][run]; 
1328 
if (level1 < 1) 
1329 
goto esc2;

1330 
code = get_rl_index(rl, last, run, level1); 
1331 
if (code == rl>n) {

1332 
esc2:

1333 
put_bits(&s>pb, 1, 1); 
1334 
if (level > MAX_LEVEL)

1335 
goto esc3;

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

1337 
if (run1 < 0) 
1338 
goto esc3;

1339 
code = get_rl_index(rl, last, run1, level); 
1340 
if (code == rl>n) {

1341 
esc3:

1342 
/* third escape */

1343 
put_bits(&s>pb, 1, 1); 
1344 
put_bits(&s>pb, 1, last);

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

1346 
put_bits(&s>pb, 1, 1); 
1347 
put_bits(&s>pb, 12, slevel & 0xfff); 
1348 
put_bits(&s>pb, 1, 1); 
1349 
} else {

1350 
/* second escape */

1351 
put_bits(&s>pb, 1, 0); 
1352 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1353 
put_bits(&s>pb, 1, sign);

1354 
} 
1355 
} else {

1356 
/* first escape */

1357 
put_bits(&s>pb, 1, 0); 
1358 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1359 
put_bits(&s>pb, 1, sign);

1360 
} 
1361 
} else {

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

1363 
} 
1364 
last_non_zero = i; 
1365 
} 
1366 
} 
1367 
} 
1368  
1369  
1370  
1371 
/***********************************************/

1372 
/* decoding */

1373  
1374 
static VLC intra_MCBPC_vlc;

1375 
static VLC inter_MCBPC_vlc;

1376 
static VLC cbpy_vlc;

1377 
static VLC mv_vlc;

1378 
static VLC dc_lum, dc_chrom;

1379 
static VLC sprite_trajectory;

1380 
static VLC mb_type_b_vlc;

1381  
1382 
void init_rl(RLTable *rl)

1383 
{ 
1384 
INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; 
1385 
UINT8 index_run[MAX_RUN+1];

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

1387  
1388 
/* compute max_level[], max_run[] and index_run[] */

1389 
for(last=0;last<2;last++) { 
1390 
if (last == 0) { 
1391 
start = 0;

1392 
end = rl>last; 
1393 
} else {

1394 
start = rl>last; 
1395 
end = rl>n; 
1396 
} 
1397  
1398 
memset(max_level, 0, MAX_RUN + 1); 
1399 
memset(max_run, 0, MAX_LEVEL + 1); 
1400 
memset(index_run, rl>n, MAX_RUN + 1);

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

1402 
run = rl>table_run[i]; 
1403 
level = rl>table_level[i]; 
1404 
if (index_run[run] == rl>n)

1405 
index_run[run] = i; 
1406 
if (level > max_level[run])

1407 
max_level[run] = level; 
1408 
if (run > max_run[level])

1409 
max_run[level] = run; 
1410 
} 
1411 
rl>max_level[last] = malloc(MAX_RUN + 1);

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

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

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

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

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

1417 
} 
1418 
} 
1419  
1420 
void init_vlc_rl(RLTable *rl)

1421 
{ 
1422 
init_vlc(&rl>vlc, 9, rl>n + 1, 
1423 
&rl>table_vlc[0][1], 4, 2, 
1424 
&rl>table_vlc[0][0], 4, 2); 
1425 
} 
1426  
1427 
/* init vlcs */

1428  
1429 
/* XXX: find a better solution to handle static init */

1430 
void h263_decode_init_vlc(MpegEncContext *s)

1431 
{ 
1432 
static int done = 0; 
1433  
1434 
if (!done) {

1435 
done = 1;

1436  
1437 
init_vlc(&intra_MCBPC_vlc, 6, 8, 
1438 
intra_MCBPC_bits, 1, 1, 
1439 
intra_MCBPC_code, 1, 1); 
1440 
init_vlc(&inter_MCBPC_vlc, 9, 25, 
1441 
inter_MCBPC_bits, 1, 1, 
1442 
inter_MCBPC_code, 1, 1); 
1443 
init_vlc(&cbpy_vlc, 6, 16, 
1444 
&cbpy_tab[0][1], 2, 1, 
1445 
&cbpy_tab[0][0], 2, 1); 
1446 
init_vlc(&mv_vlc, 9, 33, 
1447 
&mvtab[0][1], 2, 1, 
1448 
&mvtab[0][0], 2, 1); 
1449 
init_rl(&rl_inter); 
1450 
init_rl(&rl_intra); 
1451 
init_rl(&rl_intra_aic); 
1452 
init_vlc_rl(&rl_inter); 
1453 
init_vlc_rl(&rl_intra); 
1454 
init_vlc_rl(&rl_intra_aic); 
1455 
init_vlc(&dc_lum, 9, 13, 
1456 
&DCtab_lum[0][1], 2, 1, 
1457 
&DCtab_lum[0][0], 2, 1); 
1458 
init_vlc(&dc_chrom, 9, 13, 
1459 
&DCtab_chrom[0][1], 2, 1, 
1460 
&DCtab_chrom[0][0], 2, 1); 
1461 
init_vlc(&sprite_trajectory, 9, 15, 
1462 
&sprite_trajectory_tab[0][1], 4, 2, 
1463 
&sprite_trajectory_tab[0][0], 4, 2); 
1464 
init_vlc(&mb_type_b_vlc, 4, 4, 
1465 
&mb_type_b_tab[0][1], 2, 1, 
1466 
&mb_type_b_tab[0][0], 2, 1); 
1467 
} 
1468 
} 
1469  
1470 
int h263_decode_gob_header(MpegEncContext *s)

1471 
{ 
1472 
unsigned int val, gfid; 
1473 

1474 
/* Check for GOB Start Code */

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

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

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

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

1482 
#endif

1483 
s>gob_number = get_bits(&s>gb, 5); /* GN */ 
1484 
gfid = get_bits(&s>gb, 2); /* GFID */ 
1485 
s>qscale = get_bits(&s>gb, 5); /* GQUANT */ 
1486 
#ifdef DEBUG

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

1488 
#endif

1489 
return 1; 
1490 
} 
1491 
return 0; 
1492 

1493 
} 
1494  
1495 
static inline void memsetw(short *tab, int val, int n) 
1496 
{ 
1497 
int i;

1498 
for(i=0;i<n;i++) 
1499 
tab[i] = val; 
1500 
} 
1501  
1502 
static int mpeg4_resync(MpegEncContext *s) 
1503 
{ 
1504 
int state, v, bits;

1505 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
1506 
int header_extension=0, mb_num; 
1507 
int c_wrap, c_xy, l_wrap, l_xy;

1508 
int time_increment;

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

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

1511  
1512 
if( get_bits_count(&s>gb) > s>gb.size*832) 
1513 
return 0; 
1514  
1515 
align_get_bits(&s>gb); 
1516 
state = 0xff;

1517 
for(;;) {

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

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

1520 
state = ((state << 8)  v) & 0xffff; 
1521 
if (state == 0) break; 
1522 
if( get_bits_count(&s>gb) > s>gb.size*832){ 
1523 
printf("resync failed\n");

1524 
return 1; 
1525 
} 
1526 
} 
1527 
//printf("%X\n", show_bits(&s>gb, 24));

1528 
bits=0;

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

1532 
//FIXME check bits for Bframess

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

1534  
1535 
if(s>shape != RECT_SHAPE){

1536 
header_extension= get_bits1(&s>gb); 
1537 
//FIXME more stuff here

1538 
} 
1539  
1540 
mb_num= get_bits(&s>gb, mb_num_bits); 
1541 
if(mb_num != s>mb_x + s>mb_y*s>mb_width){

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

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

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

1545 
//FIXME many vars are wrong now

1546 
} 
1547  
1548 
if(s>shape != BIN_ONLY_SHAPE){

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

1550 
h263_dc_scale(s); 
1551 
} 
1552  
1553 
if(s>shape == RECT_SHAPE){

1554 
header_extension= get_bits1(&s>gb); 
1555 
} 
1556 
if(header_extension){

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

1559 
while (get_bits1(&s>gb) != 0) 
1560 
time_incr++; 
1561  
1562 
check_marker(&s>gb, "before time_increment in video packed header");

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

1565 
s>last_time_base= s>time_base; 
1566 
s>time_base+= time_incr; 
1567 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
1568 
s>pp_time= s>time  s>last_non_b_time; 
1569 
s>last_non_b_time= s>time; 
1570 
}else{

1571 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
1572 
s>bp_time= s>last_non_b_time  s>time; 
1573 
} 
1574 
check_marker(&s>gb, "before vop_coding_type in video packed header");

1575 

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

1578  
1579 
if(s>shape != BIN_ONLY_SHAPE){

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

1583 
mpeg4_decode_sprite_trajectory(s); 
1584 
} 
1585  
1586 
//FIXME reduced res stuff here

1587 

1588 
if (s>pict_type != I_TYPE) {

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

1592 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
1593 
} 
1594 
} 
1595 
if (s>pict_type == B_TYPE) {

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

1597 
} 
1598 
} 
1599  
1600 
} 
1601 
//FIXME newpred stuff

1602  
1603 
l_wrap= s>block_wrap[0];

1604 
l_xy= s>mb_y*l_wrap*2;

1605 
c_wrap= s>block_wrap[4];

1606 
c_xy= s>mb_y*c_wrap; 
1607  
1608 
/* clean DC */

1609 
memsetw(s>dc_val[0] + l_xy, 1024, l_wrap*3); 
1610 
memsetw(s>dc_val[1] + c_xy, 1024, c_wrap*2); 
1611 
memsetw(s>dc_val[2] + c_xy, 1024, c_wrap*2); 
1612  
1613 
/* clean AC */

1614 
memset(s>ac_val[0] + l_xy, 0, l_wrap*3*16*sizeof(INT16)); 
1615 
memset(s>ac_val[1] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); 
1616 
memset(s>ac_val[2] + c_xy, 0, c_wrap*2*16*sizeof(INT16)); 
1617  
1618 
/* clean MV */

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

1621 
s>resync_x_pos= s>mb_x; 
1622 
s>first_slice_line=1;

1623  
1624 
return 0; 
1625 
} 
1626  
1627 
int h263_decode_mb(MpegEncContext *s,

1628 
DCTELEM block[6][64]) 
1629 
{ 
1630 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

1631 
INT16 *mot_val; 
1632 
static INT8 quant_tab[4] = { 1, 2, 1, 2 }; 
1633  
1634 
if(s>resync_marker){

1635 
if( s>resync_x_pos == s>mb_x+1 
1636 
 s>resync_x_pos == s>mb_x){ 
1637 
/* f*ck mpeg4

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

1639 
if(s>resync_x_pos == s>mb_x+1 && s>mb_x==0){ 
1640 
int xy= s>block_index[0]  s>block_wrap[0]; 
1641 
s>motion_val[xy][0]= s>motion_val[xy+2][0]; 
1642 
s>motion_val[xy][1]= s>motion_val[xy+2][1]; 
1643 
} 
1644  
1645 
s>first_slice_line=0;

1646 
s>resync_x_pos=0; // isnt needed but for cleanness sake ;) 
1647 
} 
1648  
1649 
if(show_aligned_bits(&s>gb, 1, 16) == 0){ 
1650 
if( mpeg4_resync(s) < 0 ) return 1; 
1651 

1652 
} 
1653 
} 
1654  
1655 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

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

1657 
/* skip mb */

1658 
s>mb_intra = 0;

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

1661 
s>mv_dir = MV_DIR_FORWARD; 
1662 
s>mv_type = MV_TYPE_16X16; 
1663 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

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

1666  
1667 
s>mcsel=1;

1668 
if(s>divx_version==500 && s>divx_build==413){ 
1669 
s>mv[0][0][0] = s>sprite_offset[0][0] / (1<<(as>quarter_sample)); 
1670 
s>mv[0][0][1] = s>sprite_offset[0][1] / (1<<(as>quarter_sample)); 
1671 
}else{

1672 
s>mv[0][0][0] = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
1673 
s>mv[0][0][1] = RSHIFT(s>sprite_offset[0][1], as>quarter_sample); 
1674 
} 
1675 
/* if (s>mv[0][0][0] < l) s>mv[0][0][0]= l;

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

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

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

1679  
1680 
s>mb_skiped = 0;

1681 
}else{

1682 
s>mcsel=0;

1683 
s>mv[0][0][0] = 0; 
1684 
s>mv[0][0][1] = 0; 
1685 
s>mb_skiped = 1;

1686 
} 
1687 
return 0; 
1688 
} 
1689 
cbpc = get_vlc(&s>gb, &inter_MCBPC_vlc); 
1690 
//fprintf(stderr, "\tCBPC: %d", cbpc);

1691 
if (cbpc < 0) 
1692 
return 1; 
1693 
if (cbpc > 20) 
1694 
cbpc+=3;

1695 
else if (cbpc == 20) 
1696 
fprintf(stderr, "Stuffing !");

1697 

1698 
dquant = cbpc & 8;

1699 
s>mb_intra = ((cbpc & 4) != 0); 
1700 
if (s>mb_intra) goto intra; 
1701 

1702 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
1703 
s>mcsel= get_bits1(&s>gb); 
1704 
else s>mcsel= 0; 
1705 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
1706 
cbp = (cbpc & 3)  ((cbpy ^ 0xf) << 2); 
1707 
if (dquant) {

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

1709 
if (s>qscale < 1) 
1710 
s>qscale = 1;

1711 
else if (s>qscale > 31) 
1712 
s>qscale = 31;

1713 
h263_dc_scale(s); 
1714 
} 
1715 
s>mv_dir = MV_DIR_FORWARD; 
1716 
if ((cbpc & 16) == 0) { 
1717 
/* 16x16 motion prediction */

1718 
s>mv_type = MV_TYPE_16X16; 
1719 
h263_pred_motion(s, 0, &pred_x, &pred_y);

1720 
if (s>umvplus_dec)

1721 
mx = h263p_decode_umotion(s, pred_x); 
1722 
else if(!s>mcsel) 
1723 
mx = h263_decode_motion(s, pred_x, s>f_code); 
1724 
else {

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

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

1730 
mx = RSHIFT(s>sprite_offset[0][0], as>quarter_sample); 
1731 
} 
1732 
// if (mx < l) mx= l, printf("C");

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

1734 
} 
1735 
if (mx >= 0xffff) 
1736 
return 1; 
1737 

1738 
if (s>umvplus_dec)

1739 
my = h263p_decode_umotion(s, pred_y); 
1740 
else if(!s>mcsel) 
1741 
my = h263_decode_motion(s, pred_y, s>f_code); 
1742 
else{

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

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

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

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

1752 
} 
1753 
if (my >= 0xffff) 
1754 
return 1; 
1755 
s>mv[0][0][0] = mx; 
1756 
s>mv[0][0][1] = my; 
1757 
/*fprintf(stderr, "\n MB %d", (s>mb_y * s>mb_width) + s>mb_x);

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

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

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

1762 

1763 
} else {

1764 
s>mv_type = MV_TYPE_8X8; 
1765 
for(i=0;i<4;i++) { 
1766 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
1767 
if (s>umvplus_dec)

1768 
mx = h263p_decode_umotion(s, pred_x); 
1769 
else

1770 
mx = h263_decode_motion(s, pred_x, s>f_code); 
1771 
if (mx >= 0xffff) 
1772 
return 1; 
1773 

1774 
if (s>umvplus_dec)

1775 
my = h263p_decode_umotion(s, pred_y); 
1776 
else

1777 
my = h263_decode_motion(s, pred_y, s>f_code); 
1778 
if (my >= 0xffff) 
1779 
return 1; 
1780 
s>mv[0][i][0] = mx; 
1781 
s>mv[0][i][1] = my; 
1782 
if (s>umvplus_dec && (mx  pred_x) == 1 && (my  pred_y) == 1) 
1783 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

1784 
mot_val[0] = mx;

1785 
mot_val[1] = my;

1786 
} 
1787 
} 
1788 
} else if(s>pict_type==B_TYPE) { 
1789 
int modb1; // first bit of modb 
1790 
int modb2; // second bit of modb 
1791 
int mb_type;

1792 
uint16_t time_pp; 
1793 
uint16_t time_pb; 
1794 
int xy;

1795  
1796 
s>mb_intra = 0; //Bframes never contain intra blocks 
1797 
s>mcsel=0; // ... true gmc blocks 
1798  
1799 
if(s>mb_x==0){ 
1800 
s>last_mv[0][0][0]= 
1801 
s>last_mv[0][0][1]= 
1802 
s>last_mv[1][0][0]= 
1803 
s>last_mv[1][0][1]= 0; 
1804 
// printf("\n");

1805 
} 
1806  
1807 
/* if we skipped it in the future P Frame than skip it now too */

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

1809  
1810 
if(s>mb_skiped){

1811 
/* skip mb */

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

1814  
1815 
s>mv_dir = MV_DIR_FORWARD; 
1816 
s>mv_type = MV_TYPE_16X16; 
1817 
s>mv[0][0][0] = 0; 
1818 
s>mv[0][0][1] = 0; 
1819 
s>mv[1][0][0] = 0; 
1820 
s>mv[1][0][1] = 0; 
1821 
//FIXME is this correct?

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

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

1824 
// printf("S");

1825 
return 0; 
1826 
} 
1827  
1828 
modb1= get_bits1(&s>gb); 
1829 
if(modb1==0){ 
1830 
modb2= get_bits1(&s>gb); 
1831 
mb_type= get_vlc(&s>gb, &mb_type_b_vlc); 
1832 
if(modb2==0) cbp= get_bits(&s>gb, 6); 
1833 
else cbp=0; 
1834 
if (mb_type && cbp) {

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

1836 
s>qscale +=get_bits1(&s>gb)*4  2; 
1837 
if (s>qscale < 1) 
1838 
s>qscale = 1;

1839 
else if (s>qscale > 31) 
1840 
s>qscale = 31;

1841 
h263_dc_scale(s); 
1842 
} 
1843 
} 
1844 
}else{

1845 
mb_type=4; //like 0 but no vectors coded 
1846 
cbp=0;

1847 
} 
1848 
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

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

1851 
{ 
1852 
case 0: /* direct */ 
1853 
mx = h263_decode_motion(s, 0, 1); 
1854 
my = h263_decode_motion(s, 0, 1); 
1855 
case 4: /* direct with mx=my=0 */ 
1856 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
1857 
xy= s>block_index[0];

1858 
time_pp= s>pp_time; 
1859 
time_pb= time_pp  s>bp_time; 
1860 
//if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);

1861 
//FIXME 4MV

1862 
//FIXME avoid divides

1863 
s>mv[0][0][0] = s>motion_val[xy][0]*time_pb/time_pp + mx; 
1864 
s>mv[0][0][1] = s>motion_val[xy][1]*time_pb/time_pp + my; 
1865 
s>mv[1][0][0] = mx ? s>mv[0][0][0]  s>motion_val[xy][0] 
1866 
: s>motion_val[xy][0]*(time_pb  time_pp)/time_pp + mx;

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

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

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

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

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

1873 
// printf("D");

1874 
break;

1875 
case 1: 
1876 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD; 
1877 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
1878 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
1879 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
1880 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
1881  
1882 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
1883 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
1884 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
1885 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
1886 
// printf("I");

1887 
break;

1888 
case 2: 
1889 
s>mv_dir = MV_DIR_BACKWARD; 
1890 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
1891 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
1892 
s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
1893 
s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
1894 
// printf("B");

1895 
break;

1896 
case 3: 
1897 
s>mv_dir = MV_DIR_FORWARD; 
1898 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
1899 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
1900 
s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
1901 
s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
1902 
// printf("F");

1903 
break;

1904 
default: return 1; 
1905 
} 
1906 
} else { /* IFrame */ 
1907 
cbpc = get_vlc(&s>gb, &intra_MCBPC_vlc); 
1908 
if (cbpc < 0) 
1909 
return 1; 
1910 
dquant = cbpc & 4;

1911 
s>mb_intra = 1;

1912 
intra:

1913 
s>ac_pred = 0;

1914 
if (s>h263_pred  s>h263_aic) {

1915 
s>ac_pred = get_bits1(&s>gb); 
1916 
if (s>ac_pred && s>h263_aic)

1917 
s>h263_aic_dir = get_bits1(&s>gb); 
1918 
} 
1919 
if (s>h263_aic) {

1920 
s>y_dc_scale = 2 * s>qscale;

1921 
s>c_dc_scale = 2 * s>qscale;

1922 
} 
1923 
cbpy = get_vlc(&s>gb, &cbpy_vlc); 
1924 
cbp = (cbpc & 3)  (cbpy << 2); 
1925 
if (dquant) {

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

1927 
if (s>qscale < 1) 
1928 
s>qscale = 1;

1929 
else if (s>qscale > 31) 
1930 
s>qscale = 31;

1931 
h263_dc_scale(s); 
1932 
} 
1933 
} 
1934  
1935 
/* decode each block */

1936 
if (s>h263_pred) {

1937 
for (i = 0; i < 6; i++) { 
1938 
if (mpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
1939 
return 1; 
1940 
} 
1941 
} else {

1942 
for (i = 0; i < 6; i++) { 
1943 
if (h263_decode_block(s, block[i], i, (cbp >> (5  i)) & 1) < 0) 
1944 
return 1; 
1945 
} 
1946 
} 
1947 
return 0; 
1948 
} 
1949  
1950 
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 
1951 
{ 
1952 
int code, val, sign, shift, l, m;

1953  
1954 
code = get_vlc(&s>gb, &mv_vlc); 
1955 
if (code < 0) 
1956 
return 0xffff; 
1957  
1958 
if (code == 0) 
1959 
return pred;

1960 
sign = get_bits1(&s>gb); 
1961 
shift = f_code  1;

1962 
val = (code  1) << shift;

1963 
if (shift > 0) 
1964 
val = get_bits(&s>gb, shift); 
1965 
val++; 
1966 
if (sign)

1967 
val = val; 
1968 
val += pred; 
1969 

1970 
/* modulo decoding */

1971 
if (!s>h263_long_vectors) {

1972 
l = (1 << (f_code  1)) * 32; 
1973 
m = 2 * l;

1974 
if (val < l) {

1975 
val += m; 
1976 
} else if (val >= l) { 
1977 
val = m; 
1978 
} 
1979 
} else {

1980 
/* horrible h263 long vector mode */

1981 
if (pred < 31 && val < 63) 
1982 
val += 64;

1983 
if (pred > 32 && val > 63) 
1984 
val = 64;

1985 

1986 
} 
1987 
return val;

1988 
} 
1989  
1990 
/* Decodes RVLC of H.263+ UMV */

1991 
static int h263p_decode_umotion(MpegEncContext * s, int pred) 
1992 
{ 
1993 
int code = 0, sign; 
1994 

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

1997 

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

1999 

2000 
while (get_bits1(&s>gb))

2001 
{ 
2002 
code <<= 1;

2003 
code += get_bits1(&s>gb); 
2004 
} 
2005 
sign = code & 1;

2006 
code >>= 1;

2007 

2008 
code = (sign) ? (pred  code) : (pred + code); 
2009 
#ifdef DEBUG

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

2011 
#endif

2012 
return code;

2013  
2014 
} 
2015  
2016 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
2017 
int n, int coded) 
2018 
{ 
2019 
int code, level, i, j, last, run;

2020 
RLTable *rl = &rl_inter; 
2021 
const UINT8 *scan_table;

2022  
2023 
scan_table = zigzag_direct; 
2024 
if (s>h263_aic && s>mb_intra) {

2025 
rl = &rl_intra_aic; 
2026 
i = 0;

2027 
if (s>ac_pred) {

2028 
if (s>h263_aic_dir)

2029 
scan_table = ff_alternate_vertical_scan; /* left */

2030 
else

2031 
scan_table = ff_alternate_horizontal_scan; /* top */

2032 
} 
2033 
} else if (s>mb_intra) { 
2034 
/* DC coef */

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

2037 
component = (n <= 3 ? 0 : n  4 + 1); 
2038 
level = s>last_dc[component]; 
2039 
if (s>rv10_first_dc_coded[component]) {

2040 
diff = rv_decode_dc(s, n); 
2041 
if (diff == 0xffff) 
2042 
return 1; 
2043 
level += diff; 
2044 
level = level & 0xff; /* handle wrap round */ 
2045 
s>last_dc[component] = level; 
2046 
} else {

2047 
s>rv10_first_dc_coded[component] = 1;

2048 
} 
2049 
} else {

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

2051 
if (level == 255) 
2052 
level = 128;

2053 
} 
2054 
block[0] = level;

2055 
i = 1;

2056 
} else {

2057 
i = 0;

2058 
} 
2059 
if (!coded) {

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

2061 
goto not_coded;

2062 
s>block_last_index[n] = i  1;

2063 
return 0; 
2064 
} 
2065  
2066 
for(;;) {

2067 
code = get_vlc(&s>gb, &rl>vlc); 
2068 
if (code < 0) 
2069 
return 1; 
2070 
if (code == rl>n) {

2071 
/* escape */

2072 
last = get_bits1(&s>gb); 
2073 
run = get_bits(&s>gb, 6);

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

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

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

2078 
level = (level << 20) >> 20; 
2079 
} 
2080 
} else {

2081 
run = rl>table_run[code]; 
2082 
level = rl>table_level[code]; 
2083 
last = code >= rl>last; 
2084 
if (get_bits1(&s>gb))

2085 
level = level; 
2086 
} 
2087 
i += run; 
2088 
if (i >= 64) 
2089 
return 1; 
2090 
j = scan_table[i]; 
2091 
block[j] = level; 
2092 
if (last)

2093 
break;

2094 
i++; 
2095 
} 
2096 
not_coded:

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

2098 
h263_pred_acdc(s, block, n); 
2099 
i = 63;

2100 
} 
2101 
s>block_last_index[n] = i; 
2102 
return 0; 
2103 
} 
2104  
2105 
static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
2106 
{ 
2107 
int level, pred, code;

2108 
UINT16 *dc_val; 
2109  
2110 
if (n < 4) 
2111 
code = get_vlc(&s>gb, &dc_lum); 
2112 
else

2113 
code = get_vlc(&s>gb, &dc_chrom); 
2114 
if (code < 0) 
2115 
return 1; 
2116 
if (code == 0) { 
2117 
level = 0;

2118 
} else {

2119 
level = get_bits(&s>gb, code); 
2120 
if ((level >> (code  1)) == 0) /* if MSB not set it is negative*/ 
2121 
level =  (level ^ ((1 << code)  1)); 
2122 
if (code > 8) 
2123 
skip_bits1(&s>gb); /* marker */

2124 
} 
2125  
2126 
pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
2127 
level += pred; 
2128 
if (level < 0) 
2129 
level = 0;

2130 
if (n < 4) { 
2131 
*dc_val = level * s>y_dc_scale; 
2132 
} else {

2133 
*dc_val = level * s>c_dc_scale; 
2134 
} 
2135 
return level;

2136 
} 
2137  
2138 
static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
2139 
int n, int coded) 
2140 
{ 
2141 
int code, level, i, j, last, run;

2142 
int dc_pred_dir;

2143 
RLTable *rl; 
2144 
const UINT8 *scan_table;

2145  
2146 
if (s>mb_intra) {

2147 
/* DC coef */

2148 
level = mpeg4_decode_dc(s, n, &dc_pred_dir); 
2149 
if (level < 0) 
2150 
return 1; 
2151 
block[0] = level;

2152 
i = 1;

2153 
if (!coded)

2154 
goto not_coded;

2155 
rl = &rl_intra; 
2156 
if (s>ac_pred) {

2157 
if (dc_pred_dir == 0) 
2158 
scan_table = ff_alternate_vertical_scan; /* left */

2159 
else

2160 
scan_table = ff_alternate_horizontal_scan; /* top */

2161 
} else {

2162 
scan_table = zigzag_direct; 
2163 
} 
2164 
} else {

2165 
i = 0;

2166 
if (!coded) {

2167 
s>block_last_index[n] = i  1;

2168 
return 0; 
2169 
} 
2170 
rl = &rl_inter; 
2171 
scan_table = zigzag_direct; 
2172 
} 
2173  
2174 
for(;;) {

2175 
code = get_vlc(&s>gb, &rl>vlc); 
2176 
if (code < 0) 
2177 
return 1; 
2178 
if (code == rl>n) {

2179 
/* escape */

2180 
if (get_bits1(&s>gb) != 0) { 
2181 
if (get_bits1(&s>gb) != 0) { 
2182 
/* third escape */

2183 
last = get_bits1(&s>gb); 
2184 
run = get_bits(&s>gb, 6);

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

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

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

2189 
} else {

2190 
/* second escape */

2191 
code = get_vlc(&s>gb, &rl>vlc); 
2192 
if (code < 0  code >= rl>n) 
2193 
return 1; 
2194 
run = rl>table_run[code]; 
2195 
level = rl>table_level[code]; 
2196 
last = code >= rl>last; 
2197 
run += rl>max_run[last][level] + 1;

2198 
if (get_bits1(&s>gb))

2199 
level = level; 
2200 
} 
2201 
} else {

2202 
/* first escape */

2203 
code = get_vlc(&s>gb, &rl>vlc); 
2204 
if (code < 0  code >= rl>n) 
2205 
return 1; 
2206 
run = rl>table_run[code]; 
2207 
level = rl>table_level[code]; 
2208 
last = code >= rl>last; 
2209 
level += rl>max_level[last][run]; 
2210 
if (get_bits1(&s>gb))

2211 
level = level; 
2212 
} 
2213 
} else {

2214 
run = rl>table_run[code]; 
2215 
level = rl>table_level[code]; 
2216 
last = code >= rl>last; 
2217 
if (get_bits1(&s>gb))

2218 
level = level; 
2219 
} 
2220 
i += run; 
2221 
if (i >= 64) 
2222 
return 1; 
2223 
j = scan_table[i]; 
2224 
block[j] = level; 
2225 
i++; 
2226 
if (last)

2227 
break;

2228 
} 
2229 
not_coded:

2230 
if (s>mb_intra) {

2231 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
2232 
if (s>ac_pred) {

2233 
i = 64; /* XXX: not optimal */ 
2234 
} 
2235 
} 
2236 
s>block_last_index[n] = i  1;

2237 
return 0; 
2238 
} 
2239  
2240 
/* most is hardcoded. should extend to handle all h263 streams */

2241 
int h263_decode_picture_header(MpegEncContext *s)

2242 
{ 
2243 
int format, width, height;

2244  
2245 
/* picture header */

2246 
if (get_bits(&s>gb, 22) != 0x20) 
2247 
return 1; 
2248 
s>picture_number = get_bits(&s>gb, 8); /* picture timestamp */ 
2249 

2250 
if (get_bits1(&s>gb) != 1) 
2251 
return 1; /* marker */ 
2252 
if (get_bits1(&s>gb) != 0) 
2253 
return 1; /* h263 id */ 
2254 
skip_bits1(&s>gb); /* split screen off */

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

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

2257  
2258 
/* Reset GOB number */

2259 
s>gob_number = 0;

2260 

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

2262  
2263 
if (format != 7 && format != 6) { 
2264 
s>h263_plus = 0;

2265 
/* H.263v1 */

2266 
width = h263_format[format][0];

2267 
height = h263_format[format][1];

2268 
if (!width)

2269 
return 1; 
2270 

2271 
s>width = width; 
2272 
s>height = height; 
2273 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
2274  
2275 
s>unrestricted_mv = get_bits1(&s>gb); 
2276 
s>h263_long_vectors = s>unrestricted_mv; 
2277  
2278 
if (get_bits1(&s>gb) != 0) 
2279 
return 1; /* SAC: off */ 
2280 
if (get_bits1(&s>gb) != 0) { 
2281 
s>mv_type = MV_TYPE_8X8; /* Advanced prediction mode */

2282 
} 
2283 

2284 
if (get_bits1(&s>gb) != 0) 
2285 
return 1; /* not PB frame */ 
2286  
2287 
s>qscale = get_bits(&s>gb, 5);

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

2289 
} else {

2290 
int ufep;

2291 

2292 
/* H.263v2 */

2293 
s>h263_plus = 1;

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

2296 
if (ufep == 1) { 
2297 
/* OPPTYPE */

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

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

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

2304 
} 
2305 
if (get_bits1(&s>gb) != 0) { /* Advanced Intra Coding (AIC) */ 
2306 
s>h263_aic = 1;

2307 
} 
2308 
skip_bits(&s>gb, 7);

2309 
skip_bits(&s>gb, 3); /* Reserved */ 
2310 
} else if (ufep != 0) 
2311 
return 1; 
2312 

2313 
/* MPPTYPE */

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

2316 
s>pict_type != P_TYPE) 
2317 
return 1; 
2318 
skip_bits(&s>gb, 2);

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

2321 
skip_bits(&s>gb, 4);

2322 

2323 
/* Get the picture dimensions */

2324 
if (ufep) {

2325 
if (format == 6) { 
2326 
/* Custom Picture Format (CPFMT) */

2327 
skip_bits(&s>gb, 4); /* aspect ratio */ 
2328 
width = (get_bits(&s>gb, 9) + 1) * 4; 
2329 
skip_bits1(&s>gb); 
2330 
height = get_bits(&s>gb, 9) * 4; 
2331 
#ifdef DEBUG

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

2333 
#endif

2334 
} 
2335 
else {

2336 
width = h263_format[format][0];

2337 
height = h263_format[format][1];

2338 
} 
2339 
if ((width == 0)  (height == 0)) 
2340 
return 1; 
2341 
s>width = width; 
2342 
s>height = height; 
2343 
if (s>umvplus_dec) {

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

2345 
} 
2346 
} 
2347 

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

2349 
} 
2350 
/* PEI */

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

2353 
} 
2354 
s>f_code = 1;

2355 
return 0; 
2356 
} 
2357  
2358 
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) 
2359 
{ 
2360 
int i;

2361 
int a= 2<<s>sprite_warping_accuracy; 
2362 
int rho= 3s>sprite_warping_accuracy; 
2363 
int r=16/a; 
2364 
const int vop_ref[4][2]= {{0,0}, {s>width,0}, {0, s>height}, {s>width, s>height}}; // only true for rectangle shapes 
2365 
int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; 
2366 
int sprite_ref[4][2]; 
2367 
int virtual_ref[2][2]; 
2368 
int w2, h2;

2369 
int alpha=0, beta=0; 
2370 
int w= s>width;

2371 
int h= s>height;

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

2373 
for(i=0; i<s>num_sprite_warping_points; i++){ 
2374 
int length;

2375 
int x=0, y=0; 
2376  
2377 
length= get_vlc(&s>gb, &sprite_trajectory); 
2378 
if(length){

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

2381 
if ((x >> (length  1)) == 0) /* if MSB not set it is negative*/ 
2382 
x =  (x ^ ((1 << length)  1)); 
2383 
} 
2384 
if(!(s>divx_version==500 && s>divx_build==413)) skip_bits1(&s>gb); /* marker bit */ 
2385 

2386 
length= get_vlc(&s>gb, &sprite_trajectory); 
2387 
if(length){

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

2390 
if ((y >> (length  1)) == 0) /* if MSB not set it is negative*/ 
2391 
y =  (y ^ ((1 << length)  1)); 
2392 
} 
2393 
skip_bits1(&s>gb); /* marker bit */

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

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

2396 
//x=y=0;

2397 
d[i][0]= x;

2398 
d[i][1]= y;

2399 
} 
2400  
2401 
while((1<<alpha)<w) alpha++; 
2402 
while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' 
2403 
w2= 1<<alpha;

2404 
h2= 1<<beta;

2405  
2406 
// Note, the 4th point isnt used for GMC

2407 
if(s>divx_version==500 && s>divx_build==413){ 
2408 
sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; 
2409 
sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; 
2410 
sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; 
2411 
sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; 
2412 
sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; 
2413 
sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; 
2414 
} else {

2415 
sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); 
2416 
sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); 
2417 
sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); 
2418 
sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); 
2419 
sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); 
2420 
sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); 
2421 
} 
2422 
/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

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

2424 

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

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

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

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

2429 
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 
2430 
+ 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); 
2431 
virtual_ref[0][1]= 16*vop_ref[0][1] 
2432 
+ 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); 
2433 
virtual_ref[1][0]= 16*vop_ref[0][0] 
2434 
+ 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); 
2435 
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 
2436 
+ 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); 
2437  
2438 
switch(s>num_sprite_warping_points)

2439 
{ 
2440 
case 0: 
2441 
s>sprite_offset[0][0]= 0; 
2442 
s>sprite_offset[0][1]= 0; 
2443 
s>sprite_offset[1][0]= 0; 
2444 
s>sprite_offset[1][1]= 0; 
2445 
s>sprite_delta[0][0][0]= a; 
2446 
s>sprite_delta[0][0][1]= 0; 
2447 
s>sprite_delta[0][1][0]= 0; 
2448 
s>sprite_delta[0][1][1]= a; 
2449 
s>sprite_delta[1][0][0]= a; 
2450 
s>sprite_delta[1][0][1]= 0; 
2451 
s>sprite_delta[1][1][0]= 0; 
2452 
s>sprite_delta[1][1][1]= a; 
2453 
s>sprite_shift[0][0]= 0; 
2454 
s>sprite_shift[0][1]= 0; 
2455 
s>sprite_shift[1][0]= 0; 
2456 
s>sprite_shift[1][1]= 0; 
2457 
break;

2458 
case 1: //GMC only 
2459 
s>sprite_offset[0][0]= sprite_ref[0][0]  a*vop_ref[0][0]; 
2460 
s>sprite_offset[0][1]= sprite_ref[0][1]  a*vop_ref[0][1]; 
2461 
s>sprite_offset[1][0]= ((sprite_ref[0][0]>>1)(sprite_ref[0][0]&1))  a*(vop_ref[0][0]/2); 
2462 
s>sprite_offset[1][1]= ((sprite_ref[0][1]>>1)(sprite_ref[0][1]&1))  a*(vop_ref[0][1]/2); 
2463 
s>sprite_delta[0][0][0]= a; 
2464 
s>sprite_delta[0][0][1]= 0; 
2465 
s>sprite_delta[0][1][0]= 0; 
2466 
s>sprite_delta[0][1][1]= a; 
2467 
s>sprite_delta[1][0][0]= a; 
2468 
s>sprite_delta[1][0][1]= 0; 
2469 
s>sprite_delta[1][1][0]= 0; 
2470 
s>sprite_delta[1][1][1]= a; 
2471 
s>sprite_shift[0][0]= 0; 
2472 
s>sprite_shift[0][1]= 0; 
2473 
s>sprite_shift[1][0]= 0; 
2474 
s>sprite_shift[1][1]= 0; 
2475 
break;

2476 
case 2: 
2477 
case 3: //FIXME 
2478 
s>sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) 
2479 
+ ((r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][0]) 
2480 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(vop_ref[0][1])); 
2481 
s>sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) 
2482 
+ ((r*sprite_ref[0][1] + virtual_ref[0][1])*(vop_ref[0][0]) 
2483 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(vop_ref[0][1])); 
2484 
s>sprite_offset[1][0]= ((r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][0] + 1) 
2485 
+( r*sprite_ref[0][1]  virtual_ref[0][1])*(2*vop_ref[0][1] + 1) 
2486 
+2*w2*r*sprite_ref[0][0]  16*w2); 
2487 
s>sprite_offset[1][1]= ((r*sprite_ref[0][1] + virtual_ref[0][1])*(2*vop_ref[0][0] + 1) 
2488 
+(r*sprite_ref[0][0] + virtual_ref[0][0])*(2*vop_ref[0][1] + 1) 
2489 
+2*w2*r*sprite_ref[0][1]  16*w2); 
2490 
s>sprite_delta[0][0][0]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
2491 
s>sprite_delta[0][0][1]= ( r*sprite_ref[0][1]  virtual_ref[0][1]); 
2492 
s>sprite_delta[0][1][0]= (r*sprite_ref[0][1] + virtual_ref[0][1]); 
2493 
s>sprite_delta[0][1][1]= (r*sprite_ref[0][0] + virtual_ref[0][0]); 
2494 
s>sprite_delta[1][0][0]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
2495 
s>sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1]  virtual_ref[0][1]); 
2496 
s>sprite_delta[1][1][0]= 4*(r*sprite_ref[0][1] + virtual_ref[0][1]); 
2497 
s>sprite_delta[1][1][1]= 4*(r*sprite_ref[0][0] + virtual_ref[0][0]); 
2498 
s>sprite_shift[0][0]= alpha+rho; 
2499 
s>sprite_shift[0][1]= alpha+rho; 
2500 
s>sprite_shift[1][0]= alpha+rho+2; 
2501 
s>sprite_shift[1][1]= alpha+rho+2; 
2502 
break;

2503 
// case 3:

2504 
break;

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

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

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

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

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

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

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

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

2514 
/* try to simplify the situation */

2515 
if( s>sprite_delta[0][0][0] == a<<s>sprite_shift[0][0] 
2516 
&& s>sprite_delta[0][0][1] == 0 
2517 
&& s>sprite_delta[0][1][0] == 0 
2518 
&& s>sprite_delta[0][1][1] == a<<s>sprite_shift[0][1] 
2519 
&& s>sprite_delta[1][0][0] == a<<s>sprite_shift[1][0] 
2520 
&& s>sprite_delta[1][0][1] == 0 
2521 
&& s>sprite_delta[1][1][0] == 0 
2522 
&& s>sprite_delta[1][1][1] == a<<s>sprite_shift[1][1]) 
2523 
{ 
2524 
s>sprite_offset[0][0]>>=s>sprite_shift[0][0]; 
2525 
s>sprite_offset[0][1]>>=s>sprite_shift[0][1]; 
2526 
s>sprite_offset[1][0]>>=s>sprite_shift[1][0]; 
2527 
s>sprite_offset[1][1]>>=s>sprite_shift[1][1]; 
2528 
s>sprite_delta[0][0][0]= a; 
2529 
s>sprite_delta[0][0][1]= 0; 
2530 
s>sprite_delta[0][1][0]= 0; 
2531 
s>sprite_delta[0][1][1]= a; 
2532 
s>sprite_delta[1][0][0]= a; 
2533 
s>sprite_delta[1][0][1]= 0; 
2534 
s>sprite_delta[1][1][0]= 0; 
2535 
s>sprite_delta[1][1][1]= a; 
2536 
s>sprite_shift[0][0]= 0; 
2537 
s>sprite_shift[0][1]= 0; 
2538 
s>sprite_shift[1][0]= 0; 
2539 
s>sprite_shift[1][1]= 0; 
2540 
s>real_sprite_warping_points=1;

2541 
} 
2542 
else

2543 
s>real_sprite_warping_points= s>num_sprite_warping_points; 
2544  
2545 
//printf("%d %d %d %d\n", d[0][0], d[0][1], s>sprite_offset[0][0], s>sprite_offset[0][1]);

2546 
} 
2547  
2548 
/* decode mpeg4 VOP header */

2549 
int mpeg4_decode_picture_header(MpegEncContext * s)

2550 
{ 
2551 
int time_incr, startcode, state, v;

2552 
int time_increment;

2553  
2554 
redo:

2555 
/* search next start code */

2556 
align_get_bits(&s>gb); 
2557 
state = 0xff;

2558 
for(;;) {

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

2560 
if (state == 0x000001) { 
2561 
state = ((state << 8)  v) & 0xffffff; 
2562 
startcode = state; 
2563 
break;

2564 
} 
2565 
state = ((state << 8)  v) & 0xffffff; 
2566 
if( get_bits_count(&s>gb) > s>gb.size*832){ 
2567 
if(s>gb.size>50){ 
2568 
printf("no VOP startcode found, frame size was=%d\n", s>gb.size);

2569 
return 1; 
2570 
}else{

2571 
printf("frame skip\n");

2572 
return FRAME_SKIPED;

2573 
} 
2574 
} 
2575 
} 
2576 
//printf("startcode %X %d\n", startcode, get_bits_count(&s>gb));

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

2579  
2580 
/* vol header */

2581 
skip_bits(&s>gb, 1); /* random access */ 
2582 
skip_bits(&s>gb, 8); /* vo_type */ 
2583 
if (get_bits1(&s>gb) != 0) { /* is_ol_id */ 
2584 
vo_ver_id = get_bits(&s>gb, 4); /* vo_ver_id */ 
2585 
skip_bits(&s>gb, 3); /* vo_priority */ 
2586 
} else {

2587 
vo_ver_id = 1;

2588 
} 
2589 

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

2591 
if(s>aspect_ratio_info == EXTENDET_PAR){

2592 
skip_bits(&s>gb, 8); //par_width 
2593 
skip_bits(&s>gb, 8); // par_height 
2594 
} 
2595  
2596 
if(get_bits1(&s>gb)){ /* vol control parameter */ 
2597 
printf("vol control parameter not supported\n");

2598 
return 1; 
2599 
} 
2600 
s>shape = get_bits(&s>gb, 2); /* vol shape */ 
2601 
if(s>shape != RECT_SHAPE) printf("only rectangular vol supported\n"); 
2602 
if(s>shape == GRAY_SHAPE && vo_ver_id != 1){ 
2603 
printf("Gray shape not supported\n");

2604 
skip_bits(&s>gb, 4); //video_object_layer_shape_extension 
2605 
} 
2606  
2607 
skip_bits1(&s>gb); /* marker */

2608 

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

2610 
s>time_increment_bits = av_log2(s>time_increment_resolution  1) + 1; 
2611 
if (s>time_increment_bits < 1) 
2612 
s>time_increment_bits = 1;

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

2614  
2615 
if (get_bits1(&s>gb) != 0) { /* fixed_vop_rate */ 
2616 
skip_bits(&s>gb, s>time_increment_bits); 
2617 
} 
2618  
2619 
if (s>shape != BIN_ONLY_SHAPE) {

2620 
if (s>shape == RECT_SHAPE) {

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

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

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

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

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

2626 
if(width && height){ /* they should be non zero but who knows ... */ 
2627 
s>width = width; 
2628 
s>height = height; 
2629 
// printf("width/height: %d %d\n", width, height);

2630 
} 
2631 
} 
2632 

2633 
if(get_bits1(&s>gb)) printf("interlaced not supported\n"); /* interlaced */ 
2634 
if(!get_bits1(&s>gb)) printf("OBMC not supported\n"); /* OBMC Disable */ 
2635 
if (vo_ver_id == 1) { 
2636 
s>vol_sprite_usage = get_bits1(&s>gb); /* vol_sprite_usage */

2637 
} else {

2638 
s>vol_sprite_usage = get_bits(&s>gb, 2); /* vol_sprite_usage */ 
2639 
} 
2640 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); 
2641 
if(s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE){

2642 
if(s>vol_sprite_usage==STATIC_SPRITE){

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

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

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

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

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

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

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

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

2651 
} 
2652 
s>num_sprite_warping_points= get_bits(&s>gb, 6);

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

2654 
s>sprite_brightness_change= get_bits1(&s>gb); 
2655 
if(s>vol_sprite_usage==STATIC_SPRITE)

2656 
s>low_latency_sprite= get_bits1(&s>gb); 
2657 
} 
2658 
// FIXME sadct disable bit if verid!=1 && shape not rect

2659 

2660 
if (get_bits1(&s>gb) == 1) { /* not_8_bit */ 
2661 
s>quant_precision = get_bits(&s>gb, 4); /* quant_precision */ 
2662 
if(get_bits(&s>gb, 4)!=8) printf("Nbit not supported\n"); /* bits_per_pixel */ 
2663 
if(s>quant_precision!=5) printf("quant precission %d\n", s>quant_precision); 
2664 
} else {

2665 
s>quant_precision = 5;

2666 
} 
2667 

2668 
// FIXME a bunch of grayscale shape things

2669  
2670 
if(get_bits1(&s>gb)){ /* vol_quant_type */ 
2671 
int i, j, v;

2672 
/* load default matrixes */

2673 
for(i=0; i<64; i++){ 
2674 
v= ff_mpeg4_default_intra_matrix[i]; 
2675 
s>intra_matrix[i]= v; 
2676 
s>chroma_intra_matrix[i]= v; 
2677 

2678 
v= ff_mpeg4_default_non_intra_matrix[i]; 
2679 
s>non_intra_matrix[i]= v; 
2680 
s>chroma_non_intra_matrix[i]= v; 
2681 
} 
2682  
2683 
/* load custom intra matrix */

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

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

2687 
if(v==0) break; 
2688  
2689 
j= zigzag_direct[i]; 
2690 
s>intra_matrix[j]= v; 
2691 
s>chroma_intra_matrix[j]= v; 
2692 
} 
2693 
} 
2694  
2695 
/* load custom non intra matrix */

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

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

2699 
if(v==0) break; 
2700  
2701 
j= zigzag_direct[i]; 
2702 
s>non_intra_matrix[j]= v; 
2703 
s>chroma_non_intra_matrix[j]= v; 
2704 
} 
2705  
2706 
/* replicate last value */

2707 
for(; i<64; i++){ 
2708 
j= zigzag_direct[i]; 
2709 
s>non_intra_matrix[j]= v; 
2710 
s>chroma_non_intra_matrix[j]= v; 
2711 
} 
2712 
} 
2713  
2714 
s>dct_unquantize= s>dct_unquantize_mpeg2; 
2715  
2716 
// FIXME a bunch of grayscale shape things

2717 
}else

2718 
s>dct_unquantize= s>dct_unquantize_h263; 
2719  
2720 
if(vo_ver_id != 1) 
2721 
s>quarter_sample= get_bits1(&s>gb); 
2722 
else s>quarter_sample=0; 
2723  
2724 
if(!get_bits1(&s>gb)) printf("Complexity estimation not supported\n"); 
2725  
2726 
s>resync_marker= !get_bits1(&s>gb); /* resync_marker_disabled */

2727  
2728 
s>data_partioning= get_bits1(&s>gb); 
2729 
if(s>data_partioning){

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

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

2732 
} 
2733 

2734 
if(vo_ver_id != 1) { 
2735 
s>new_pred= get_bits1(&s>gb); 
2736 
if(s>new_pred){

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

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

2740 
} 
2741 
s>reduced_res_vop= get_bits1(&s>gb); 
2742 
if(s>reduced_res_vop) printf("reduced resolution VOP not supported\n"); 
2743 
} 
2744 
else{

2745 
s>new_pred=0;

2746 
s>reduced_res_vop= 0;

2747 
} 
2748  
2749 
s>scalability= get_bits1(&s>gb); 
2750 
if (s>scalability) {

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

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

2755 
goto redo;

2756 
} else if (startcode == 0x1b2) { //userdata 
2757 
char buf[256]; 
2758 
int i;

2759 
int e;

2760 
int ver, build;

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

2763 
buf[0]= show_bits(&s>gb, 8); 
2764 
for(i=1; i<256; i++){ 
2765 
buf[i]= show_bits(&s>gb, 16)&0xFF; 
2766 
if(buf[i]==0) break; 
2767 
skip_bits(&s>gb, 8);

2768 
} 
2769 
buf[255]=0; 
2770 
e=sscanf(buf, "DivX%dBuild%d", &ver, &build);

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

2773 
if(e==2){ 
2774 
s>divx_version= ver; 
2775 
s>divx_build= build; 
2776 
if(s>picture_number==0){ 
2777 
printf("This file was encoded with DivX%d Build%d\n", ver, build);

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

2780 
#if 0

2781 
}else{

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

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

2784 
#endif

2785 
} 
2786 
} 
2787 
} 
2788 
//printf("User Data: %s\n", buf);

2789 
goto redo;

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

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

2796 
time_incr=0;

2797 
while (get_bits1(&s>gb) != 0) 
2798 
time_incr++; 
2799  
2800 
check_marker(&s>gb, "before time_increment");

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

2803 
if(s>pict_type!=B_TYPE){

2804 
s>last_time_base= s>time_base; 
2805 
s>time_base+= time_incr; 
2806 
s>time= s>time_base*s>time_increment_resolution + time_increment; 
2807 
s>pp_time= s>time  s>last_non_b_time; 
2808 
s>last_non_b_time= s>time; 
2809 
}else{

2810 
s>time= (s>last_time_base + time_incr)*s>time_increment_resolution + time_increment; 
2811 
s>bp_time= s>last_non_b_time  s>time; 
2812 
} 
2813  
2814 
if(check_marker(&s>gb, "before vop_coded")==0 && s>picture_number==0){ 
2815 
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");

2816 
for(s>time_increment_bits++ ;s>time_increment_bits<16; s>time_increment_bits++){ 
2817 
if(get_bits1(&s>gb)) break; 
2818 
} 
2819 
printf("my guess is %d bits ;)\n",s>time_increment_bits);

2820 
} 
2821 
/* vop coded */

2822 
if (get_bits1(&s>gb) != 1) 
2823 
goto redo;

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

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

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

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

2829 
s>no_rounding = get_bits1(&s>gb); 
2830 
} else {

2831 
s>no_rounding = 0;

2832 
} 
2833 
//FIXME reduced res stuff

2834  
2835 
if (s>shape != RECT_SHAPE) {

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

2838 

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

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

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

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

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

2845 
ver_spat_ref = get_bits(&s>gb, 13); /* ver_spat_ref */ 
2846 
} 
2847 
skip_bits1(&s>gb); /* change_CR_disable */

2848 

2849 
if (get_bits1(&s>gb) != 0) { 
2850 
skip_bits(&s>gb, 8); /* constant_alpha_value */ 
2851 
} 
2852 
} 
2853 
//FIXME complexity estimation stuff

2854 

2855 
if (s>shape != BIN_ONLY_SHAPE) {

2856 
int t;

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

2859 
//FIXME interlaced specific bits

2860 
} 
2861  
2862 
if(s>pict_type == S_TYPE && (s>vol_sprite_usage==STATIC_SPRITE  s>vol_sprite_usage==GMC_SPRITE)){

2863 
if(s>num_sprite_warping_points){

2864 
mpeg4_decode_sprite_trajectory(s); 
2865 
} 
2866 
if(s>sprite_brightness_change) printf("sprite_brightness_change not supported\n"); 
2867 
if(s>vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); 
2868 
} 
2869  
2870 
if (s>shape != BIN_ONLY_SHAPE) {

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

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

2873 
movies */

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

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

2877 
return 1; // makes no sense to continue, as there is nothing left from the image then 
2878 
} 
2879 

2880 
if (s>pict_type != I_TYPE) {

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

2884 
return 1; // makes no sense to continue, as the MV decoding will break very quickly 
2885 
} 
2886 
} 
2887 
if (s>pict_type == B_TYPE) {

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

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

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

2892 
if(!s>scalability){

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

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

2895 
} 
2896 
} 
2897 
} 
2898 
s>picture_number++; // better than pic number==0 allways ;)

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

2900 
return 0; 
2901 
} 
2902  
2903 
/* don't understand why they choose a different header ! */

2904 
int intel_h263_decode_picture_header(MpegEncContext *s)

2905 
{ 
2906 
int format;

2907  
2908 
/* picture header */

2909 
if (get_bits(&s>gb, 22) != 0x20) 
2910 
return 1; 
2911 
skip_bits(&s>gb, 8); /* picture timestamp */ 
2912  
2913 
if (get_bits1(&s>gb) != 1) 
2914 
return 1; /* marker */ 
2915 
if (get_bits1(&s>gb) != 0) 
2916 
return 1; /* h263 id */ 
2917 
skip_bits1(&s>gb); /* split screen off */

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

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

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

2922 
if (format != 7) 
2923 
return 1; 
2924  
2925 
s>h263_plus = 0;

2926  
2927 
s>pict_type = I_TYPE + get_bits1(&s>gb); 
2928 

2929 
s>unrestricted_mv = get_bits1(&s>gb); 
2930 
s>h263_long_vectors = s>unrestricted_mv; 
2931  
2932 
if (get_bits1(&s>gb) != 0) 
2933 
return 1; /* SAC: off */ 
2934 
if (get_bits1(&s>gb) != 0) 
2935 
return 1; /* advanced prediction mode: off */ 
2936 
if (get_bits1(&s>gb) != 0) 
2937 
return 1; /* not PB frame */ 
2938  
2939 
/* skip unknown header garbage */

2940 
skip_bits(&s>gb, 41);

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

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

2944  
2945 
/* PEI */

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

2948 
} 
2949 
s>f_code = 1;

2950 
return 0; 
2951 
} 
2952 