ffmpeg / libavcodec / h263.c @ 204b5c9e
History  View  Annotate  Download (208 KB)
1 
/*


2 
* H263/MPEG4 backend for ffmpeg encoder and decoder

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

4 
* H263+ support.

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

6 
* Copyright (c) 20022004 Michael Niedermayer <michaelni@gmx.at>

7 
*

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

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

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

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

12 
*

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

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

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

16 
* Lesser General Public License for more details.

17 
*

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

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

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

21 
*

22 
* ac prediction encoding, bframe support, error resilience, optimizations,

23 
* qpel decoding, gmc decoding, interlaced decoding,

24 
* by Michael Niedermayer <michaelni@gmx.at>

25 
*/

26  
27 
/**

28 
* @file h263.c

29 
* h263/mpeg4 codec.

30 
*/

31 

32 
//#define DEBUG

33 
#include <limits.h> 
34  
35 
#include "common.h" 
36 
#include "dsputil.h" 
37 
#include "avcodec.h" 
38 
#include "mpegvideo.h" 
39 
#include "h263data.h" 
40 
#include "mpeg4data.h" 
41  
42 
//#undef NDEBUG

43 
//#include <assert.h>

44  
45 
#define INTRA_MCBPC_VLC_BITS 6 
46 
#define INTER_MCBPC_VLC_BITS 7 
47 
#define CBPY_VLC_BITS 6 
48 
#define MV_VLC_BITS 9 
49 
#define DC_VLC_BITS 9 
50 
#define SPRITE_TRAJ_VLC_BITS 6 
51 
#define MB_TYPE_B_VLC_BITS 4 
52 
#define TEX_VLC_BITS 9 
53 
#define H263_MBTYPE_B_VLC_BITS 6 
54 
#define CBPC_B_VLC_BITS 3 
55  
56 
#ifdef CONFIG_ENCODERS

57 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, 
58 
int n);

59 
static void h263_encode_motion(MpegEncContext * s, int val, int fcode); 
60 
static void h263p_encode_umotion(MpegEncContext * s, int val); 
61 
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, 
62 
int n, int dc, uint8_t *scan_table, 
63 
PutBitContext *dc_pb, PutBitContext *ac_pb); 
64 
#endif

65  
66 
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); 
67 
static int h263p_decode_umotion(MpegEncContext * s, int pred); 
68 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
69 
int n, int coded); 
70 
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); 
71 
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
72 
int n, int coded, int intra, int rvlc); 
73 
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr); 
74 
#ifdef CONFIG_ENCODERS

75 
static void mpeg4_encode_visual_object_header(MpegEncContext * s); 
76 
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); 
77 
#endif //CONFIG_ENCODERS 
78 
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); 
79 
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); 
80  
81 
#ifdef CONFIG_ENCODERS

82 
static uint8_t uni_DCtab_lum_len[512]; 
83 
static uint8_t uni_DCtab_chrom_len[512]; 
84 
static uint16_t uni_DCtab_lum_bits[512]; 
85 
static uint16_t uni_DCtab_chrom_bits[512]; 
86  
87 
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; 
88 
static uint8_t fcode_tab[MAX_MV*2+1]; 
89 
static uint8_t umv_fcode_tab[MAX_MV*2+1]; 
90  
91 
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; 
92 
static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; 
93 
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; 
94 
static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; 
95 
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))

96 
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)

97 
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) 
98  
99 
/* mpeg4

100 
inter

101 
max level: 24/6

102 
max run: 53/63

103 

104 
intra

105 
max level: 53/16

106 
max run: 29/41

107 
*/

108 
#endif

109  
110 
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit

111 
#define IS_3IV1 s>avctx>codec_tag == ff_get_fourcc("3IV1")

112 
#else

113 
#define IS_3IV1 0 
114 
#endif

115  
116 
int h263_get_picture_format(int width, int height) 
117 
{ 
118 
int format;

119  
120 
if (width == 128 && height == 96) 
121 
format = 1;

122 
else if (width == 176 && height == 144) 
123 
format = 2;

124 
else if (width == 352 && height == 288) 
125 
format = 3;

126 
else if (width == 704 && height == 576) 
127 
format = 4;

128 
else if (width == 1408 && height == 1152) 
129 
format = 5;

130 
else

131 
format = 7;

132 
return format;

133 
} 
134  
135 
#ifdef CONFIG_ENCODERS

136  
137 
static void aspect_to_info(MpegEncContext * s, AVRational aspect){ 
138 
int i;

139  
140 
if(aspect.num==0) aspect= (AVRational){1,1}; 
141  
142 
for(i=1; i<6; i++){ 
143 
if(av_cmp_q(pixel_aspect[i], aspect) == 0){ 
144 
s>aspect_ratio_info=i; 
145 
return;

146 
} 
147 
} 
148 

149 
s>aspect_ratio_info= FF_ASPECT_EXTENDED; 
150 
} 
151  
152 
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) 
153 
{ 
154 
int format;

155  
156 
align_put_bits(&s>pb); 
157  
158 
put_bits(&s>pb, 17, 1); 
159 
put_bits(&s>pb, 5, (s>h263_flv1)); /* 0: h263 escape codes 1: 11bit escape codes */ 
160 
put_bits(&s>pb, 8, (((int64_t)s>picture_number * 30 * s>avctx>frame_rate_base) / 
161 
s>avctx>frame_rate) & 0xff); /* TemporalReference */ 
162 
if (s>width == 352 && s>height == 288) 
163 
format = 2;

164 
else if (s>width == 176 && s>height == 144) 
165 
format = 3;

166 
else if (s>width == 128 && s>height == 96) 
167 
format = 4;

168 
else if (s>width == 320 && s>height == 240) 
169 
format = 5;

170 
else if (s>width == 160 && s>height == 120) 
171 
format = 6;

172 
else if (s>width <= 255 && s>height <= 255) 
173 
format = 0; /* use 1 byte width & height */ 
174 
else

175 
format = 1; /* use 2 bytes width & height */ 
176 
put_bits(&s>pb, 3, format); /* PictureSize */ 
177 
if (format == 0) { 
178 
put_bits(&s>pb, 8, s>width);

179 
put_bits(&s>pb, 8, s>height);

180 
} else if (format == 1) { 
181 
put_bits(&s>pb, 16, s>width);

182 
put_bits(&s>pb, 16, s>height);

183 
} 
184 
put_bits(&s>pb, 2, s>pict_type == P_TYPE); /* PictureType */ 
185 
put_bits(&s>pb, 1, 1); /* DeblockingFlag: on */ 
186 
put_bits(&s>pb, 5, s>qscale); /* Quantizer */ 
187 
put_bits(&s>pb, 1, 0); /* ExtraInformation */ 
188  
189 
if(s>h263_aic){

190 
s>y_dc_scale_table= 
191 
s>c_dc_scale_table= ff_aic_dc_scale_table; 
192 
}else{

193 
s>y_dc_scale_table= 
194 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
195 
} 
196 
} 
197  
198 
void h263_encode_picture_header(MpegEncContext * s, int picture_number) 
199 
{ 
200 
int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;

201 
int best_clock_code=1; 
202 
int best_divisor=60; 
203 
int best_error= INT_MAX;

204 

205 
if(s>h263_plus){

206 
for(i=0; i<2; i++){ 
207 
int div, error;

208 
div= (s>avctx>frame_rate_base*1800000LL + 500LL*s>avctx>frame_rate) / ((1000LL+i)*s>avctx>frame_rate); 
209 
div= clip(1, div, 127); 
210 
error= ABS(s>avctx>frame_rate_base*1800000LL  (1000LL+i)*s>avctx>frame_rate*div); 
211 
if(error < best_error){

212 
best_error= error; 
213 
best_divisor= div; 
214 
best_clock_code= i; 
215 
} 
216 
} 
217 
} 
218 
s>custom_pcf= best_clock_code!=1  best_divisor!=60; 
219 
coded_frame_rate= 1800000;

220 
coded_frame_rate_base= (1000+best_clock_code)*best_divisor;

221  
222 
align_put_bits(&s>pb); 
223  
224 
/* Update the pointer to last GOB */

225 
s>ptr_lastgob = pbBufPtr(&s>pb); 
226 
put_bits(&s>pb, 22, 0x20); /* PSC */ 
227 
temp_ref= s>picture_number * (int64_t)coded_frame_rate * s>avctx>frame_rate_base / 
228 
(coded_frame_rate_base * (int64_t)s>avctx>frame_rate); 
229 
put_bits(&s>pb, 8, temp_ref & 0xff); /* TemporalReference */ 
230  
231 
put_bits(&s>pb, 1, 1); /* marker */ 
232 
put_bits(&s>pb, 1, 0); /* h263 id */ 
233 
put_bits(&s>pb, 1, 0); /* split screen off */ 
234 
put_bits(&s>pb, 1, 0); /* camera off */ 
235 
put_bits(&s>pb, 1, 0); /* freeze picture release off */ 
236 

237 
format = h263_get_picture_format(s>width, s>height); 
238 
if (!s>h263_plus) {

239 
/* H.263v1 */

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

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

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

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

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

245 
put_bits(&s>pb, 1, 0); /* unrestricted motion vector: off */ 
246 
put_bits(&s>pb, 1, 0); /* SAC: off */ 
247 
put_bits(&s>pb, 1, s>obmc); /* advanced prediction mode */ 
248 
put_bits(&s>pb, 1, 0); /* not PB frame */ 
249 
put_bits(&s>pb, 5, s>qscale);

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

252 
int ufep=1; 
253 
/* H.263v2 */

254 
/* H.263 Plus PTYPE */

255 

256 
put_bits(&s>pb, 3, 7); 
257 
put_bits(&s>pb,3,ufep); /* Update Full Extended PTYPE */ 
258 
if (format == 7) 
259 
put_bits(&s>pb,3,6); /* Custom Source Format */ 
260 
else

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

262 

263 
put_bits(&s>pb,1, s>custom_pcf);

264 
put_bits(&s>pb,1, s>umvplus); /* Unrestricted Motion Vector */ 
265 
put_bits(&s>pb,1,0); /* SAC: off */ 
266 
put_bits(&s>pb,1,s>obmc); /* Advanced Prediction Mode */ 
267 
put_bits(&s>pb,1,s>h263_aic); /* Advanced Intra Coding */ 
268 
put_bits(&s>pb,1,s>loop_filter); /* Deblocking Filter */ 
269 
put_bits(&s>pb,1,s>h263_slice_structured); /* Slice Structured */ 
270 
put_bits(&s>pb,1,0); /* Reference Picture Selection: off */ 
271 
put_bits(&s>pb,1,0); /* Independent Segment Decoding: off */ 
272 
put_bits(&s>pb,1,s>alt_inter_vlc); /* Alternative Inter VLC */ 
273 
put_bits(&s>pb,1,s>modified_quant); /* Modified Quantization: */ 
274 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
275 
put_bits(&s>pb,3,0); /* Reserved */ 
276 

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

278 

279 
put_bits(&s>pb,1,0); /* Reference Picture Resampling: off */ 
280 
put_bits(&s>pb,1,0); /* ReducedResolution Update: off */ 
281 
put_bits(&s>pb,1,s>no_rounding); /* Rounding Type */ 
282 
put_bits(&s>pb,2,0); /* Reserved */ 
283 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
284 

285 
/* This should be here if PLUSPTYPE */

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

288 
if (format == 7) { 
289 
/* Custom Picture Format (CPFMT) */

290 
aspect_to_info(s, s>avctx>sample_aspect_ratio); 
291  
292 
put_bits(&s>pb,4,s>aspect_ratio_info);

293 
put_bits(&s>pb,9,(s>width >> 2)  1); 
294 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
295 
put_bits(&s>pb,9,(s>height >> 2)); 
296 
if (s>aspect_ratio_info == FF_ASPECT_EXTENDED){

297 
put_bits(&s>pb, 8, s>avctx>sample_aspect_ratio.num);

298 
put_bits(&s>pb, 8, s>avctx>sample_aspect_ratio.den);

299 
} 
300 
} 
301 
if(s>custom_pcf){

302 
if(ufep){

303 
put_bits(&s>pb, 1, best_clock_code);

304 
put_bits(&s>pb, 7, best_divisor);

305 
} 
306 
put_bits(&s>pb, 2, (temp_ref>>8)&3); 
307 
} 
308 

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

310 
if (s>umvplus)

311 
// put_bits(&s>pb,1,1); /* Limited according tables of Annex D */

312 
//FIXME check actual requested range

313 
put_bits(&s>pb,2,1); /* unlimited */ 
314 
if(s>h263_slice_structured)

315 
put_bits(&s>pb,2,0); /* no weird submodes */ 
316  
317 
put_bits(&s>pb, 5, s>qscale);

318 
} 
319  
320 
put_bits(&s>pb, 1, 0); /* no PEI */ 
321  
322 
if(s>h263_slice_structured){

323 
put_bits(&s>pb, 1, 1); 
324 

325 
assert(s>mb_x == 0 && s>mb_y == 0); 
326 
ff_h263_encode_mba(s); 
327  
328 
put_bits(&s>pb, 1, 1); 
329 
} 
330  
331 
if(s>h263_aic){

332 
s>y_dc_scale_table= 
333 
s>c_dc_scale_table= ff_aic_dc_scale_table; 
334 
}else{

335 
s>y_dc_scale_table= 
336 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
337 
} 
338 
} 
339  
340 
/**

341 
* Encodes a group of blocks header.

342 
*/

343 
void h263_encode_gob_header(MpegEncContext * s, int mb_line) 
344 
{ 
345 
put_bits(&s>pb, 17, 1); /* GBSC */ 
346  
347 
if(s>h263_slice_structured){

348 
put_bits(&s>pb, 1, 1); 
349  
350 
ff_h263_encode_mba(s); 
351  
352 
if(s>mb_num > 1583) 
353 
put_bits(&s>pb, 1, 1); 
354 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
355 
put_bits(&s>pb, 1, 1); 
356 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
357 
}else{

358 
int gob_number= mb_line / s>gob_index;

359  
360 
put_bits(&s>pb, 5, gob_number); /* GN */ 
361 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
362 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
363 
} 
364 
} 
365  
366 
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ 
367 
int last=0; 
368 
int j;

369 
int rate=0; 
370  
371 
for(j=1; j<=block_last_index; j++){ 
372 
const int index= scantable[j]; 
373 
int level= block[index];

374 
if(level){

375 
level+= 64;

376 
if((level&(~127)) == 0){ 
377 
if(j<block_last_index) rate+= s>intra_ac_vlc_length [UNI_AC_ENC_INDEX(jlast1, level)]; 
378 
else rate+= s>intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(jlast1, level)]; 
379 
}else

380 
rate += s>ac_esc_length; 
381 
level= 64;

382  
383 
last= j; 
384 
} 
385 
} 
386 

387 
return rate;

388 
} 
389  
390 
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 
391 
{ 
392 
int score= 0; 
393 
int i, n;

394 
int8_t * const qscale_table= s>current_picture.qscale_table;

395  
396 
memcpy(zigzag_last_index, s>block_last_index, sizeof(int)*6); 
397 

398 
for(n=0; n<6; n++){ 
399 
int16_t *ac_val, *ac_val1; 
400 

401 
score = get_block_rate(s, block[n], s>block_last_index[n], s>intra_scantable.permutated); 
402  
403 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
404 
ac_val1= ac_val; 
405 
if(dir[n]){

406 
const int xy= s>mb_x + s>mb_y*s>mb_stride  s>mb_stride; 
407 
/* top prediction */

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

409 
if(s>mb_y==0  s>qscale == qscale_table[xy]  n==2  n==3){ 
410 
/* same qscale */

411 
for(i=1; i<8; i++){ 
412 
const int level= block[n][s>dsp.idct_permutation[i ]]; 
413 
block[n][s>dsp.idct_permutation[i ]] = level  ac_val[i+8];

414 
ac_val1[i ]= block[n][s>dsp.idct_permutation[i<<3]];

415 
ac_val1[i+8]= level;

416 
} 
417 
}else{

418 
/* different qscale, we must rescale */

419 
for(i=1; i<8; i++){ 
420 
const int level= block[n][s>dsp.idct_permutation[i ]]; 
421 
block[n][s>dsp.idct_permutation[i ]] = level  ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s>qscale);

422 
ac_val1[i ]= block[n][s>dsp.idct_permutation[i<<3]];

423 
ac_val1[i+8]= level;

424 
} 
425 
} 
426 
st[n]= s>intra_h_scantable.permutated; 
427 
}else{

428 
const int xy= s>mb_x1 + s>mb_y*s>mb_stride; 
429 
/* left prediction */

430 
ac_val= 16;

431 
if(s>mb_x==0  s>qscale == qscale_table[xy]  n==1  n==3){ 
432 
/* same qscale */

433 
for(i=1; i<8; i++){ 
434 
const int level= block[n][s>dsp.idct_permutation[i<<3]]; 
435 
block[n][s>dsp.idct_permutation[i<<3]]= level  ac_val[i];

436 
ac_val1[i ]= level; 
437 
ac_val1[i+8]= block[n][s>dsp.idct_permutation[i ]];

438 
} 
439 
}else{

440 
/* different qscale, we must rescale */

441 
for(i=1; i<8; i++){ 
442 
const int level= block[n][s>dsp.idct_permutation[i<<3]]; 
443 
block[n][s>dsp.idct_permutation[i<<3]]= level  ROUNDED_DIV(ac_val[i]*qscale_table[xy], s>qscale);

444 
ac_val1[i ]= level; 
445 
ac_val1[i+8]= block[n][s>dsp.idct_permutation[i ]];

446 
} 
447 
} 
448 
st[n]= s>intra_v_scantable.permutated; 
449 
} 
450  
451 
for(i=63; i>0; i) //FIXME optimize 
452 
if(block[n][ st[n][i] ]) break; 
453 
s>block_last_index[n]= i; 
454  
455 
score += get_block_rate(s, block[n], s>block_last_index[n], st[n]); 
456 
} 
457  
458 
return score < 0; 
459 
} 
460  
461 
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 
462 
{ 
463 
int i, n;

464 
memcpy(s>block_last_index, zigzag_last_index, sizeof(int)*6); 
465  
466 
for(n=0; n<6; n++){ 
467 
int16_t *ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
468  
469 
st[n]= s>intra_scantable.permutated; 
470 
if(dir[n]){

471 
/* top prediction */

472 
for(i=1; i<8; i++){ 
473 
block[n][s>dsp.idct_permutation[i ]] = ac_val[i+8];

474 
} 
475 
}else{

476 
/* left prediction */

477 
for(i=1; i<8; i++){ 
478 
block[n][s>dsp.idct_permutation[i<<3]]= ac_val[i ];

479 
} 
480 
} 
481 
} 
482 
} 
483  
484 
/**

485 
* modify qscale so that encoding is acually possible in h263 (limit difference to 2..2)

486 
*/

487 
void ff_clean_h263_qscales(MpegEncContext *s){

488 
int i;

489 
int8_t * const qscale_table= s>current_picture.qscale_table;

490 

491 
for(i=1; i<s>mb_num; i++){ 
492 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i1] ] >2) 
493 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i1] ]+2; 
494 
} 
495 
for(i=s>mb_num2; i>=0; i){ 
496 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i+1] ] >2) 
497 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i+1] ]+2; 
498 
} 
499 
} 
500  
501 
/**

502 
* modify mb_type & qscale so that encoding is acually possible in mpeg4

503 
*/

504 
void ff_clean_mpeg4_qscales(MpegEncContext *s){

505 
int i;

506 
int8_t * const qscale_table= s>current_picture.qscale_table;

507  
508 
ff_clean_h263_qscales(s); 
509 

510 
for(i=1; i<s>mb_num; i++){ 
511 
int mb_xy= s>mb_index2xy[i];

512 

513 
if(qscale_table[mb_xy] != qscale_table[s>mb_index2xy[i1]] && (s>mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ 
514 
s>mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V; 
515 
s>mb_type[mb_xy]= CANDIDATE_MB_TYPE_INTER; 
516 
} 
517 
} 
518  
519 
if(s>pict_type== B_TYPE){

520 
int odd=0; 
521 
/* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than

522 
for the actual adaptive quantization */

523 

524 
for(i=0; i<s>mb_num; i++){ 
525 
int mb_xy= s>mb_index2xy[i];

526 
odd += qscale_table[mb_xy]&1;

527 
} 
528 

529 
if(2*odd > s>mb_num) odd=1; 
530 
else odd=0; 
531 

532 
for(i=0; i<s>mb_num; i++){ 
533 
int mb_xy= s>mb_index2xy[i];

534 
if((qscale_table[mb_xy]&1) != odd) 
535 
qscale_table[mb_xy]++; 
536 
if(qscale_table[mb_xy] > 31) 
537 
qscale_table[mb_xy]= 31;

538 
} 
539 

540 
for(i=1; i<s>mb_num; i++){ 
541 
int mb_xy= s>mb_index2xy[i];

542 
if(qscale_table[mb_xy] != qscale_table[s>mb_index2xy[i1]] && (s>mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ 
543 
s>mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT; 
544 
s>mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR; 
545 
} 
546 
} 
547 
} 
548 
} 
549  
550 
#endif //CONFIG_ENCODERS 
551 
/**

552 
*

553 
* @return the mb_type

554 
*/

555 
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ 
556 
const int mb_index= s>mb_x + s>mb_y*s>mb_stride; 
557 
const int colocated_mb_type= s>next_picture.mb_type[mb_index]; 
558 
int xy= s>block_index[0]; 
559 
uint16_t time_pp= s>pp_time; 
560 
uint16_t time_pb= s>pb_time; 
561 
int i;

562 

563 
//FIXME avoid divides

564 

565 
if(IS_8X8(colocated_mb_type)){

566 
s>mv_type = MV_TYPE_8X8; 
567 
for(i=0; i<4; i++){ 
568 
xy= s>block_index[i]; 
569 
s>mv[0][i][0] = s>next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx; 
570 
s>mv[0][i][1] = s>next_picture.motion_val[0][xy][1]*time_pb/time_pp + my; 
571 
s>mv[1][i][0] = mx ? s>mv[0][i][0]  s>next_picture.motion_val[0][xy][0] 
572 
: s>next_picture.motion_val[0][xy][0]*(time_pb  time_pp)/time_pp; 
573 
s>mv[1][i][1] = my ? s>mv[0][i][1]  s>next_picture.motion_val[0][xy][1] 
574 
: s>next_picture.motion_val[0][xy][1]*(time_pb  time_pp)/time_pp; 
575 
} 
576 
return MB_TYPE_DIRECT2  MB_TYPE_8x8  MB_TYPE_L0L1;

577 
} else if(IS_INTERLACED(colocated_mb_type)){ 
578 
s>mv_type = MV_TYPE_FIELD; 
579 
for(i=0; i<2; i++){ 
580 
if(s>top_field_first){

581 
time_pp= s>pp_field_time  s>p_field_select_table[i][mb_index] + i; 
582 
time_pb= s>pb_field_time  s>p_field_select_table[i][mb_index] + i; 
583 
}else{

584 
time_pp= s>pp_field_time + s>p_field_select_table[i][mb_index]  i; 
585 
time_pb= s>pb_field_time + s>p_field_select_table[i][mb_index]  i; 
586 
} 
587 
s>mv[0][i][0] = s>p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; 
588 
s>mv[0][i][1] = s>p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; 
589 
s>mv[1][i][0] = mx ? s>mv[0][i][0]  s>p_field_mv_table[i][0][mb_index][0] 
590 
: s>p_field_mv_table[i][0][mb_index][0]*(time_pb  time_pp)/time_pp; 
591 
s>mv[1][i][1] = my ? s>mv[0][i][1]  s>p_field_mv_table[i][0][mb_index][1] 
592 
: s>p_field_mv_table[i][0][mb_index][1]*(time_pb  time_pp)/time_pp; 
593 
} 
594 
return MB_TYPE_DIRECT2  MB_TYPE_16x8  MB_TYPE_L0L1  MB_TYPE_INTERLACED;

595 
}else{

596 
s>mv[0][0][0] = s>mv[0][1][0] = s>mv[0][2][0] = s>mv[0][3][0] = s>next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx; 
597 
s>mv[0][0][1] = s>mv[0][1][1] = s>mv[0][2][1] = s>mv[0][3][1] = s>next_picture.motion_val[0][xy][1]*time_pb/time_pp + my; 
598 
s>mv[1][0][0] = s>mv[1][1][0] = s>mv[1][2][0] = s>mv[1][3][0] = mx ? s>mv[0][0][0]  s>next_picture.motion_val[0][xy][0] 
599 
: s>next_picture.motion_val[0][xy][0]*(time_pb  time_pp)/time_pp; 
600 
s>mv[1][0][1] = s>mv[1][1][1] = s>mv[1][2][1] = s>mv[1][3][1] = my ? s>mv[0][0][1]  s>next_picture.motion_val[0][xy][1] 
601 
: s>next_picture.motion_val[0][xy][1]*(time_pb  time_pp)/time_pp; 
602 
if((s>avctx>workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE)  !s>quarter_sample)

603 
s>mv_type= MV_TYPE_16X16; 
604 
else

605 
s>mv_type= MV_TYPE_8X8; 
606 
return MB_TYPE_DIRECT2  MB_TYPE_16x16  MB_TYPE_L0L1; //Note see prev line 
607 
} 
608 
} 
609  
610 
void ff_h263_update_motion_val(MpegEncContext * s){

611 
const int mb_xy = s>mb_y * s>mb_stride + s>mb_x; 
612 
//FIXME a lot of thet is only needed for !low_delay

613 
const int wrap = s>block_wrap[0]; 
614 
const int xy = s>block_index[0]; 
615 

616 
s>current_picture.mbskip_table[mb_xy]= s>mb_skiped; 
617  
618 
if(s>mv_type != MV_TYPE_8X8){

619 
int motion_x, motion_y;

620 
if (s>mb_intra) {

621 
motion_x = 0;

622 
motion_y = 0;

623 
} else if (s>mv_type == MV_TYPE_16X16) { 
624 
motion_x = s>mv[0][0][0]; 
625 
motion_y = s>mv[0][0][1]; 
626 
} else /*if (s>mv_type == MV_TYPE_FIELD)*/ { 
627 
int i;

628 
motion_x = s>mv[0][0][0] + s>mv[0][1][0]; 
629 
motion_y = s>mv[0][0][1] + s>mv[0][1][1]; 
630 
motion_x = (motion_x>>1)  (motion_x&1); 
631 
for(i=0; i<2; i++){ 
632 
s>p_field_mv_table[i][0][mb_xy][0]= s>mv[0][i][0]; 
633 
s>p_field_mv_table[i][0][mb_xy][1]= s>mv[0][i][1]; 
634 
s>p_field_select_table[i][mb_xy]= s>field_select[0][i];

635 
} 
636 
} 
637 

638 
/* no update if 8X8 because it has been done during parsing */

639 
s>current_picture.motion_val[0][xy][0] = motion_x; 
640 
s>current_picture.motion_val[0][xy][1] = motion_y; 
641 
s>current_picture.motion_val[0][xy + 1][0] = motion_x; 
642 
s>current_picture.motion_val[0][xy + 1][1] = motion_y; 
643 
s>current_picture.motion_val[0][xy + wrap][0] = motion_x; 
644 
s>current_picture.motion_val[0][xy + wrap][1] = motion_y; 
645 
s>current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; 
646 
s>current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; 
647 
} 
648  
649 
if(s>encoding){ //FIXME encoding MUST be cleaned up 
650 
if (s>mv_type == MV_TYPE_8X8)

651 
s>current_picture.mb_type[mb_xy]= MB_TYPE_L0  MB_TYPE_8x8; 
652 
else if(s>mb_intra) 
653 
s>current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; 
654 
else

655 
s>current_picture.mb_type[mb_xy]= MB_TYPE_L0  MB_TYPE_16x16; 
656 
} 
657 
} 
658  
659 
#ifdef CONFIG_ENCODERS

660  
661 
static inline int get_p_cbp(MpegEncContext * s, 
662 
DCTELEM block[6][64], 
663 
int motion_x, int motion_y){ 
664 
int cbp, i;

665  
666 
if(s>flags & CODEC_FLAG_CBP_RD){

667 
int best_cbpy_score= INT_MAX;

668 
int best_cbpc_score= INT_MAX;

669 
int cbpc = (1), cbpy= (1); 
670 
const int offset= (s>mv_type==MV_TYPE_16X16 ? 0 : 16) + (s>dquant ? 8 : 0); 
671 
const int lambda= s>lambda2 >> (FF_LAMBDA_SHIFT  6); 
672  
673 
for(i=0; i<4; i++){ 
674 
int score= inter_MCBPC_bits[i + offset] * lambda;

675 
if(i&1) score += s>coded_score[5]; 
676 
if(i&2) score += s>coded_score[4]; 
677  
678 
if(score < best_cbpc_score){

679 
best_cbpc_score= score; 
680 
cbpc= i; 
681 
} 
682 
} 
683  
684 
for(i=0; i<16; i++){ 
685 
int score= cbpy_tab[i ^ 0xF][1] * lambda; 
686 
if(i&1) score += s>coded_score[3]; 
687 
if(i&2) score += s>coded_score[2]; 
688 
if(i&4) score += s>coded_score[1]; 
689 
if(i&8) score += s>coded_score[0]; 
690  
691 
if(score < best_cbpy_score){

692 
best_cbpy_score= score; 
693 
cbpy= i; 
694 
} 
695 
} 
696 
cbp= cbpc + 4*cbpy;

697 
if ((motion_x  motion_y  s>dquant) == 0 && s>mv_type==MV_TYPE_16X16){ 
698 
if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) 
699 
cbp= 0;

700 
} 
701  
702 
for (i = 0; i < 6; i++) { 
703 
if (s>block_last_index[i] >= 0 && ((cbp >> (5  i))&1)==0 ){ 
704 
s>block_last_index[i]= 1;

705 
memset(s>block[i], 0, sizeof(DCTELEM)*64); 
706 
} 
707 
} 
708 
}else{

709 
cbp= 0;

710 
for (i = 0; i < 6; i++) { 
711 
if (s>block_last_index[i] >= 0) 
712 
cbp = 1 << (5  i); 
713 
} 
714 
} 
715 
return cbp;

716 
} 
717  
718 
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], 
719 
int motion_x, int motion_y, int mb_type){ 
720 
int cbp=0, i; 
721  
722 
if(s>flags & CODEC_FLAG_CBP_RD){

723 
int score=0; 
724 
const int lambda= s>lambda2 >> (FF_LAMBDA_SHIFT  6); 
725 

726 
for(i=0; i<6; i++){ 
727 
if(s>coded_score[i] < 0){ 
728 
score += s>coded_score[i]; 
729 
cbp = 1 << (5  i); 
730 
} 
731 
} 
732 

733 
if(cbp){

734 
int zero_score= 6; 
735 
if ((motion_x  motion_y  s>dquant  mb_type) == 0){ 
736 
zero_score= 4; //2*MV + mb_type + cbp bit 
737 
} 
738  
739 
zero_score*= lambda; 
740 
if(zero_score <= score){

741 
cbp=0;

742 
} 
743 
} 
744  
745 
for (i = 0; i < 6; i++) { 
746 
if (s>block_last_index[i] >= 0 && ((cbp >> (5  i))&1)==0 ){ 
747 
s>block_last_index[i]= 1;

748 
memset(s>block[i], 0, sizeof(DCTELEM)*64); 
749 
} 
750 
} 
751 
}else{

752 
for (i = 0; i < 6; i++) { 
753 
if (s>block_last_index[i] >= 0) 
754 
cbp = 1 << (5  i); 
755 
} 
756 
} 
757 
return cbp;

758 
} 
759  
760 
void mpeg4_encode_mb(MpegEncContext * s,

761 
DCTELEM block[6][64], 
762 
int motion_x, int motion_y) 
763 
{ 
764 
int cbpc, cbpy, pred_x, pred_y;

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

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

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

768 
const int interleaved_stats= (s>flags&CODEC_FLAG_PASS1) && !s>data_partitioning ? 1 : 0; 
769 
const int dquant_code[5]= {1,0,9,2,3}; 
770 

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

772 
if (!s>mb_intra) {

773 
int i, cbp;

774 

775 
if(s>pict_type==B_TYPE){

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

778  
779 
if(s>mb_x==0){ 
780 
for(i=0; i<2; i++){ 
781 
s>last_mv[i][0][0]= 
782 
s>last_mv[i][0][1]= 
783 
s>last_mv[i][1][0]= 
784 
s>last_mv[i][1][1]= 0; 
785 
} 
786 
} 
787 

788 
assert(s>dquant>=2 && s>dquant<=2); 
789 
assert((s>dquant&1)==0); 
790 
assert(mb_type>=0);

791  
792 
/* nothing to do if this MB was skiped in the next P Frame */

793 
if(s>next_picture.mbskip_table[s>mb_y * s>mb_stride + s>mb_x]){ //FIXME avoid DCT & ... 
794 
s>skip_count++; 
795 
s>mv[0][0][0]= 
796 
s>mv[0][0][1]= 
797 
s>mv[1][0][0]= 
798 
s>mv[1][0][1]= 0; 
799 
s>mv_dir= MV_DIR_FORWARD; //doesnt matter

800 
s>qscale = s>dquant; 
801 
// s>mb_skiped=1;

802  
803 
return;

804 
} 
805 

806 
cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); 
807 

808 
if ((cbp  motion_x  motion_y  mb_type) ==0) { 
809 
/* direct MB with MV={0,0} */

810 
assert(s>dquant==0);

811 

812 
put_bits(&s>pb, 1, 1); /* mb not coded modb1=1 */ 
813  
814 
if(interleaved_stats){

815 
s>misc_bits++; 
816 
s>last_bits++; 
817 
} 
818 
s>skip_count++; 
819 
return;

820 
} 
821 

822 
put_bits(&s>pb, 1, 0); /* mb coded modb1=0 */ 
823 
put_bits(&s>pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge 
824 
put_bits(&s>pb, mb_type+1, 1); // this table is so simple that we dont need it :) 
825 
if(cbp) put_bits(&s>pb, 6, cbp); 
826 

827 
if(cbp && mb_type){

828 
if(s>dquant)

829 
put_bits(&s>pb, 2, (s>dquant>>2)+3); 
830 
else

831 
put_bits(&s>pb, 1, 0); 
832 
}else

833 
s>qscale = s>dquant; 
834 

835 
if(!s>progressive_sequence){

836 
if(cbp)

837 
put_bits(&s>pb, 1, s>interlaced_dct);

838 
if(mb_type) // not diect mode 
839 
put_bits(&s>pb, 1, s>mv_type == MV_TYPE_FIELD);

840 
} 
841  
842 
if(interleaved_stats){

843 
s>misc_bits+= get_bits_diff(s); 
844 
} 
845  
846 
if(mb_type == 0){ 
847 
assert(s>mv_dir & MV_DIRECT); 
848 
h263_encode_motion(s, motion_x, 1);

849 
h263_encode_motion(s, motion_y, 1);

850 
s>b_count++; 
851 
s>f_count++; 
852 
}else{

853 
assert(mb_type > 0 && mb_type < 4); 
854 
if(s>mv_type != MV_TYPE_FIELD){

855 
if(s>mv_dir & MV_DIR_FORWARD){

856 
h263_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
857 
h263_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
858 
s>last_mv[0][0][0]= s>last_mv[0][1][0]= s>mv[0][0][0]; 
859 
s>last_mv[0][0][1]= s>last_mv[0][1][1]= s>mv[0][0][1]; 
860 
s>f_count++; 
861 
} 
862 
if(s>mv_dir & MV_DIR_BACKWARD){

863 
h263_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
864 
h263_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
865 
s>last_mv[1][0][0]= s>last_mv[1][1][0]= s>mv[1][0][0]; 
866 
s>last_mv[1][0][1]= s>last_mv[1][1][1]= s>mv[1][0][1]; 
867 
s>b_count++; 
868 
} 
869 
}else{

870 
if(s>mv_dir & MV_DIR_FORWARD){

871 
put_bits(&s>pb, 1, s>field_select[0][0]); 
872 
put_bits(&s>pb, 1, s>field_select[0][1]); 
873 
} 
874 
if(s>mv_dir & MV_DIR_BACKWARD){

875 
put_bits(&s>pb, 1, s>field_select[1][0]); 
876 
put_bits(&s>pb, 1, s>field_select[1][1]); 
877 
} 
878 
if(s>mv_dir & MV_DIR_FORWARD){

879 
for(i=0; i<2; i++){ 
880 
h263_encode_motion(s, s>mv[0][i][0]  s>last_mv[0][i][0] , s>f_code); 
881 
h263_encode_motion(s, s>mv[0][i][1]  s>last_mv[0][i][1]/2, s>f_code); 
882 
s>last_mv[0][i][0]= s>mv[0][i][0]; 
883 
s>last_mv[0][i][1]= s>mv[0][i][1]*2; 
884 
} 
885 
s>f_count++; 
886 
} 
887 
if(s>mv_dir & MV_DIR_BACKWARD){

888 
for(i=0; i<2; i++){ 
889 
h263_encode_motion(s, s>mv[1][i][0]  s>last_mv[1][i][0] , s>b_code); 
890 
h263_encode_motion(s, s>mv[1][i][1]  s>last_mv[1][i][1]/2, s>b_code); 
891 
s>last_mv[1][i][0]= s>mv[1][i][0]; 
892 
s>last_mv[1][i][1]= s>mv[1][i][1]*2; 
893 
} 
894 
s>b_count++; 
895 
} 
896 
} 
897 
} 
898  
899 
if(interleaved_stats){

900 
s>mv_bits+= get_bits_diff(s); 
901 
} 
902  
903 
/* encode each block */

904 
for (i = 0; i < 6; i++) { 
905 
mpeg4_encode_block(s, block[i], i, 0, s>intra_scantable.permutated, NULL, &s>pb); 
906 
} 
907  
908 
if(interleaved_stats){

909 
s>p_tex_bits+= get_bits_diff(s); 
910 
} 
911  
912 
}else{ /* s>pict_type==B_TYPE */ 
913 
cbp= get_p_cbp(s, block, motion_x, motion_y); 
914 

915 
if ((cbp  motion_x  motion_y  s>dquant) == 0 && s>mv_type==MV_TYPE_16X16) { 
916 
/* check if the B frames can skip it too, as we must skip it if we skip here

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

918 
if(s>max_b_frames>0){ 
919 
int i;

920 
int x,y, offset;

921 
uint8_t *p_pic; 
922  
923 
x= s>mb_x*16;

924 
y= s>mb_y*16;

925 
if(x+16 > s>width) x= s>width16; 
926 
if(y+16 > s>height) y= s>height16; 
927  
928 
offset= x + y*s>linesize; 
929 
p_pic= s>new_picture.data[0] + offset;

930 

931 
s>mb_skiped=1;

932 
for(i=0; i<s>max_b_frames; i++){ 
933 
uint8_t *b_pic; 
934 
int diff;

935 
Picture *pic= s>reordered_input_picture[i+1];

936  
937 
if(pic==NULL  pic>pict_type!=B_TYPE) break; 
938  
939 
b_pic= pic>data[0] + offset + 16; //FIXME +16 
940 
diff= s>dsp.sad[0](NULL, p_pic, b_pic, s>linesize, 16); 
941 
if(diff>s>qscale*70){ //FIXME check that 70 is optimal 
942 
s>mb_skiped=0;

943 
break;

944 
} 
945 
} 
946 
}else

947 
s>mb_skiped=1;

948  
949 
if(s>mb_skiped==1){ 
950 
/* skip macroblock */

951 
put_bits(&s>pb, 1, 1); 
952  
953 
if(interleaved_stats){

954 
s>misc_bits++; 
955 
s>last_bits++; 
956 
} 
957 
s>skip_count++; 
958 

959 
return;

960 
} 
961 
} 
962  
963 
put_bits(&s>pb, 1, 0); /* mb coded */ 
964 
cbpc = cbp & 3;

965 
cbpy = cbp >> 2;

966 
cbpy ^= 0xf;

967 
if(s>mv_type==MV_TYPE_16X16){

968 
if(s>dquant) cbpc+= 8; 
969 
put_bits(&s>pb, 
970 
inter_MCBPC_bits[cbpc], 
971 
inter_MCBPC_code[cbpc]); 
972  
973 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
974 
if(s>dquant)

975 
put_bits(pb2, 2, dquant_code[s>dquant+2]); 
976  
977 
if(!s>progressive_sequence){

978 
if(cbp)

979 
put_bits(pb2, 1, s>interlaced_dct);

980 
put_bits(pb2, 1, 0); 
981 
} 
982 

983 
if(interleaved_stats){

984 
s>misc_bits+= get_bits_diff(s); 
985 
} 
986  
987 
/* motion vectors: 16x16 mode */

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

989 

990 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
991 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
992 
}else if(s>mv_type==MV_TYPE_FIELD){ 
993 
if(s>dquant) cbpc+= 8; 
994 
put_bits(&s>pb, 
995 
inter_MCBPC_bits[cbpc], 
996 
inter_MCBPC_code[cbpc]); 
997  
998 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
999 
if(s>dquant)

1000 
put_bits(pb2, 2, dquant_code[s>dquant+2]); 
1001  
1002 
assert(!s>progressive_sequence); 
1003 
if(cbp)

1004 
put_bits(pb2, 1, s>interlaced_dct);

1005 
put_bits(pb2, 1, 1); 
1006 

1007 
if(interleaved_stats){

1008 
s>misc_bits+= get_bits_diff(s); 
1009 
} 
1010  
1011 
/* motion vectors: 16x8 interlaced mode */

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

1013 
pred_y /=2;

1014 

1015 
put_bits(&s>pb, 1, s>field_select[0][0]); 
1016 
put_bits(&s>pb, 1, s>field_select[0][1]); 
1017 

1018 
h263_encode_motion(s, s>mv[0][0][0]  pred_x, s>f_code); 
1019 
h263_encode_motion(s, s>mv[0][0][1]  pred_y, s>f_code); 
1020 
h263_encode_motion(s, s>mv[0][1][0]  pred_x, s>f_code); 
1021 
h263_encode_motion(s, s>mv[0][1][1]  pred_y, s>f_code); 
1022 
}else{

1023 
assert(s>mv_type==MV_TYPE_8X8); 
1024 
put_bits(&s>pb, 
1025 
inter_MCBPC_bits[cbpc+16],

1026 
inter_MCBPC_code[cbpc+16]);

1027 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1028  
1029 
if(!s>progressive_sequence){

1030 
if(cbp)

1031 
put_bits(pb2, 1, s>interlaced_dct);

1032 
} 
1033 

1034 
if(interleaved_stats){

1035 
s>misc_bits+= get_bits_diff(s); 
1036 
} 
1037  
1038 
for(i=0; i<4; i++){ 
1039 
/* motion vectors: 8x8 mode*/

1040 
h263_pred_motion(s, i, &pred_x, &pred_y); 
1041  
1042 
h263_encode_motion(s, s>current_picture.motion_val[0][ s>block_index[i] ][0]  pred_x, s>f_code); 
1043 
h263_encode_motion(s, s>current_picture.motion_val[0][ s>block_index[i] ][1]  pred_y, s>f_code); 
1044 
} 
1045 
} 
1046  
1047 
if(interleaved_stats){

1048 
s>mv_bits+= get_bits_diff(s); 
1049 
} 
1050  
1051 
/* encode each block */

1052 
for (i = 0; i < 6; i++) { 
1053 
mpeg4_encode_block(s, block[i], i, 0, s>intra_scantable.permutated, NULL, tex_pb); 
1054 
} 
1055  
1056 
if(interleaved_stats){

1057 
s>p_tex_bits+= get_bits_diff(s); 
1058 
} 
1059 
s>f_count++; 
1060 
} 
1061 
} else {

1062 
int cbp;

1063 
int dc_diff[6]; //dc values with the dc prediction subtracted 
1064 
int dir[6]; //prediction direction 
1065 
int zigzag_last_index[6]; 
1066 
uint8_t *scan_table[6];

1067 
int i;

1068  
1069 
for(i=0; i<6; i++){ 
1070 
const int level= block[i][0]; 
1071 
uint16_t *dc_ptr; 
1072  
1073 
dc_diff[i]= level  ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); 
1074 
if (i < 4) { 
1075 
*dc_ptr = level * s>y_dc_scale; 
1076 
} else {

1077 
*dc_ptr = level * s>c_dc_scale; 
1078 
} 
1079 
} 
1080  
1081 
if(s>flags & CODEC_FLAG_AC_PRED){

1082 
s>ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); 
1083 
if(!s>ac_pred)

1084 
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 
1085 
}else{

1086 
for(i=0; i<6; i++) 
1087 
scan_table[i]= s>intra_scantable.permutated; 
1088 
} 
1089  
1090 
/* compute cbp */

1091 
cbp = 0;

1092 
for (i = 0; i < 6; i++) { 
1093 
if (s>block_last_index[i] >= 1) 
1094 
cbp = 1 << (5  i); 
1095 
} 
1096  
1097 
cbpc = cbp & 3;

1098 
if (s>pict_type == I_TYPE) {

1099 
if(s>dquant) cbpc+=4; 
1100 
put_bits(&s>pb, 
1101 
intra_MCBPC_bits[cbpc], 
1102 
intra_MCBPC_code[cbpc]); 
1103 
} else {

1104 
if(s>dquant) cbpc+=8; 
1105 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1106 
put_bits(&s>pb, 
1107 
inter_MCBPC_bits[cbpc + 4],

1108 
inter_MCBPC_code[cbpc + 4]);

1109 
} 
1110 
put_bits(pb2, 1, s>ac_pred);

1111 
cbpy = cbp >> 2;

1112 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1113 
if(s>dquant)

1114 
put_bits(dc_pb, 2, dquant_code[s>dquant+2]); 
1115  
1116 
if(!s>progressive_sequence){

1117 
put_bits(dc_pb, 1, s>interlaced_dct);

1118 
} 
1119  
1120 
if(interleaved_stats){

1121 
s>misc_bits+= get_bits_diff(s); 
1122 
} 
1123  
1124 
/* encode each block */

1125 
for (i = 0; i < 6; i++) { 
1126 
mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); 
1127 
} 
1128  
1129 
if(interleaved_stats){

1130 
s>i_tex_bits+= get_bits_diff(s); 
1131 
} 
1132 
s>i_count++; 
1133  
1134 
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */

1135 
if(s>ac_pred)

1136 
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 
1137 
} 
1138 
} 
1139  
1140 
void h263_encode_mb(MpegEncContext * s,

1141 
DCTELEM block[6][64], 
1142 
int motion_x, int motion_y) 
1143 
{ 
1144 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

1145 
int16_t pred_dc; 
1146 
int16_t rec_intradc[6];

1147 
uint16_t *dc_ptr[6];

1148 
const int interleaved_stats= (s>flags&CODEC_FLAG_PASS1); 
1149 
const int dquant_code[5]= {1,0,9,2,3}; 
1150 

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

1152 
if (!s>mb_intra) {

1153 
/* compute cbp */

1154 
cbp= get_p_cbp(s, block, motion_x, motion_y); 
1155  
1156 
if ((cbp  motion_x  motion_y  s>dquant  (s>mv_type  MV_TYPE_16X16)) == 0) { 
1157 
/* skip macroblock */

1158 
put_bits(&s>pb, 1, 1); 
1159 
if(interleaved_stats){

1160 
s>misc_bits++; 
1161 
s>last_bits++; 
1162 
} 
1163 
s>skip_count++; 
1164  
1165 
return;

1166 
} 
1167 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1168 

1169 
cbpc = cbp & 3;

1170 
cbpy = cbp >> 2;

1171 
if(s>alt_inter_vlc==0  cbpc!=3) 
1172 
cbpy ^= 0xF;

1173 
if(s>dquant) cbpc+= 8; 
1174 
if(s>mv_type==MV_TYPE_16X16){

1175 
put_bits(&s>pb, 
1176 
inter_MCBPC_bits[cbpc], 
1177 
inter_MCBPC_code[cbpc]); 
1178  
1179 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1180 
if(s>dquant)

1181 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1182 

1183 
if(interleaved_stats){

1184 
s>misc_bits+= get_bits_diff(s); 
1185 
} 
1186  
1187 
/* motion vectors: 16x16 mode */

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

1189 

1190 
if (!s>umvplus) {

1191 
h263_encode_motion(s, motion_x  pred_x, 1);

1192 
h263_encode_motion(s, motion_y  pred_y, 1);

1193 
} 
1194 
else {

1195 
h263p_encode_umotion(s, motion_x  pred_x); 
1196 
h263p_encode_umotion(s, motion_y  pred_y); 
1197 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
1198 
/* To prevent Start Code emulation */

1199 
put_bits(&s>pb,1,1); 
1200 
} 
1201 
}else{

1202 
put_bits(&s>pb, 
1203 
inter_MCBPC_bits[cbpc+16],

1204 
inter_MCBPC_code[cbpc+16]);

1205 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1206 
if(s>dquant)

1207 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1208  
1209 
if(interleaved_stats){

1210 
s>misc_bits+= get_bits_diff(s); 
1211 
} 
1212  
1213 
for(i=0; i<4; i++){ 
1214 
/* motion vectors: 8x8 mode*/

1215 
h263_pred_motion(s, i, &pred_x, &pred_y); 
1216  
1217 
motion_x= s>current_picture.motion_val[0][ s>block_index[i] ][0]; 
1218 
motion_y= s>current_picture.motion_val[0][ s>block_index[i] ][1]; 
1219 
if (!s>umvplus) {

1220 
h263_encode_motion(s, motion_x  pred_x, 1);

1221 
h263_encode_motion(s, motion_y  pred_y, 1);

1222 
} 
1223 
else {

1224 
h263p_encode_umotion(s, motion_x  pred_x); 
1225 
h263p_encode_umotion(s, motion_y  pred_y); 
1226 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
1227 
/* To prevent Start Code emulation */

1228 
put_bits(&s>pb,1,1); 
1229 
} 
1230 
} 
1231 
} 
1232  
1233 
if(interleaved_stats){

1234 
s>mv_bits+= get_bits_diff(s); 
1235 
} 
1236 
} else {

1237 
assert(s>mb_intra); 
1238 

1239 
cbp = 0;

1240 
if (s>h263_aic) {

1241 
/* Predict DC */

1242 
for(i=0; i<6; i++) { 
1243 
int16_t level = block[i][0];

1244 
int scale;

1245 

1246 
if(i<4) scale= s>y_dc_scale; 
1247 
else scale= s>c_dc_scale;

1248  
1249 
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); 
1250 
level = pred_dc; 
1251 
/* Quant */

1252 
if (level >= 0) 
1253 
level = (level + (scale>>1))/scale;

1254 
else

1255 
level = (level  (scale>>1))/scale;

1256 

1257 
/* AIC can change CBP */

1258 
if (level == 0 && s>block_last_index[i] == 0) 
1259 
s>block_last_index[i] = 1;

1260  
1261 
if(!s>modified_quant){

1262 
if (level < 127) 
1263 
level = 127;

1264 
else if (level > 127) 
1265 
level = 127;

1266 
} 
1267  
1268 
block[i][0] = level;

1269 
/* Reconstruction */

1270 
rec_intradc[i] = scale*level + pred_dc; 
1271 
/* Oddify */

1272 
rec_intradc[i] = 1;

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

1274 
// rec_intradc[i]++;

1275 
/* Clipping */

1276 
if (rec_intradc[i] < 0) 
1277 
rec_intradc[i] = 0;

1278 
else if (rec_intradc[i] > 2047) 
1279 
rec_intradc[i] = 2047;

1280 

1281 
/* Update AC/DC tables */

1282 
*dc_ptr[i] = rec_intradc[i]; 
1283 
if (s>block_last_index[i] >= 0) 
1284 
cbp = 1 << (5  i); 
1285 
} 
1286 
}else{

1287 
for(i=0; i<6; i++) { 
1288 
/* compute cbp */

1289 
if (s>block_last_index[i] >= 1) 
1290 
cbp = 1 << (5  i); 
1291 
} 
1292 
} 
1293  
1294 
cbpc = cbp & 3;

1295 
if (s>pict_type == I_TYPE) {

1296 
if(s>dquant) cbpc+=4; 
1297 
put_bits(&s>pb, 
1298 
intra_MCBPC_bits[cbpc], 
1299 
intra_MCBPC_code[cbpc]); 
1300 
} else {

1301 
if(s>dquant) cbpc+=8; 
1302 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1303 
put_bits(&s>pb, 
1304 
inter_MCBPC_bits[cbpc + 4],

1305 
inter_MCBPC_code[cbpc + 4]);

1306 
} 
1307 
if (s>h263_aic) {

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

1309 
put_bits(&s>pb, 1, 0); /* no AC prediction */ 
1310 
} 
1311 
cbpy = cbp >> 2;

1312 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1313 
if(s>dquant)

1314 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1315  
1316 
if(interleaved_stats){

1317 
s>misc_bits+= get_bits_diff(s); 
1318 
} 
1319 
} 
1320  
1321 
for(i=0; i<6; i++) { 
1322 
/* encode each block */

1323 
h263_encode_block(s, block[i], i); 
1324 

1325 
/* Update INTRADC for decoding */

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

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

1328 

1329 
} 
1330 
} 
1331  
1332 
if(interleaved_stats){

1333 
if (!s>mb_intra) {

1334 
s>p_tex_bits+= get_bits_diff(s); 
1335 
s>f_count++; 
1336 
}else{

1337 
s>i_tex_bits+= get_bits_diff(s); 
1338 
s>i_count++; 
1339 
} 
1340 
} 
1341 
} 
1342 
#endif

1343  
1344 
void ff_h263_loop_filter(MpegEncContext * s){

1345 
int qp_c;

1346 
const int linesize = s>linesize; 
1347 
const int uvlinesize= s>uvlinesize; 
1348 
const int xy = s>mb_y * s>mb_stride + s>mb_x; 
1349 
uint8_t *dest_y = s>dest[0];

1350 
uint8_t *dest_cb= s>dest[1];

1351 
uint8_t *dest_cr= s>dest[2];

1352 

1353 
// if(s>pict_type==B_TYPE && !s>readable) return;

1354  
1355 
/*

1356 
Diag Top

1357 
Left Center

1358 
*/

1359 
if(!IS_SKIP(s>current_picture.mb_type[xy])){

1360 
qp_c= s>qscale; 
1361 
s>dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);

1362 
s>dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); 
1363 
}else

1364 
qp_c= 0;

1365  
1366 
if(s>mb_y){

1367 
int qp_dt, qp_t, qp_tc;

1368  
1369 
if(IS_SKIP(s>current_picture.mb_type[xys>mb_stride]))

1370 
qp_t=0;

1371 
else

1372 
qp_t= s>current_picture.qscale_table[xys>mb_stride]; 
1373  
1374 
if(qp_c)

1375 
qp_tc= qp_c; 
1376 
else

1377 
qp_tc= qp_t; 
1378 

1379 
if(qp_tc){

1380 
const int chroma_qp= s>chroma_qscale_table[qp_tc]; 
1381 
s>dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); 
1382 
s>dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);

1383 

1384 
s>dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); 
1385 
s>dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); 
1386 
} 
1387 

1388 
if(qp_t)

1389 
s>dsp.h263_h_loop_filter(dest_y8*linesize+8 , linesize, qp_t); 
1390 

1391 
if(s>mb_x){

1392 
if(qp_t  IS_SKIP(s>current_picture.mb_type[xy1s>mb_stride])) 
1393 
qp_dt= qp_t; 
1394 
else

1395 
qp_dt= s>current_picture.qscale_table[xy1s>mb_stride];

1396 

1397 
if(qp_dt){

1398 
const int chroma_qp= s>chroma_qscale_table[qp_dt]; 
1399 
s>dsp.h263_h_loop_filter(dest_y 8*linesize , linesize, qp_dt);

1400 
s>dsp.h263_h_loop_filter(dest_cb8*uvlinesize, uvlinesize, chroma_qp);

1401 
s>dsp.h263_h_loop_filter(dest_cb8*uvlinesize, uvlinesize, chroma_qp);

1402 
} 
1403 
} 
1404 
} 
1405  
1406 
if(qp_c){

1407 
s>dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);

1408 
if(s>mb_y + 1 == s>mb_height) 
1409 
s>dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); 
1410 
} 
1411 

1412 
if(s>mb_x){

1413 
int qp_lc;

1414 
if(qp_c  IS_SKIP(s>current_picture.mb_type[xy1])) 
1415 
qp_lc= qp_c; 
1416 
else

1417 
qp_lc= s>current_picture.qscale_table[xy1];

1418 

1419 
if(qp_lc){

1420 
s>dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); 
1421 
if(s>mb_y + 1 == s>mb_height){ 
1422 
const int chroma_qp= s>chroma_qscale_table[qp_lc]; 
1423 
s>dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);

1424 
s>dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); 
1425 
s>dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); 
1426 
} 
1427 
} 
1428 
} 
1429 
} 
1430  
1431 
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr) 
1432 
{ 
1433 
int x, y, wrap, a, c, pred_dc, scale;

1434 
int16_t *dc_val, *ac_val; 
1435  
1436 
/* find prediction */

1437 
if (n < 4) { 
1438 
x = 2 * s>mb_x + 1 + (n & 1); 
1439 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
1440 
wrap = s>mb_width * 2 + 2; 
1441 
dc_val = s>dc_val[0];

1442 
ac_val = s>ac_val[0][0]; 
1443 
scale = s>y_dc_scale; 
1444 
} else {

1445 
x = s>mb_x + 1;

1446 
y = s>mb_y + 1;

1447 
wrap = s>mb_width + 2;

1448 
dc_val = s>dc_val[n  4 + 1]; 
1449 
ac_val = s>ac_val[n  4 + 1][0]; 
1450 
scale = s>c_dc_scale; 
1451 
} 
1452 
/* B C

1453 
* A X

1454 
*/

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

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

1457 

1458 
/* No prediction outside GOB boundary */

1459 
if(s>first_slice_line && n!=3){ 
1460 
if(n!=2) c= 1024; 
1461 
if(n!=1 && s>mb_x == s>resync_mb_x) a= 1024; 
1462 
} 
1463 
pred_dc = 1024;

1464 
/* just DC prediction */

1465 
if (a != 1024 && c != 1024) 
1466 
pred_dc = (a + c) >> 1;

1467 
else if (a != 1024) 
1468 
pred_dc = a; 
1469 
else

1470 
pred_dc = c; 
1471 

1472 
/* we assume pred is positive */

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

1474 
*dc_val_ptr = &dc_val[x + y * wrap]; 
1475 
return pred_dc;

1476 
} 
1477  
1478 
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) 
1479 
{ 
1480 
int x, y, wrap, a, c, pred_dc, scale, i;

1481 
int16_t *dc_val, *ac_val, *ac_val1; 
1482  
1483 
/* find prediction */

1484 
if (n < 4) { 
1485 
x = 2 * s>mb_x + 1 + (n & 1); 
1486 
y = 2 * s>mb_y + 1 + (n>> 1); 
1487 
wrap = s>mb_width * 2 + 2; 
1488 
dc_val = s>dc_val[0];

1489 
ac_val = s>ac_val[0][0]; 
1490 
scale = s>y_dc_scale; 
1491 
} else {

1492 
x = s>mb_x + 1;

1493 
y = s>mb_y + 1;

1494 
wrap = s>mb_width + 2;

1495 
dc_val = s>dc_val[n  4 + 1]; 
1496 
ac_val = s>ac_val[n  4 + 1][0]; 
1497 
scale = s>c_dc_scale; 
1498 
} 
1499 

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

1501 
ac_val1 = ac_val; 
1502 

1503 
/* B C

1504 
* A X

1505 
*/

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

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

1508 

1509 
/* No prediction outside GOB boundary */

1510 
if(s>first_slice_line && n!=3){ 
1511 
if(n!=2) c= 1024; 
1512 
if(n!=1 && s>mb_x == s>resync_mb_x) a= 1024; 
1513 
} 
1514 

1515 
if (s>ac_pred) {

1516 
pred_dc = 1024;

1517 
if (s>h263_aic_dir) {

1518 
/* left prediction */

1519 
if (a != 1024) { 
1520 
ac_val = 16;

1521 
for(i=1;i<8;i++) { 
1522 
block[s>dsp.idct_permutation[i<<3]] += ac_val[i];

1523 
} 
1524 
pred_dc = a; 
1525 
} 
1526 
} else {

1527 
/* top prediction */

1528 
if (c != 1024) { 
1529 
ac_val = 16 * wrap;

1530 
for(i=1;i<8;i++) { 
1531 
block[s>dsp.idct_permutation[i ]] += ac_val[i + 8];

1532 
} 
1533 
pred_dc = c; 
1534 
} 
1535 
} 
1536 
} else {

1537 
/* just DC prediction */

1538 
if (a != 1024 && c != 1024) 
1539 
pred_dc = (a + c) >> 1;

1540 
else if (a != 1024) 
1541 
pred_dc = a; 
1542 
else

1543 
pred_dc = c; 
1544 
} 
1545 

1546 
/* we assume pred is positive */

1547 
block[0]=block[0]*scale + pred_dc; 
1548 

1549 
if (block[0] < 0) 
1550 
block[0] = 0; 
1551 
else

1552 
block[0] = 1; 
1553 

1554 
/* Update AC/DC tables */

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

1556 

1557 
/* left copy */

1558 
for(i=1;i<8;i++) 
1559 
ac_val1[i ] = block[s>dsp.idct_permutation[i<<3]];

1560 
/* top copy */

1561 
for(i=1;i<8;i++) 
1562 
ac_val1[8 + i] = block[s>dsp.idct_permutation[i ]];

1563 
} 
1564  
1565 
int16_t *h263_pred_motion(MpegEncContext * s, int block,

1566 
int *px, int *py) 
1567 
{ 
1568 
int xy, wrap;

1569 
int16_t *A, *B, *C, *mot_val; 
1570 
static const int off[4]= {2, 1, 1, 1}; 
1571  
1572 
wrap = s>block_wrap[0];

1573 
xy = s>block_index[block]; 
1574  
1575 
mot_val = s>current_picture.motion_val[0][xy];

1576  
1577 
A = s>current_picture.motion_val[0][xy  1]; 
1578 
/* special case for first (slice) line */

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

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

1582 
if(block==0){ //most common case 
1583 
if(s>mb_x == s>resync_mb_x){ //rare 
1584 
*px= *py = 0;

1585 
}else if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1586 
C = s>current_picture.motion_val[0][xy + off[block]  wrap];

1587 
if(s>mb_x==0){ 
1588 
*px = C[0];

1589 
*py = C[1];

1590 
}else{

1591 
*px = mid_pred(A[0], 0, C[0]); 
1592 
*py = mid_pred(A[1], 0, C[1]); 
1593 
} 
1594 
}else{

1595 
*px = A[0];

1596 
*py = A[1];

1597 
} 
1598 
}else if(block==1){ 
1599 
if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1600 
C = s>current_picture.motion_val[0][xy + off[block]  wrap];

1601 
*px = mid_pred(A[0], 0, C[0]); 
1602 
*py = mid_pred(A[1], 0, C[1]); 
1603 
}else{

1604 
*px = A[0];

1605 
*py = A[1];

1606 
} 
1607 
}else{ /* block==2*/ 
1608 
B = s>current_picture.motion_val[0][xy  wrap];

1609 
C = s>current_picture.motion_val[0][xy + off[block]  wrap];

1610 
if(s>mb_x == s>resync_mb_x) //rare 
1611 
A[0]=A[1]=0; 
1612 

1613 
*px = mid_pred(A[0], B[0], C[0]); 
1614 
*py = mid_pred(A[1], B[1], C[1]); 
1615 
} 
1616 
} else {

1617 
B = s>current_picture.motion_val[0][xy  wrap];

1618 
C = s>current_picture.motion_val[0][xy + off[block]  wrap];

1619 
*px = mid_pred(A[0], B[0], C[0]); 
1620 
*py = mid_pred(A[1], B[1], C[1]); 
1621 
} 
1622 
return mot_val;

1623 
} 
1624  
1625 
// identical to above but with s>current_picture>motion_val, the above one will be removed, and this renamed to it

1626 
int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir, 
1627 
int *px, int *py) 
1628 
{ 
1629 
int xy, wrap;

1630 
int16_t *A, *B, *C, (*mot_val)[2];

1631 
static const int off[4]= {2, 1, 1, 1}; 
1632  
1633 
wrap = s>b8_stride; 
1634 
xy = 2*(s>mb_x + s>mb_y * wrap);

1635  
1636 
mot_val = s>current_picture.motion_val[dir] + xy; 
1637  
1638 
A = mot_val[  1];

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

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

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

1643 
if(block==0){ //most common case 
1644 
if(s>mb_x == s>resync_mb_x){ //rare 
1645 
*px= *py = 0;

1646 
}else if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1647 
C = mot_val[off[block]  wrap]; 
1648 
if(s>mb_x==0){ 
1649 
*px = C[0];

1650 
*py = C[1];

1651 
}else{

1652 
*px = mid_pred(A[0], 0, C[0]); 
1653 
*py = mid_pred(A[1], 0, C[1]); 
1654 
} 
1655 
}else{

1656 
*px = A[0];

1657 
*py = A[1];

1658 
} 
1659 
}else if(block==1){ 
1660 
if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1661 
C = mot_val[off[block]  wrap]; 
1662 
*px = mid_pred(A[0], 0, C[0]); 
1663 
*py = mid_pred(A[1], 0, C[1]); 
1664 
}else{

1665 
*px = A[0];

1666 
*py = A[1];

1667 
} 
1668 
}else{ /* block==2*/ 
1669 
B = mot_val[  wrap]; 
1670 
C = mot_val[off[block]  wrap]; 
1671 
if(s>mb_x == s>resync_mb_x) //rare 
1672 
A[0]=A[1]=0; 
1673 

1674 
*px = mid_pred(A[0], B[0], C[0]); 
1675 
*py = mid_pred(A[1], B[1], C[1]); 
1676 
} 
1677 
} else {

1678 
B = mot_val[  wrap]; 
1679 
C = mot_val[off[block]  wrap]; 
1680 
*px = mid_pred(A[0], B[0], C[0]); 
1681 
*py = mid_pred(A[1], B[1], C[1]); 
1682 
} 
1683 
return *mot_val;

1684 
} 
1685  
1686 
#ifdef CONFIG_ENCODERS

1687 
static void h263_encode_motion(MpegEncContext * s, int val, int f_code) 
1688 
{ 
1689 
int range, l, bit_size, sign, code, bits;

1690  
1691 
if (val == 0) { 
1692 
/* zero vector */

1693 
code = 0;

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

1696 
bit_size = f_code  1;

1697 
range = 1 << bit_size;

1698 
/* modulo encoding */

1699 
l = range * 32;

1700 
#if 1 
1701 
val+= l; 
1702 
val&= 2*l1; 
1703 
val= l; 
1704 
sign = val>>31;

1705 
val= (val^sign)sign; 
1706 
sign&=1;

1707 
#else

1708 
if (val < l) {

1709 
val += 2*l;

1710 
} else if (val >= l) { 
1711 
val = 2*l;

1712 
} 
1713  
1714 
assert(val>=l && val<l); 
1715  
1716 
if (val >= 0) { 
1717 
sign = 0;

1718 
} else {

1719 
val = val; 
1720 
sign = 1;

1721 
} 
1722 
#endif

1723 
val; 
1724 
code = (val >> bit_size) + 1;

1725 
bits = val & (range  1);

1726  
1727 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
1728 
if (bit_size > 0) { 
1729 
put_bits(&s>pb, bit_size, bits); 
1730 
} 
1731 
} 
1732  
1733 
} 
1734  
1735 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

1736 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
1737 
{ 
1738 
short sval = 0; 
1739 
short i = 0; 
1740 
short n_bits = 0; 
1741 
short temp_val;

1742 
int code = 0; 
1743 
int tcode;

1744 

1745 
if ( val == 0) 
1746 
put_bits(&s>pb, 1, 1); 
1747 
else if (val == 1) 
1748 
put_bits(&s>pb, 3, 0); 
1749 
else if (val == 1) 
1750 
put_bits(&s>pb, 3, 2); 
1751 
else {

1752 

1753 
sval = ((val < 0) ? (short)(val):(short)val); 
1754 
temp_val = sval; 
1755 

1756 
while (temp_val != 0) { 
1757 
temp_val = temp_val >> 1;

1758 
n_bits++; 
1759 
} 
1760 

1761 
i = n_bits  1;

1762 
while (i > 0) { 
1763 
tcode = (sval & (1 << (i1))) >> (i1); 
1764 
tcode = (tcode << 1)  1; 
1765 
code = (code << 2)  tcode;

1766 
i; 
1767 
} 
1768 
code = ((code << 1)  (val < 0)) << 1; 
1769 
put_bits(&s>pb, (2*n_bits)+1, code); 
1770 
//printf("\nVal = %d\tCode = %d", sval, code);

1771 
} 
1772 
} 
1773  
1774 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
1775 
{ 
1776 
int f_code;

1777 
int mv;

1778 

1779 
if(mv_penalty==NULL) 
1780 
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); 
1781 

1782 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
1783 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

1784 
int len;

1785  
1786 
if(mv==0) len= mvtab[0][1]; 
1787 
else{

1788 
int val, bit_size, range, code;

1789  
1790 
bit_size = f_code  1;

1791 
range = 1 << bit_size;

1792  
1793 
val=mv; 
1794 
if (val < 0) 
1795 
val = val; 
1796 
val; 
1797 
code = (val >> bit_size) + 1;

1798 
if(code<33){ 
1799 
len= mvtab[code][1] + 1 + bit_size; 
1800 
}else{

1801 
len= mvtab[32][1] + 2 + bit_size; 
1802 
} 
1803 
} 
1804  
1805 
mv_penalty[f_code][mv+MAX_MV]= len; 
1806 
} 
1807 
} 
1808  
1809 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
1810 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
1811 
fcode_tab[mv+MAX_MV]= f_code; 
1812 
} 
1813 
} 
1814  
1815 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
1816 
umv_fcode_tab[mv]= 1;

1817 
} 
1818 
} 
1819 
#endif

1820  
1821 
#ifdef CONFIG_ENCODERS

1822  
1823 
static void init_uni_dc_tab(void) 
1824 
{ 
1825 
int level, uni_code, uni_len;

1826  
1827 
for(level=256; level<256; level++){ 
1828 
int size, v, l;

1829 
/* find number of bits */

1830 
size = 0;

1831 
v = abs(level); 
1832 
while (v) {

1833 
v >>= 1;

1834 
size++; 
1835 
} 
1836  
1837 
if (level < 0) 
1838 
l= (level) ^ ((1 << size)  1); 
1839 
else

1840 
l= level; 
1841  
1842 
/* luminance */

1843 
uni_code= DCtab_lum[size][0];

1844 
uni_len = DCtab_lum[size][1];

1845  
1846 
if (size > 0) { 
1847 
uni_code<<=size; uni_code=l; 
1848 
uni_len+=size; 
1849 
if (size > 8){ 
1850 
uni_code<<=1; uni_code=1; 
1851 
uni_len++; 
1852 
} 
1853 
} 
1854 
uni_DCtab_lum_bits[level+256]= uni_code;

1855 
uni_DCtab_lum_len [level+256]= uni_len;

1856  
1857 
/* chrominance */

1858 
uni_code= DCtab_chrom[size][0];

1859 
uni_len = DCtab_chrom[size][1];

1860 

1861 
if (size > 0) { 
1862 
uni_code<<=size; uni_code=l; 
1863 
uni_len+=size; 
1864 
if (size > 8){ 
1865 
uni_code<<=1; uni_code=1; 
1866 
uni_len++; 
1867 
} 
1868 
} 
1869 
uni_DCtab_chrom_bits[level+256]= uni_code;

1870 
uni_DCtab_chrom_len [level+256]= uni_len;

1871  
1872 
} 
1873 
} 
1874  
1875 
#endif //CONFIG_ENCODERS 
1876  
1877 
#ifdef CONFIG_ENCODERS

1878 
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ 
1879 
int slevel, run, last;

1880 

1881 
assert(MAX_LEVEL >= 64);

1882 
assert(MAX_RUN >= 63);

1883  
1884 
for(slevel=64; slevel<64; slevel++){ 
1885 
if(slevel==0) continue; 
1886 
for(run=0; run<64; run++){ 
1887 
for(last=0; last<=1; last++){ 
1888 
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); 
1889 
int level= slevel < 0 ? slevel : slevel; 
1890 
int sign= slevel < 0 ? 1 : 0; 
1891 
int bits, len, code;

1892 
int level1, run1;

1893 

1894 
len_tab[index]= 100;

1895 

1896 
/* ESC0 */

1897 
code= get_rl_index(rl, last, run, level); 
1898 
bits= rl>table_vlc[code][0];

1899 
len= rl>table_vlc[code][1];

1900 
bits=bits*2+sign; len++;

1901 

1902 
if(code!=rl>n && len < len_tab[index]){

1903 
bits_tab[index]= bits; 
1904 
len_tab [index]= len; 
1905 
} 
1906 
#if 1 
1907 
/* ESC1 */

1908 
bits= rl>table_vlc[rl>n][0];

1909 
len= rl>table_vlc[rl>n][1];

1910 
bits=bits*2; len++; //esc1 
1911 
level1= level  rl>max_level[last][run]; 
1912 
if(level1>0){ 
1913 
code= get_rl_index(rl, last, run, level1); 
1914 
bits<<= rl>table_vlc[code][1];

1915 
len += rl>table_vlc[code][1];

1916 
bits += rl>table_vlc[code][0];

1917 
bits=bits*2+sign; len++;

1918 

1919 
if(code!=rl>n && len < len_tab[index]){

1920 
bits_tab[index]= bits; 
1921 
len_tab [index]= len; 
1922 
} 
1923 
} 
1924 
#endif

1925 
#if 1 
1926 
/* ESC2 */

1927 
bits= rl>table_vlc[rl>n][0];

1928 
len= rl>table_vlc[rl>n][1];

1929 
bits=bits*4+2; len+=2; //esc2 
1930 
run1 = run  rl>max_run[last][level]  1;

1931 
if(run1>=0){ 
1932 
code= get_rl_index(rl, last, run1, level); 
1933 
bits<<= rl>table_vlc[code][1];

1934 
len += rl>table_vlc[code][1];

1935 
bits += rl>table_vlc[code][0];

1936 
bits=bits*2+sign; len++;

1937 

1938 
if(code!=rl>n && len < len_tab[index]){

1939 
bits_tab[index]= bits; 
1940 
len_tab [index]= len; 
1941 
} 
1942 
} 
1943 
#endif

1944 
/* ESC3 */

1945 
bits= rl>table_vlc[rl>n][0];

1946 
len = rl>table_vlc[rl>n][1];

1947 
bits=bits*4+3; len+=2; //esc3 
1948 
bits=bits*2+last; len++;

1949 
bits=bits*64+run; len+=6; 
1950 
bits=bits*2+1; len++; //marker 
1951 
bits=bits*4096+(slevel&0xfff); len+=12; 
1952 
bits=bits*2+1; len++; //marker 
1953 

1954 
if(len < len_tab[index]){

1955 
bits_tab[index]= bits; 
1956 
len_tab [index]= len; 
1957 
} 
1958 
} 
1959 
} 
1960 
} 
1961 
} 
1962  
1963 
void h263_encode_init(MpegEncContext *s)

1964 
{ 
1965 
static int done = 0; 
1966  
1967 
if (!done) {

1968 
done = 1;

1969  
1970 
init_uni_dc_tab(); 
1971  
1972 
init_rl(&rl_inter); 
1973 
init_rl(&rl_intra); 
1974 
init_rl(&rl_intra_aic); 
1975 

1976 
init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); 
1977 
init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); 
1978  
1979 
init_mv_penalty_and_fcode(s); 
1980 
} 
1981 
s>me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

1982 

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

1984 
switch(s>codec_id){

1985 
case CODEC_ID_MPEG4:

1986 
s>fcode_tab= fcode_tab; 
1987 
s>min_qcoeff= 2048;

1988 
s>max_qcoeff= 2047;

1989 
s>intra_ac_vlc_length = uni_mpeg4_intra_rl_len; 
1990 
s>intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; 
1991 
s>inter_ac_vlc_length = uni_mpeg4_inter_rl_len; 
1992 
s>inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; 
1993 
s>luma_dc_vlc_length= uni_DCtab_lum_len; 
1994 
s>chroma_dc_vlc_length= uni_DCtab_chrom_len; 
1995 
s>ac_esc_length= 7+2+1+6+1+12+1; 
1996 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 
1997 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
1998  
1999 
if(s>flags & CODEC_FLAG_GLOBAL_HEADER){

2000  
2001 
s>avctx>extradata= av_malloc(1024);

2002 
init_put_bits(&s>pb, s>avctx>extradata, 1024);

2003 

2004 
mpeg4_encode_visual_object_header(s); 
2005 
mpeg4_encode_vol_header(s, 0, 0); 
2006  
2007 
// ff_mpeg4_stuffing(&s>pb); ?

2008 
flush_put_bits(&s>pb); 
2009 
s>avctx>extradata_size= (put_bits_count(&s>pb)+7)>>3; 
2010 
} 
2011 

2012 
break;

2013 
case CODEC_ID_H263P:

2014 
if(s>umvplus)

2015 
s>fcode_tab= umv_fcode_tab; 
2016 
if(s>modified_quant){

2017 
s>min_qcoeff= 2047;

2018 
s>max_qcoeff= 2047;

2019 
}else{

2020 
s>min_qcoeff= 127;

2021 
s>max_qcoeff= 127;

2022 
} 
2023 
break;

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

2025 
case CODEC_ID_FLV1:

2026 
if (s>h263_flv > 1) { 
2027 
s>min_qcoeff= 1023;

2028 
s>max_qcoeff= 1023;

2029 
} else {

2030 
s>min_qcoeff= 127;

2031 
s>max_qcoeff= 127;

2032 
} 
2033 
s>y_dc_scale_table= 
2034 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
2035 
break;

2036 
default: //nothing needed default table allready set in mpegvideo.c 
2037 
s>min_qcoeff= 127;

2038 
s>max_qcoeff= 127;

2039 
s>y_dc_scale_table= 
2040 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
2041 
} 
2042 
} 
2043  
2044 
/**

2045 
* encodes a 8x8 block.

2046 
* @param block the 8x8 block

2047 
* @param n block index (03 are luma, 45 are chroma)

2048 
*/

2049 
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
2050 
{ 
2051 
int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;

2052 
RLTable *rl; 
2053  
2054 
rl = &rl_inter; 
2055 
if (s>mb_intra && !s>h263_aic) {

2056 
/* DC coef */

2057 
level = block[0];

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

2059 
if (level > 254) { 
2060 
level = 254;

2061 
block[0] = 254; 
2062 
} 
2063 
/* 0 cannot be represented also */

2064 
else if (level < 1) { 
2065 
level = 1;

2066 
block[0] = 1; 
2067 
} 
2068 
if (level == 128) //FIXME check rv10 
2069 
put_bits(&s>pb, 8, 0xff); 
2070 
else

2071 
put_bits(&s>pb, 8, level);

2072 
i = 1;

2073 
} else {

2074 
i = 0;

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

2076 
rl = &rl_intra_aic; 
2077 

2078 
if(s>alt_inter_vlc && !s>mb_intra){

2079 
int aic_vlc_bits=0; 
2080 
int inter_vlc_bits=0; 
2081 
int wrong_pos=1; 
2082 
int aic_code;

2083 

2084 
last_index = s>block_last_index[n]; 
2085 
last_non_zero = i  1;

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

2087 
j = s>intra_scantable.permutated[i]; 
2088 
level = block[j]; 
2089 
if (level) {

2090 
run = i  last_non_zero  1;

2091 
last = (i == last_index); 
2092 

2093 
if(level<0) level= level; 
2094 

2095 
code = get_rl_index(rl, last, run, level); 
2096 
aic_code = get_rl_index(&rl_intra_aic, last, run, level); 
2097 
inter_vlc_bits += rl>table_vlc[code][1]+1; 
2098 
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; 
2099  
2100 
if (code == rl>n) {

2101 
inter_vlc_bits += 1+6+81; 
2102 
} 
2103 
if (aic_code == rl_intra_aic.n) {

2104 
aic_vlc_bits += 1+6+81; 
2105 
wrong_pos += run + 1;

2106 
}else

2107 
wrong_pos += wrong_run[aic_code]; 
2108 
last_non_zero = i; 
2109 
} 
2110 
} 
2111 
i = 0;

2112 
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) 
2113 
rl = &rl_intra_aic; 
2114 
} 
2115 
} 
2116 

2117 
/* AC coefs */

2118 
last_index = s>block_last_index[n]; 
2119 
last_non_zero = i  1;

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

2121 
j = s>intra_scantable.permutated[i]; 
2122 
level = block[j]; 
2123 
if (level) {

2124 
run = i  last_non_zero  1;

2125 
last = (i == last_index); 
2126 
sign = 0;

2127 
slevel = level; 
2128 
if (level < 0) { 
2129 
sign = 1;

2130 
level = level; 
2131 
} 
2132 
code = get_rl_index(rl, last, run, level); 
2133 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2134 
if (code == rl>n) {

2135 
if(s>h263_flv <= 1){ 
2136 
put_bits(&s>pb, 1, last);

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

2138 

2139 
assert(slevel != 0);

2140  
2141 
if(level < 128) 
2142 
put_bits(&s>pb, 8, slevel & 0xff); 
2143 
else{

2144 
put_bits(&s>pb, 8, 128); 
2145 
put_bits(&s>pb, 5, slevel & 0x1f); 
2146 
put_bits(&s>pb, 6, (slevel>>5)&0x3f); 
2147 
} 
2148 
}else{

2149 
if(level < 64) { // 7bit level 
2150 
put_bits(&s>pb, 1, 0); 
2151 
put_bits(&s>pb, 1, last);

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

2153  
2154 
put_bits(&s>pb, 7, slevel & 0x7f); 
2155 
} else {

2156 
/* 11bit level */

2157 
put_bits(&s>pb, 1, 1); 
2158 
put_bits(&s>pb, 1, last);

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

2160  
2161 
put_bits(&s>pb, 11, slevel & 0x7ff); 
2162 
} 
2163 
} 
2164 
} else {

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

2166 
} 
2167 
last_non_zero = i; 
2168 
} 
2169 
} 
2170 
} 
2171 
#endif

2172  
2173 
#ifdef CONFIG_ENCODERS

2174  
2175 
/***************************************************/

2176 
/**

2177 
* add mpeg4 stuffing bits (01...1)

2178 
*/

2179 
void ff_mpeg4_stuffing(PutBitContext * pbc)

2180 
{ 
2181 
int length;

2182 
put_bits(pbc, 1, 0); 
2183 
length= (put_bits_count(pbc))&7;

2184 
if(length) put_bits(pbc, length, (1<<length)1); 
2185 
} 
2186  
2187 
/* must be called before writing the header */

2188 
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ 
2189 
int time_div, time_mod;

2190  
2191 
assert(s>current_picture_ptr>pts != AV_NOPTS_VALUE); 
2192 
s>time= (s>current_picture_ptr>pts*s>time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;

2193  
2194 
time_div= s>time/s>time_increment_resolution; 
2195 
time_mod= s>time%s>time_increment_resolution; 
2196  
2197 
if(s>pict_type==B_TYPE){

2198 
s>pb_time= s>pp_time  (s>last_non_b_time  s>time); 
2199 
}else{

2200 
s>last_time_base= s>time_base; 
2201 
s>time_base= time_div; 
2202 
s>pp_time= s>time  s>last_non_b_time; 
2203 
s>last_non_b_time= s>time; 
2204 
} 
2205 
} 
2206  
2207 
static void mpeg4_encode_gop_header(MpegEncContext * s){ 
2208 
int hours, minutes, seconds;

2209 
int64_t time; 
2210 

2211 
put_bits(&s>pb, 16, 0); 
2212 
put_bits(&s>pb, 16, GOP_STARTCODE);

2213 

2214 
time= s>current_picture_ptr>pts; 
2215 
if(s>reordered_input_picture[1]) 
2216 
time= FFMIN(time, s>reordered_input_picture[1]>pts);

2217 
time= (time*s>time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;

2218  
2219 
seconds= time/s>time_increment_resolution; 
2220 
minutes= seconds/60; seconds %= 60; 
2221 
hours= minutes/60; minutes %= 60; 
2222 
hours%=24;

2223  
2224 
put_bits(&s>pb, 5, hours);

2225 
put_bits(&s>pb, 6, minutes);

2226 
put_bits(&s>pb, 1, 1); 
2227 
put_bits(&s>pb, 6, seconds);

2228 

2229 
put_bits(&s>pb, 1, !!(s>flags&CODEC_FLAG_CLOSED_GOP));

2230 
put_bits(&s>pb, 1, 0); //broken link == NO 
2231 

2232 
s>last_time_base= time / s>time_increment_resolution; 
2233  
2234 
ff_mpeg4_stuffing(&s>pb); 
2235 
} 
2236  
2237 
static void mpeg4_encode_visual_object_header(MpegEncContext * s){ 
2238 
int profile_and_level_indication;

2239 
int vo_ver_id;

2240 

2241 
if(s>max_b_frames  s>quarter_sample){

2242 
profile_and_level_indication= 0xF1; // adv simple level 1 
2243 
vo_ver_id= 5;

2244 
}else{

2245 
profile_and_level_indication= 0x01; // simple level 1 
2246 
vo_ver_id= 1;

2247 
} 
2248 
//FIXME levels

2249  
2250 
put_bits(&s>pb, 16, 0); 
2251 
put_bits(&s>pb, 16, VOS_STARTCODE);

2252  
2253 
put_bits(&s>pb, 8, profile_and_level_indication);

2254  
2255 
put_bits(&s>pb, 16, 0); 
2256 
put_bits(&s>pb, 16, VISUAL_OBJ_STARTCODE);

2257 

2258 
put_bits(&s>pb, 1, 1); 
2259 
put_bits(&s>pb, 4, vo_ver_id);

2260 
put_bits(&s>pb, 3, 1); //priority 
2261 

2262 
put_bits(&s>pb, 4, 1); //visual obj type== video obj 
2263 

2264 
put_bits(&s>pb, 1, 0); //video signal type == no clue //FIXME 
2265  
2266 
ff_mpeg4_stuffing(&s>pb); 
2267 
} 
2268  
2269 
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) 
2270 
{ 
2271 
int vo_ver_id;

2272  
2273 
if(s>max_b_frames  s>quarter_sample){

2274 
vo_ver_id= 5;

2275 
s>vo_type= ADV_SIMPLE_VO_TYPE; 
2276 
}else{

2277 
vo_ver_id= 1;

2278 
s>vo_type= SIMPLE_VO_TYPE; 
2279 
} 
2280  
2281 
put_bits(&s>pb, 16, 0); 
2282 
put_bits(&s>pb, 16, 0x100 + vo_number); /* video obj */ 
2283 
put_bits(&s>pb, 16, 0); 
2284 
put_bits(&s>pb, 16, 0x120 + vol_number); /* video obj layer */ 
2285  
2286 
put_bits(&s>pb, 1, 0); /* random access vol */ 
2287 
put_bits(&s>pb, 8, s>vo_type); /* video obj type indication */ 
2288 
put_bits(&s>pb, 1, 1); /* is obj layer id= yes */ 
2289 
put_bits(&s>pb, 4, vo_ver_id); /* is obj layer ver id */ 
2290 
put_bits(&s>pb, 3, 1); /* is obj layer priority */ 
2291 

2292 
aspect_to_info(s, s>avctx>sample_aspect_ratio); 
2293  
2294 
put_bits(&s>pb, 4, s>aspect_ratio_info);/* aspect ratio info */ 
2295 
if (s>aspect_ratio_info == FF_ASPECT_EXTENDED){

2296 
put_bits(&s>pb, 8, s>avctx>sample_aspect_ratio.num);

2297 
put_bits(&s>pb, 8, s>avctx>sample_aspect_ratio.den);

2298 
} 
2299  
2300 
if(s>low_delay){

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

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

2306 
put_bits(&s>pb, 1, 0); /* vol control parameters= no */ 
2307 
} 
2308  
2309 
put_bits(&s>pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 
2310 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2311 

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

2313 
if (s>time_increment_bits < 1) 
2314 
s>time_increment_bits = 1;

2315 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2316 
put_bits(&s>pb, 1, 0); /* fixed vop rate=no */ 
2317 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2318 
put_bits(&s>pb, 13, s>width); /* vol width */ 
2319 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2320 
put_bits(&s>pb, 13, s>height); /* vol height */ 
2321 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2322 
put_bits(&s>pb, 1, s>progressive_sequence ? 0 : 1); 
2323 
put_bits(&s>pb, 1, 1); /* obmc disable */ 
2324 
if (vo_ver_id == 1) { 
2325 
put_bits(&s>pb, 1, s>vol_sprite_usage); /* sprite enable */ 
2326 
}else{

2327 
put_bits(&s>pb, 2, s>vol_sprite_usage); /* sprite enable */ 
2328 
} 
2329 

2330 
put_bits(&s>pb, 1, 0); /* not 8 bit == false */ 
2331 
put_bits(&s>pb, 1, s>mpeg_quant); /* quant type= (0=h263 style)*/ 
2332  
2333 
if(s>mpeg_quant){

2334 
ff_write_quant_matrix(&s>pb, s>avctx>intra_matrix); 
2335 
ff_write_quant_matrix(&s>pb, s>avctx>inter_matrix); 
2336 
} 
2337  
2338 
if (vo_ver_id != 1) 
2339 
put_bits(&s>pb, 1, s>quarter_sample);

2340 
put_bits(&s>pb, 1, 1); /* complexity estimation disable */ 
2341 
s>resync_marker= s>rtp_mode; 
2342 
put_bits(&s>pb, 1, s>resync_marker ? 0 : 1);/* resync marker disable */ 
2343 
put_bits(&s>pb, 1, s>data_partitioning ? 1 : 0); 
2344 
if(s>data_partitioning){

2345 
put_bits(&s>pb, 1, 0); /* no rvlc */ 
2346 
} 
2347  
2348 
if (vo_ver_id != 1){ 
2349 
put_bits(&s>pb, 1, 0); /* newpred */ 
2350 
put_bits(&s>pb, 1, 0); /* reduced res vop */ 
2351 
} 
2352 
put_bits(&s>pb, 1, 0); /* scalability */ 
2353 

2354 
ff_mpeg4_stuffing(&s>pb); 
2355  
2356 
/* user data */

2357 
if(!(s>flags & CODEC_FLAG_BITEXACT)){

2358 
put_bits(&s>pb, 16, 0); 
2359 
put_bits(&s>pb, 16, 0x1B2); /* user_data */ 
2360 
put_string(&s>pb, LIBAVCODEC_IDENT, 0);

2361 
} 
2362 
} 
2363  
2364 
/* write mpeg4 VOP header */

2365 
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
2366 
{ 
2367 
int time_incr;

2368 
int time_div, time_mod;

2369 

2370 
if(s>pict_type==I_TYPE){

2371 
if(!(s>flags&CODEC_FLAG_GLOBAL_HEADER)){

2372 
if(s>strict_std_compliance < 2) //HACK, the reference sw is buggy 
2373 
mpeg4_encode_visual_object_header(s); 
2374 
if(s>strict_std_compliance < 2  picture_number==0) //HACK, the reference sw is buggy 
2375 
mpeg4_encode_vol_header(s, 0, 0); 
2376 
} 
2377 
mpeg4_encode_gop_header(s); 
2378 
} 
2379 

2380 
s>partitioned_frame= s>data_partitioning && s>pict_type!=B_TYPE; 
2381  
2382 
//printf("num:%d rate:%d base:%d\n", s>picture_number, s>frame_rate, FRAME_RATE_BASE);

2383 

2384 
put_bits(&s>pb, 16, 0); /* vop header */ 
2385 
put_bits(&s>pb, 16, VOP_STARTCODE); /* vop header */ 
2386 
put_bits(&s>pb, 2, s>pict_type  1); /* pict type: I = 0 , P = 1 */ 
2387  
2388 
time_div= s>time/s>time_increment_resolution; 
2389 
time_mod= s>time%s>time_increment_resolution; 
2390 
time_incr= time_div  s>last_time_base; 
2391 
while(time_incr)

2392 
put_bits(&s>pb, 1, 1); 
2393 

2394 
put_bits(&s>pb, 1, 0); 
2395  
2396 
put_bits(&s>pb, 1, 1); /* marker */ 
2397 
put_bits(&s>pb, s>time_increment_bits, time_mod); /* time increment */

2398 
put_bits(&s>pb, 1, 1); /* marker */ 
2399 
put_bits(&s>pb, 1, 1); /* vop coded */ 
2400 
if ( s>pict_type == P_TYPE

2401 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE)) { 
2402 
put_bits(&s>pb, 1, s>no_rounding); /* rounding type */ 
2403 
} 
2404 
put_bits(&s>pb, 3, 0); /* intra dc VLC threshold */ 
2405 
if(!s>progressive_sequence){

2406 
put_bits(&s>pb, 1, s>current_picture_ptr>top_field_first);

2407 
put_bits(&s>pb, 1, s>alternate_scan);

2408 
} 
2409 
//FIXME sprite stuff

2410  
2411 
put_bits(&s>pb, 5, s>qscale);

2412  
2413 
if (s>pict_type != I_TYPE)

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

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

2418 
} 
2419  
2420 
#endif //CONFIG_ENCODERS 
2421  
2422 
/**

2423 
* set qscale and update qscale dependant variables.

2424 
*/

2425 
void ff_set_qscale(MpegEncContext * s, int qscale) 
2426 
{ 
2427 
if (qscale < 1) 
2428 
qscale = 1;

2429 
else if (qscale > 31) 
2430 
qscale = 31;

2431 

2432 
s>qscale = qscale; 
2433 
s>chroma_qscale= s>chroma_qscale_table[qscale]; 
2434  
2435 
s>y_dc_scale= s>y_dc_scale_table[ qscale ]; 
2436 
s>c_dc_scale= s>c_dc_scale_table[ s>chroma_qscale ]; 
2437 
} 
2438  
2439 
/**

2440 
* predicts the dc.

2441 
* @param n block index (03 are luma, 45 are chroma)

2442 
* @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here

2443 
* @param dir_ptr pointer to an integer where the prediction direction will be stored

2444 
* @return the quantized predicted dc

2445 
*/

2446 
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) 
2447 
{ 
2448 
int a, b, c, wrap, pred, scale;

2449 
uint16_t *dc_val; 
2450  
2451 
/* find prediction */

2452 
if (n < 4) { 
2453 
scale = s>y_dc_scale; 
2454 
} else {

2455 
scale = s>c_dc_scale; 
2456 
} 
2457 
if(IS_3IV1)

2458 
scale= 8;

2459  
2460 
wrap= s>block_wrap[n]; 
2461 
dc_val = s>dc_val[0] + s>block_index[n];

2462  
2463 
/* B C

2464 
* A X

2465 
*/

2466 
a = dc_val[  1];

2467 
b = dc_val[  1  wrap];

2468 
c = dc_val[  wrap]; 
2469  
2470 
/* outside slice handling (we cant do that by memset as we need the dc for error resilience) */

2471 
if(s>first_slice_line && n!=3){ 
2472 
if(n!=2) b=c= 1024; 
2473 
if(n!=1 && s>mb_x == s>resync_mb_x) b=a= 1024; 
2474 
} 
2475 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1){ 
2476 
if(n==0  n==4  n==5) 
2477 
b=1024;

2478 
} 
2479  
2480 
if (abs(a  b) < abs(b  c)) {

2481 
pred = c; 
2482 
*dir_ptr = 1; /* top */ 
2483 
} else {

2484 
pred = a; 
2485 
*dir_ptr = 0; /* left */ 
2486 
} 
2487 
/* we assume pred is positive */

2488 
pred = FASTDIV((pred + (scale >> 1)), scale);

2489  
2490 
/* prepare address for prediction update */

2491 
*dc_val_ptr = &dc_val[0];

2492  
2493 
return pred;

2494 
} 
2495  
2496 
/**

2497 
* predicts the ac.

2498 
* @param n block index (03 are luma, 45 are chroma)

2499 
* @param dir the ac prediction direction

2500 
*/

2501 
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, 
2502 
int dir)

2503 
{ 
2504 
int i;

2505 
int16_t *ac_val, *ac_val1; 
2506 
int8_t * const qscale_table= s>current_picture.qscale_table;

2507  
2508 
/* find prediction */

2509 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
2510 
ac_val1 = ac_val; 
2511 
if (s>ac_pred) {

2512 
if (dir == 0) { 
2513 
const int xy= s>mb_x1 + s>mb_y*s>mb_stride; 
2514 
/* left prediction */

2515 
ac_val = 16;

2516 

2517 
if(s>mb_x==0  s>qscale == qscale_table[xy]  n==1  n==3){ 
2518 
/* same qscale */

2519 
for(i=1;i<8;i++) { 
2520 
block[s>dsp.idct_permutation[i<<3]] += ac_val[i];

2521 
} 
2522 
}else{

2523 
/* different qscale, we must rescale */

2524 
for(i=1;i<8;i++) { 
2525 
block[s>dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s>qscale);

2526 
} 
2527 
} 
2528 
} else {

2529 
const int xy= s>mb_x + s>mb_y*s>mb_stride  s>mb_stride; 
2530 
/* top prediction */

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

2532  
2533 
if(s>mb_y==0  s>qscale == qscale_table[xy]  n==2  n==3){ 
2534 
/* same qscale */

2535 
for(i=1;i<8;i++) { 
2536 
block[s>dsp.idct_permutation[i]] += ac_val[i + 8];

2537 
} 
2538 
}else{

2539 
/* different qscale, we must rescale */

2540 
for(i=1;i<8;i++) { 
2541 
block[s>dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s>qscale);

2542 
} 
2543 
} 
2544 
} 
2545 
} 
2546 
/* left copy */

2547 
for(i=1;i<8;i++) 
2548 
ac_val1[i ] = block[s>dsp.idct_permutation[i<<3]];

2549  
2550 
/* top copy */

2551 
for(i=1;i<8;i++) 
2552 
ac_val1[8 + i] = block[s>dsp.idct_permutation[i ]];

2553  
2554 
} 
2555  
2556 
#ifdef CONFIG_ENCODERS

2557  
2558 
/**

2559 
* encodes the dc value.

2560 
* @param n block index (03 are luma, 45 are chroma)

2561 
*/

2562 
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) 
2563 
{ 
2564 
#if 1 
2565 
// if(level<255  level>255) printf("dc overflow\n");

2566 
level+=256;

2567 
if (n < 4) { 
2568 
/* luminance */

2569 
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); 
2570 
} else {

2571 
/* chrominance */

2572 
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); 
2573 
} 
2574 
#else

2575 
int size, v;

2576 
/* find number of bits */

2577 
size = 0;

2578 
v = abs(level); 
2579 
while (v) {

2580 
v >>= 1;

2581 
size++; 
2582 
} 
2583  
2584 
if (n < 4) { 
2585 
/* luminance */

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

2588 
/* chrominance */

2589 
put_bits(&s>pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 
2590 
} 
2591  
2592 
/* encode remaining bits */

2593 
if (size > 0) { 
2594 
if (level < 0) 
2595 
level = (level) ^ ((1 << size)  1); 
2596 
put_bits(&s>pb, size, level); 
2597 
if (size > 8) 
2598 
put_bits(&s>pb, 1, 1); 
2599 
} 
2600 
#endif

2601 
} 
2602  
2603 
/**

2604 
* encodes a 8x8 block

2605 
* @param n block index (03 are luma, 45 are chroma)

2606 
*/

2607 
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2608 
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) 
2609 
{ 
2610 
int i, last_non_zero;

2611 
#if 0 //variables for the outcommented version

2612 
int code, sign, last;

2613 
#endif

2614 
const RLTable *rl;

2615 
uint32_t *bits_tab; 
2616 
uint8_t *len_tab; 
2617 
const int last_index = s>block_last_index[n]; 
2618  
2619 
if (s>mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 
2620 
/* mpeg4 based DC predictor */

2621 
mpeg4_encode_dc(dc_pb, intra_dc, n); 
2622 
if(last_index<1) return; 
2623 
i = 1;

2624 
rl = &rl_intra; 
2625 
bits_tab= uni_mpeg4_intra_rl_bits; 
2626 
len_tab = uni_mpeg4_intra_rl_len; 
2627 
} else {

2628 
if(last_index<0) return; 
2629 
i = 0;

2630 
rl = &rl_inter; 
2631 
bits_tab= uni_mpeg4_inter_rl_bits; 
2632 
len_tab = uni_mpeg4_inter_rl_len; 
2633 
} 
2634  
2635 
/* AC coefs */

2636 
last_non_zero = i  1;

2637 
#if 1 
2638 
for (; i < last_index; i++) {

2639 
int level = block[ scan_table[i] ];

2640 
if (level) {

2641 
int run = i  last_non_zero  1; 
2642 
level+=64;

2643 
if((level&(~127)) == 0){ 
2644 
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 
2645 
put_bits(ac_pb, len_tab[index], bits_tab[index]); 
2646 
}else{ //ESC3 
2647 
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level64)&0xfff)<<1)+1); 
2648 
} 
2649 
last_non_zero = i; 
2650 
} 
2651 
} 
2652 
/*if(i<=last_index)*/{

2653 
int level = block[ scan_table[i] ];

2654 
int run = i  last_non_zero  1; 
2655 
level+=64;

2656 
if((level&(~127)) == 0){ 
2657 
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 
2658 
put_bits(ac_pb, len_tab[index], bits_tab[index]); 
2659 
}else{ //ESC3 
2660 
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level64)&0xfff)<<1)+1); 
2661 
} 
2662 
} 
2663 
#else

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

2665 
const int slevel = block[ scan_table[i] ]; 
2666 
if (slevel) {

2667 
int level;

2668 
int run = i  last_non_zero  1; 
2669 
last = (i == last_index); 
2670 
sign = 0;

2671 
level = slevel; 
2672 
if (level < 0) { 
2673 
sign = 1;

2674 
level = level; 
2675 
} 
2676 
code = get_rl_index(rl, last, run, level); 
2677 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2678 
if (code == rl>n) {

2679 
int level1, run1;

2680 
level1 = level  rl>max_level[last][run]; 
2681 
if (level1 < 1) 
2682 
goto esc2;

2683 
code = get_rl_index(rl, last, run, level1); 
2684 
if (code == rl>n) {

2685 
esc2:

2686 
put_bits(ac_pb, 1, 1); 
2687 
if (level > MAX_LEVEL)

2688 
goto esc3;

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

2690 
if (run1 < 0) 
2691 
goto esc3;

2692 
code = get_rl_index(rl, last, run1, level); 
2693 
if (code == rl>n) {

2694 
esc3:

2695 
/* third escape */

2696 
put_bits(ac_pb, 1, 1); 
2697 
put_bits(ac_pb, 1, last);

2698 
put_bits(ac_pb, 6, run);

2699 
put_bits(ac_pb, 1, 1); 
2700 
put_bits(ac_pb, 12, slevel & 0xfff); 
2701 
put_bits(ac_pb, 1, 1); 
2702 
} else {

2703 
/* second escape */

2704 
put_bits(ac_pb, 1, 0); 
2705 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2706 
put_bits(ac_pb, 1, sign);

2707 
} 
2708 
} else {

2709 
/* first escape */

2710 
put_bits(ac_pb, 1, 0); 
2711 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2712 
put_bits(ac_pb, 1, sign);

2713 
} 
2714 
} else {

2715 
put_bits(ac_pb, 1, sign);

2716 
} 
2717 
last_non_zero = i; 
2718 
} 
2719 
} 
2720 
#endif

2721 
} 
2722  
2723 
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2724 
uint8_t *scan_table) 
2725 
{ 
2726 
int i, last_non_zero;

2727 
const RLTable *rl;

2728 
uint8_t *len_tab; 
2729 
const int last_index = s>block_last_index[n]; 
2730 
int len=0; 
2731  
2732 
if (s>mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 
2733 
/* mpeg4 based DC predictor */

2734 
//mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME

2735 
if(last_index<1) return len; 
2736 
i = 1;

2737 
rl = &rl_intra; 
2738 
len_tab = uni_mpeg4_intra_rl_len; 
2739 
} else {

2740 
if(last_index<0) return 0; 
2741 
i = 0;

2742 
rl = &rl_inter; 
2743 
len_tab = uni_mpeg4_inter_rl_len; 
2744 
} 
2745  
2746 
/* AC coefs */

2747 
last_non_zero = i  1;

2748 
for (; i < last_index; i++) {

2749 
int level = block[ scan_table[i] ];

2750 
if (level) {

2751 
int run = i  last_non_zero  1; 
2752 
level+=64;

2753 
if((level&(~127)) == 0){ 
2754 
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 
2755 
len += len_tab[index]; 
2756 
}else{ //ESC3 
2757 
len += 7+2+1+6+1+12+1; 
2758 
} 
2759 
last_non_zero = i; 
2760 
} 
2761 
} 
2762 
/*if(i<=last_index)*/{

2763 
int level = block[ scan_table[i] ];

2764 
int run = i  last_non_zero  1; 
2765 
level+=64;

2766 
if((level&(~127)) == 0){ 
2767 
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 
2768 
len += len_tab[index]; 
2769 
}else{ //ESC3 
2770 
len += 7+2+1+6+1+12+1; 
2771 
} 
2772 
} 
2773 

2774 
return len;

2775 
} 
2776  
2777 
#endif

2778  
2779  
2780 
/***********************************************/

2781 
/* decoding */

2782  
2783 
static VLC intra_MCBPC_vlc;

2784 
static VLC inter_MCBPC_vlc;

2785 
static VLC cbpy_vlc;

2786 
static VLC mv_vlc;

2787 
static VLC dc_lum, dc_chrom;

2788 
static VLC sprite_trajectory;

2789 
static VLC mb_type_b_vlc;

2790 
static VLC h263_mbtype_b_vlc;

2791 
static VLC cbpc_b_vlc;

2792  
2793 
void init_vlc_rl(RLTable *rl)

2794 
{ 
2795 
int i, q;

2796 

2797 
init_vlc(&rl>vlc, 9, rl>n + 1, 
2798 
&rl>table_vlc[0][1], 4, 2, 
2799 
&rl>table_vlc[0][0], 4, 2); 
2800  
2801 

2802 
for(q=0; q<32; q++){ 
2803 
int qmul= q*2; 
2804 
int qadd= (q1)1; 
2805 

2806 
if(q==0){ 
2807 
qmul=1;

2808 
qadd=0;

2809 
} 
2810 

2811 
rl>rl_vlc[q]= av_malloc(rl>vlc.table_size*sizeof(RL_VLC_ELEM));

2812 
for(i=0; i<rl>vlc.table_size; i++){ 
2813 
int code= rl>vlc.table[i][0]; 
2814 
int len = rl>vlc.table[i][1]; 
2815 
int level, run;

2816 

2817 
if(len==0){ // illegal code 
2818 
run= 66;

2819 
level= MAX_LEVEL; 
2820 
}else if(len<0){ //more bits needed 
2821 
run= 0;

2822 
level= code; 
2823 
}else{

2824 
if(code==rl>n){ //esc 
2825 
run= 66;

2826 
level= 0;

2827 
}else{

2828 
run= rl>table_run [code] + 1;

2829 
level= rl>table_level[code] * qmul + qadd; 
2830 
if(code >= rl>last) run+=192; 
2831 
} 
2832 
} 
2833 
rl>rl_vlc[q][i].len= len; 
2834 
rl>rl_vlc[q][i].level= level; 
2835 
rl>rl_vlc[q][i].run= run; 
2836 
} 
2837 
} 
2838 
} 
2839  
2840 
/* init vlcs */

2841  
2842 
/* XXX: find a better solution to handle static init */

2843 
void h263_decode_init_vlc(MpegEncContext *s)

2844 
{ 
2845 
static int done = 0; 
2846  
2847 
if (!done) {

2848 
done = 1;

2849  
2850 
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,

2851 
intra_MCBPC_bits, 1, 1, 
2852 
intra_MCBPC_code, 1, 1); 
2853 
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,

2854 
inter_MCBPC_bits, 1, 1, 
2855 
inter_MCBPC_code, 1, 1); 
2856 
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,

2857 
&cbpy_tab[0][1], 2, 1, 
2858 
&cbpy_tab[0][0], 2, 1); 
2859 
init_vlc(&mv_vlc, MV_VLC_BITS, 33,

2860 
&mvtab[0][1], 2, 1, 
2861 
&mvtab[0][0], 2, 1); 
2862 
init_rl(&rl_inter); 
2863 
init_rl(&rl_intra); 
2864 
init_rl(&rvlc_rl_inter); 
2865 
init_rl(&rvlc_rl_intra); 
2866 
init_rl(&rl_intra_aic); 
2867 
init_vlc_rl(&rl_inter); 
2868 
init_vlc_rl(&rl_intra); 
2869 
init_vlc_rl(&rvlc_rl_inter); 
2870 
init_vlc_rl(&rvlc_rl_intra); 
2871 
init_vlc_rl(&rl_intra_aic); 
2872 
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, 
2873 
&DCtab_lum[0][1], 2, 1, 
2874 
&DCtab_lum[0][0], 2, 1); 
2875 
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, 
2876 
&DCtab_chrom[0][1], 2, 1, 
2877 
&DCtab_chrom[0][0], 2, 1); 
2878 
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,

2879 
&sprite_trajectory_tab[0][1], 4, 2, 
2880 
&sprite_trajectory_tab[0][0], 4, 2); 
2881 
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,

2882 
&mb_type_b_tab[0][1], 2, 1, 
2883 
&mb_type_b_tab[0][0], 2, 1); 
2884 
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,

2885 
&h263_mbtype_b_tab[0][1], 2, 1, 
2886 
&h263_mbtype_b_tab[0][0], 2, 1); 
2887 
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,

2888 
&cbpc_b_tab[0][1], 2, 1, 
2889 
&cbpc_b_tab[0][0], 2, 1); 
2890 
} 
2891 
} 
2892  
2893 
/**

2894 
* Get the GOB height based on picture height.

2895 
*/

2896 
int ff_h263_get_gob_height(MpegEncContext *s){

2897 
if (s>height <= 400) 
2898 
return 1; 
2899 
else if (s>height <= 800) 
2900 
return 2; 
2901 
else

2902 
return 4; 
2903 
} 
2904  
2905 
int ff_h263_decode_mba(MpegEncContext *s)

2906 
{ 
2907 
int i, mb_pos;

2908  
2909 
for(i=0; i<6; i++){ 
2910 
if(s>mb_num1 <= ff_mba_max[i]) break; 
2911 
} 
2912 
mb_pos= get_bits(&s>gb, ff_mba_length[i]); 
2913 
s>mb_x= mb_pos % s>mb_width; 
2914 
s>mb_y= mb_pos / s>mb_width; 
2915  
2916 
return mb_pos;

2917 
} 
2918  
2919 
void ff_h263_encode_mba(MpegEncContext *s)

2920 
{ 
2921 
int i, mb_pos;

2922  
2923 
for(i=0; i<6; i++){ 
2924 
if(s>mb_num1 <= ff_mba_max[i]) break; 
2925 
} 
2926 
mb_pos= s>mb_x + s>mb_width*s>mb_y; 
2927 
put_bits(&s>pb, ff_mba_length[i], mb_pos); 
2928 
} 
2929  
2930 
/**

2931 
* decodes the group of blocks header or slice header.

2932 
* @return <0 if an error occured

2933 
*/

2934 
static int h263_decode_gob_header(MpegEncContext *s) 
2935 
{ 
2936 
unsigned int val, gfid, gob_number; 
2937 
int left;

2938 

2939 
/* Check for GOB Start Code */

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

2941 
if(val)

2942 
return 1; 
2943  
2944 
/* We have a GBSC probably with GSTUFF */

2945 
skip_bits(&s>gb, 16); /* Drop the zeros */ 
2946 
left= s>gb.size_in_bits  get_bits_count(&s>gb); 
2947 
//MN: we must check the bits left or we might end in a infinite loop (or segfault)

2948 
for(;left>13; left){ 
2949 
if(get_bits1(&s>gb)) break; /* Seek the '1' bit */ 
2950 
} 
2951 
if(left<=13) 
2952 
return 1; 
2953  
2954 
if(s>h263_slice_structured){

2955 
if(get_bits1(&s>gb)==0) 
2956 
return 1; 
2957  
2958 
ff_h263_decode_mba(s); 
2959  
2960 
if(s>mb_num > 1583) 
2961 
if(get_bits1(&s>gb)==0) 
2962 
return 1; 
2963 

2964 
s>qscale = get_bits(&s>gb, 5); /* SQUANT */ 
2965 
if(get_bits1(&s>gb)==0) 
2966 
return 1; 
2967 
gfid = get_bits(&s>gb, 2); /* GFID */ 
2968 
}else{

2969 
gob_number = get_bits(&s>gb, 5); /* GN */ 
2970 
s>mb_x= 0;

2971 
s>mb_y= s>gob_index* gob_number; 
2972 
gfid = get_bits(&s>gb, 2); /* GFID */ 
2973 
s>qscale = get_bits(&s>gb, 5); /* GQUANT */ 
2974 
} 
2975 

2976 
if(s>mb_y >= s>mb_height)

2977 
return 1; 
2978  
2979 
if(s>qscale==0) 
2980 
return 1; 
2981  
2982 
return 0; 
2983 
} 
2984  
2985 
static inline void memsetw(short *tab, int val, int n) 
2986 
{ 
2987 
int i;

2988 
for(i=0;i<n;i++) 
2989 
tab[i] = val; 
2990 
} 
2991  
2992 
#ifdef CONFIG_ENCODERS

2993  
2994 
void ff_mpeg4_init_partitions(MpegEncContext *s)

2995 
{ 
2996 
uint8_t *start= pbBufPtr(&s>pb); 
2997 
uint8_t *end= s>pb.buf_end; 
2998 
int size= end  start;

2999 
int pb_size = size/3; 
3000 
int pb2_size= size/3; 
3001 
int tex_size= size  pb_size  pb2_size;

3002 

3003 
set_put_bits_buffer_size(&s>pb, pb_size); 
3004 
init_put_bits(&s>tex_pb, start + pb_size , tex_size); 
3005 
init_put_bits(&s>pb2 , start + pb_size + tex_size, pb2_size); 
3006 
} 
3007  
3008 
void ff_mpeg4_merge_partitions(MpegEncContext *s)

3009 
{ 
3010 
const int pb2_len = put_bits_count(&s>pb2 ); 
3011 
const int tex_pb_len= put_bits_count(&s>tex_pb); 
3012 
const int bits= put_bits_count(&s>pb); 
3013  
3014 
if(s>pict_type==I_TYPE){

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

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

3017 
s>i_tex_bits+= tex_pb_len; 
3018 
}else{

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

3020 
s>misc_bits+=17 + pb2_len;

3021 
s>mv_bits+= bits  s>last_bits; 
3022 
s>p_tex_bits+= tex_pb_len; 
3023 
} 
3024  
3025 
flush_put_bits(&s>pb2); 
3026 
flush_put_bits(&s>tex_pb); 
3027  
3028 
set_put_bits_buffer_size(&s>pb, s>pb2.buf_end  s>pb.buf); 
3029 
ff_copy_bits(&s>pb, s>pb2.buf , pb2_len); 
3030 
ff_copy_bits(&s>pb, s>tex_pb.buf, tex_pb_len); 
3031 
s>last_bits= put_bits_count(&s>pb); 
3032 
} 
3033  
3034 
#endif //CONFIG_ENCODERS 
3035  
3036 
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){

3037 
switch(s>pict_type){

3038 
case I_TYPE:

3039 
return 16; 
3040 
case P_TYPE:

3041 
case S_TYPE:

3042 
return s>f_code+15; 
3043 
case B_TYPE:

3044 
return FFMAX(FFMAX(s>f_code, s>b_code)+15, 17); 
3045 
default:

3046 
return 1; 
3047 
} 
3048 
} 
3049  
3050 
#ifdef CONFIG_ENCODERS

3051  
3052 
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)

3053 
{ 
3054 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
3055  
3056 
put_bits(&s>pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);

3057 
put_bits(&s>pb, 1, 1); 
3058 

3059 
put_bits(&s>pb, mb_num_bits, s>mb_x + s>mb_y*s>mb_width); 
3060 
put_bits(&s>pb, s>quant_precision, s>qscale); 
3061 
put_bits(&s>pb, 1, 0); /* no HEC */ 
3062 
} 
3063  
3064 
#endif //CONFIG_ENCODERS 
3065  
3066 
/**

3067 
* check if the next stuff is a resync marker or the end.

3068 
* @return 0 if not

3069 
*/

3070 
static inline int mpeg4_is_resync(MpegEncContext *s){ 
3071 
const int bits_count= get_bits_count(&s>gb); 
3072 

3073 
if(s>workaround_bugs&FF_BUG_NO_PADDING){

3074 
return 0; 
3075 
} 
3076  
3077 
if(bits_count + 8 >= s>gb.size_in_bits){ 
3078 
int v= show_bits(&s>gb, 8); 
3079 
v= 0x7F >> (7(bits_count&7)); 
3080 

3081 
if(v==0x7F) 
3082 
return 1; 
3083 
}else{

3084 
if(show_bits(&s>gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){ 
3085 
int len;

3086 
GetBitContext gb= s>gb; 
3087 

3088 
skip_bits(&s>gb, 1);

3089 
align_get_bits(&s>gb); 
3090 

3091 
for(len=0; len<32; len++){ 
3092 
if(get_bits1(&s>gb)) break; 
3093 
} 
3094  
3095 
s>gb= gb; 
3096  
3097 
if(len>=ff_mpeg4_get_video_packet_prefix_length(s))

3098 
return 1; 
3099 
} 
3100 
} 
3101 
return 0; 
3102 
} 
3103  
3104 
/**

3105 
* decodes the next video packet.

3106 
* @return <0 if something went wrong

3107 
*/

3108 
static int mpeg4_decode_video_packet_header(MpegEncContext *s) 
3109 
{ 
3110 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
3111 
int header_extension=0, mb_num, len; 
3112 

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

3114 
if( get_bits_count(&s>gb) > s>gb.size_in_bits20) return 1; 
3115  
3116 
for(len=0; len<32; len++){ 
3117 
if(get_bits1(&s>gb)) break; 
3118 
} 
3119  
3120 
if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){

3121 
av_log(s>avctx, AV_LOG_ERROR, "marker does not match f_code\n");

3122 
return 1; 
3123 
} 
3124 

3125 
if(s>shape != RECT_SHAPE){

3126 
header_extension= get_bits1(&s>gb); 
3127 
//FIXME more stuff here

3128 
} 
3129  
3130 
mb_num= get_bits(&s>gb, mb_num_bits); 
3131 
if(mb_num>=s>mb_num){

3132 
av_log(s>avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s>mb_num);

3133 
return 1; 
3134 
} 
3135 
if(s>pict_type == B_TYPE){

3136 
while(s>next_picture.mbskip_table[ s>mb_index2xy[ mb_num ] ]) mb_num++;

3137 
if(mb_num >= s>mb_num) return 1; // slice contains just skiped MBs which where allready decoded 
3138 
} 
3139 

3140 
s>mb_x= mb_num % s>mb_width; 
3141 
s>mb_y= mb_num / s>mb_width; 
3142  
3143 
if(s>shape != BIN_ONLY_SHAPE){

3144 
int qscale= get_bits(&s>gb, s>quant_precision);

3145 
if(qscale)

3146 
s>chroma_qscale=s>qscale= qscale; 
3147 
} 
3148  
3149 
if(s>shape == RECT_SHAPE){

3150 
header_extension= get_bits1(&s>gb); 
3151 
} 
3152 
if(header_extension){

3153 
int time_increment;

3154 
int time_incr=0; 
3155  
3156 
while (get_bits1(&s>gb) != 0) 
3157 
time_incr++; 
3158  
3159 
check_marker(&s>gb, "before time_increment in video packed header");

3160 
time_increment= get_bits(&s>gb, s>time_increment_bits); 
3161 
check_marker(&s>gb, "before vop_coding_type in video packed header");

3162 

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

3165  
3166 
if(s>shape != BIN_ONLY_SHAPE){

3167 
skip_bits(&s>gb, 3); /* intra dc vlc threshold */ 
3168 
//FIXME dont just ignore everything

3169 
if(s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

3170 
mpeg4_decode_sprite_trajectory(s); 
3171 
av_log(s>avctx, AV_LOG_ERROR, "untested\n");

3172 
} 
3173  
3174 
//FIXME reduced res stuff here

3175 

3176 
if (s>pict_type != I_TYPE) {

3177 
int f_code = get_bits(&s>gb, 3); /* fcode_for */ 
3178 
if(f_code==0){ 
3179 
av_log(s>avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");

3180 
} 
3181 
} 
3182 
if (s>pict_type == B_TYPE) {

3183 
int b_code = get_bits(&s>gb, 3); 
3184 
if(b_code==0){ 
3185 
av_log(s>avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");

3186 
} 
3187 
} 
3188 
} 
3189 
} 
3190 
//FIXME newpred stuff

3191 

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

3193  
3194 
return 0; 
3195 
} 
3196  
3197 
void ff_mpeg4_clean_buffers(MpegEncContext *s)

3198 
{ 
3199 
int c_wrap, c_xy, l_wrap, l_xy;

3200  
3201 
l_wrap= s>block_wrap[0];

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

3204 
c_xy= s>mb_y*c_wrap + s>mb_x; 
3205  
3206 
#if 0

3207 
/* clean DC */

3208 
memsetw(s>dc_val[0] + l_xy, 1024, l_wrap*2+1);

3209 
memsetw(s>dc_val[1] + c_xy, 1024, c_wrap+1);

3210 
memsetw(s>dc_val[2] + c_xy, 1024, c_wrap+1);

3211 
#endif

3212  
3213 
/* clean AC */

3214 
memset(s>ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); 
3215 
memset(s>ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 
3216 
memset(s>ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 
3217  
3218 
/* clean MV */

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

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

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

3222 
s>last_mv[0][0][0]= 
3223 
s>last_mv[0][0][1]= 
3224 
s>last_mv[1][0][0]= 
3225 
s>last_mv[1][0][1]= 0; 
3226 
} 
3227  
3228 
/**

3229 
* decodes the group of blocks / video packet header.

3230 
* @return <0 if no resync found

3231 
*/

3232 
int ff_h263_resync(MpegEncContext *s){

3233 
int left, ret;

3234 

3235 
if(s>codec_id==CODEC_ID_MPEG4){

3236 
skip_bits1(&s>gb); 
3237 
align_get_bits(&s>gb); 
3238 
} 
3239  
3240 
if(show_bits(&s>gb, 16)==0){ 
3241 
if(s>codec_id==CODEC_ID_MPEG4)

3242 
ret= mpeg4_decode_video_packet_header(s); 
3243 
else

3244 
ret= h263_decode_gob_header(s); 
3245 
if(ret>=0) 
3246 
return 0; 
3247 
} 
3248 
//ok, its not where its supposed to be ...

3249 
s>gb= s>last_resync_gb; 
3250 
align_get_bits(&s>gb); 
3251 
left= s>gb.size_in_bits  get_bits_count(&s>gb); 
3252 

3253 
for(;left>16+1+5+5; left=8){ 
3254 
if(show_bits(&s>gb, 16)==0){ 
3255 
GetBitContext bak= s>gb; 
3256  
3257 
if(s>codec_id==CODEC_ID_MPEG4)

3258 
ret= mpeg4_decode_video_packet_header(s); 
3259 
else

3260 
ret= h263_decode_gob_header(s); 
3261 
if(ret>=0) 
3262 
return 0; 
3263  
3264 
s>gb= bak; 
3265 
} 
3266 
skip_bits(&s>gb, 8);

3267 
} 
3268 

3269 
return 1; 
3270 
} 
3271  
3272 
/**

3273 
* gets the average motion vector for a GMC MB.

3274 
* @param n either 0 for the x component or 1 for y

3275 
* @returns the average MV for a GMC MB

3276 
*/

3277 
static inline int get_amv(MpegEncContext *s, int n){ 
3278 
int x, y, mb_v, sum, dx, dy, shift;

3279 
int len = 1 << (s>f_code + 4); 
3280 
const int a= s>sprite_warping_accuracy; 
3281  
3282 
if(s>real_sprite_warping_points==1){ 
3283 
if(s>divx_version==500 && s>divx_build==413) 
3284 
sum= s>sprite_offset[0][n] / (1<<(a  s>quarter_sample)); 
3285 
else

3286 
sum= RSHIFT(s>sprite_offset[0][n]<<s>quarter_sample, a);

3287 
}else{

3288 
dx= s>sprite_delta[n][0];

3289 
dy= s>sprite_delta[n][1];

3290 
shift= s>sprite_shift[0];

3291 
if(n) dy = 1<<(shift + a + 1); 
3292 
else dx = 1<<(shift + a + 1); 
3293 
mb_v= s>sprite_offset[0][n] + dx*s>mb_x*16 + dy*s>mb_y*16; 
3294  
3295 
sum=0;

3296 
for(y=0; y<16; y++){ 
3297 
int v;

3298 

3299 
v= mb_v + dy*y; 
3300 
//XXX FIXME optimize

3301 
for(x=0; x<16; x++){ 
3302 
sum+= v>>shift; 
3303 
v+= dx; 
3304 
} 
3305 
} 
3306 
sum= RSHIFT(sum, a+8s>quarter_sample);

3307 
} 
3308  
3309 
if (sum < len) sum= len;

3310 
else if (sum >= len) sum= len1; 
3311  
3312 
return sum;

3313 
} 
3314  
3315 
/**

3316 
* decodes first partition.

3317 
* @return number of MBs decoded or <0 if an error occured

3318 
*/

3319 
static int mpeg4_decode_partition_a(MpegEncContext *s){ 
3320 
int mb_num;

3321 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3322 

3323 
/* decode first partition */

3324 
mb_num=0;

3325 
s>first_slice_line=1;

3326 
for(; s>mb_y<s>mb_height; s>mb_y++){

3327 
ff_init_block_index(s); 
3328 
for(; s>mb_x<s>mb_width; s>mb_x++){

3329 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3330 
int cbpc;

3331 
int dir=0; 
3332 

3333 
mb_num++; 
3334 
ff_update_block_index(s); 
3335 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1) 
3336 
s>first_slice_line=0;

3337 

3338 
if(s>pict_type==I_TYPE){

3339 
int i;

3340  
3341 
do{

3342 
if(show_bits_long(&s>gb, 19)==DC_MARKER){ 
3343 
return mb_num1; 
3344 
} 
3345  
3346 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

3347 
if (cbpc < 0){ 
3348 
av_log(s>avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s>mb_x, s>mb_y);

3349 
return 1; 
3350 
} 
3351 
}while(cbpc == 8); 
3352 

3353 
s>cbp_table[xy]= cbpc & 3;

3354 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3355 
s>mb_intra = 1;

3356  
3357 
if(cbpc & 4) { 
3358 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3359 
} 
3360 
s>current_picture.qscale_table[xy]= s>qscale; 
3361  
3362 
s>mbintra_table[xy]= 1;

3363 
for(i=0; i<6; i++){ 
3364 
int dc_pred_dir;

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

3366 
if(dc < 0){ 
3367 
av_log(s>avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s>mb_x, s>mb_y);

3368 
return 1; 
3369 
} 
3370 
dir<<=1;

3371 
if(dc_pred_dir) dir=1; 
3372 
} 
3373 
s>pred_dir_table[xy]= dir; 
3374 
}else{ /* P/S_TYPE */ 
3375 
int mx, my, pred_x, pred_y, bits;

3376 
int16_t * const mot_val= s>current_picture.motion_val[0][s>block_index[0]]; 
3377 
const int stride= s>block_wrap[0]*2; 
3378  
3379 
try_again:

3380 
bits= show_bits(&s>gb, 17);

3381 
if(bits==MOTION_MARKER){

3382 
return mb_num1; 
3383 
} 
3384 
skip_bits1(&s>gb); 
3385 
if(bits&0x10000){ 
3386 
/* skip mb */

3387 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

3388 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_GMC  MB_TYPE_L0; 
3389 
mx= get_amv(s, 0);

3390 
my= get_amv(s, 1);

3391 
}else{

3392 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
3393 
mx=my=0;

3394 
} 
3395 
mot_val[0 ]= mot_val[2 ]= 
3396 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3397 
mot_val[1 ]= mot_val[3 ]= 
3398 
mot_val[1+stride]= mot_val[3+stride]= my; 
3399  
3400 
if(s>mbintra_table[xy])

3401 
ff_clean_intra_table_entries(s); 
3402 
continue;

3403 
} 
3404  
3405 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

3406 
if (cbpc < 0){ 
3407 
av_log(s>avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s>mb_x, s>mb_y);

3408 
return 1; 
3409 
} 
3410 
if(cbpc == 20) 
3411 
goto try_again;

3412  
3413 
s>cbp_table[xy]= cbpc&(8+3); //8 is dquant 
3414 

3415 
s>mb_intra = ((cbpc & 4) != 0); 
3416 

3417 
if(s>mb_intra){

3418 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3419 
s>mbintra_table[xy]= 1;

3420 
mot_val[0 ]= mot_val[2 ]= 
3421 
mot_val[0+stride]= mot_val[2+stride]= 0; 
3422 
mot_val[1 ]= mot_val[3 ]= 
3423 
mot_val[1+stride]= mot_val[3+stride]= 0; 
3424 
}else{

3425 
if(s>mbintra_table[xy])

3426 
ff_clean_intra_table_entries(s); 
3427  
3428 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
3429 
s>mcsel= get_bits1(&s>gb); 
3430 
else s>mcsel= 0; 
3431 

3432 
if ((cbpc & 16) == 0) { 
3433 
/* 16x16 motion prediction */

3434  
3435 
h263_pred_motion(s, 0, &pred_x, &pred_y);

3436 
if(!s>mcsel){

3437 
mx = h263_decode_motion(s, pred_x, s>f_code); 
3438 
if (mx >= 0xffff) 
3439 
return 1; 
3440  
3441 
my = h263_decode_motion(s, pred_y, s>f_code); 
3442 
if (my >= 0xffff) 
3443 
return 1; 
3444 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3445 
} else {

3446 
mx = get_amv(s, 0);

3447 
my = get_amv(s, 1);

3448 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_GMC  MB_TYPE_L0; 
3449 
} 
3450  
3451 
mot_val[0 ]= mot_val[2 ] = 
3452 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3453 
mot_val[1 ]= mot_val[3 ]= 
3454 
mot_val[1+stride]= mot_val[3+stride]= my; 
3455 
} else {

3456 
int i;

3457 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3458 
for(i=0;i<4;i++) { 
3459 
int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); 
3460 
mx = h263_decode_motion(s, pred_x, s>f_code); 
3461 
if (mx >= 0xffff) 
3462 
return 1; 
3463 

3464 
my = h263_decode_motion(s, pred_y, s>f_code); 
3465 
if (my >= 0xffff) 
3466 
return 1; 
3467 
mot_val[0] = mx;

3468 
mot_val[1] = my;

3469 
} 
3470 
} 
3471 
} 
3472 
} 
3473 
} 
3474 
s>mb_x= 0;

3475 
} 
3476  
3477 
return mb_num;

3478 
} 
3479  
3480 
/**

3481 
* decode second partition.

3482 
* @return <0 if an error occured

3483 
*/

3484 
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ 
3485 
int mb_num=0; 
3486 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3487  
3488 
s>mb_x= s>resync_mb_x; 
3489 
s>first_slice_line=1;

3490 
for(s>mb_y= s>resync_mb_y; mb_num < mb_count; s>mb_y++){

3491 
ff_init_block_index(s); 
3492 
for(; mb_num < mb_count && s>mb_x<s>mb_width; s>mb_x++){

3493 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3494  
3495 
mb_num++; 
3496 
ff_update_block_index(s); 
3497 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1) 
3498 
s>first_slice_line=0;

3499 

3500 
if(s>pict_type==I_TYPE){

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

3502 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3503 
if(cbpy<0){ 
3504 
av_log(s>avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3505 
return 1; 
3506 
} 
3507 

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

3509 
s>current_picture.mb_type[xy] = ac_pred*MB_TYPE_ACPRED; 
3510 
}else{ /* P  S_TYPE */ 
3511 
if(IS_INTRA(s>current_picture.mb_type[xy])){

3512 
int dir=0,i; 
3513 
int ac_pred = get_bits1(&s>gb);

3514 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3515  
3516 
if(cbpy<0){ 
3517 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3518 
return 1; 
3519 
} 
3520 

3521 
if(s>cbp_table[xy] & 8) { 
3522 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3523 
} 
3524 
s>current_picture.qscale_table[xy]= s>qscale; 
3525  
3526 
for(i=0; i<6; i++){ 
3527 
int dc_pred_dir;

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

3529 
if(dc < 0){ 
3530 
av_log(s>avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s>mb_x, s>mb_y);

3531 
return 1; 
3532 
} 
3533 
dir<<=1;

3534 
if(dc_pred_dir) dir=1; 
3535 
} 
3536 
s>cbp_table[xy]&= 3; //remove dquant 
3537 
s>cbp_table[xy]= cbpy<<2;

3538 
s>current_picture.mb_type[xy] = ac_pred*MB_TYPE_ACPRED; 
3539 
s>pred_dir_table[xy]= dir; 
3540 
}else if(IS_SKIP(s>current_picture.mb_type[xy])){ 
3541 
s>current_picture.qscale_table[xy]= s>qscale; 
3542 
s>cbp_table[xy]= 0;

3543 
}else{

3544 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3545  
3546 
if(cbpy<0){ 
3547 
av_log(s>avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3548 
return 1; 
3549 
} 
3550 

3551 
if(s>cbp_table[xy] & 8) { 
3552 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3553 
} 
3554 
s>current_picture.qscale_table[xy]= s>qscale; 
3555  
3556 
s>cbp_table[xy]&= 3; //remove dquant 
3557 
s>cbp_table[xy]= (cbpy^0xf)<<2; 
3558 
} 
3559 
} 
3560 
} 
3561 
if(mb_num >= mb_count) return 0; 
3562 
s>mb_x= 0;

3563 
} 
3564 
return 0; 
3565 
} 
3566  
3567 
/**

3568 
* decodes the first & second partition

3569 
* @return <0 if error (and sets error type in the error_status_table)

3570 
*/

3571 
int ff_mpeg4_decode_partitions(MpegEncContext *s)

3572 
{ 
3573 
int mb_num;

3574 
const int part_a_error= s>pict_type==I_TYPE ? (DC_ERRORMV_ERROR) : MV_ERROR; 
3575 
const int part_a_end = s>pict_type==I_TYPE ? (DC_END MV_END) : MV_END; 
3576 

3577 
mb_num= mpeg4_decode_partition_a(s); 
3578 
if(mb_num<0){ 
3579 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, part_a_error); 
3580 
return 1; 
3581 
} 
3582 

3583 
if(s>resync_mb_x + s>resync_mb_y*s>mb_width + mb_num > s>mb_num){

3584 
av_log(s>avctx, AV_LOG_ERROR, "slice below monitor ...\n");

3585 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, part_a_error); 
3586 
return 1; 
3587 
} 
3588  
3589 
s>mb_num_left= mb_num; 
3590 

3591 
if(s>pict_type==I_TYPE){

3592 
while(show_bits(&s>gb, 9) == 1) 
3593 
skip_bits(&s>gb, 9);

3594 
if(get_bits_long(&s>gb, 19)!=DC_MARKER){ 
3595 
av_log(s>avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s>mb_x, s>mb_y);

3596 
return 1; 
3597 
} 
3598 
}else{

3599 
while(show_bits(&s>gb, 10) == 1) 
3600 
skip_bits(&s>gb, 10);

3601 
if(get_bits(&s>gb, 17)!=MOTION_MARKER){ 
3602 
av_log(s>avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s>mb_x, s>mb_y);

3603 
return 1; 
3604 
} 
3605 
} 
3606 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x1, s>mb_y, part_a_end);

3607 

3608 
if( mpeg4_decode_partition_b(s, mb_num) < 0){ 
3609 
if(s>pict_type==P_TYPE)

3610 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, DC_ERROR); 
3611 
return 1; 
3612 
}else{

3613 
if(s>pict_type==P_TYPE)

3614 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x1, s>mb_y, DC_END);

3615 
} 
3616  
3617 
return 0; 
3618 
} 
3619  
3620 
/**

3621 
* decode partition C of one MB.

3622 
* @return <0 if an error occured

3623 
*/

3624 
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) 
3625 
{ 
3626 
int cbp, mb_type;

3627 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3628  
3629 
mb_type= s>current_picture.mb_type[xy]; 
3630 
cbp = s>cbp_table[xy]; 
3631  
3632 
if(s>current_picture.qscale_table[xy] != s>qscale){

3633 
ff_set_qscale(s, s>current_picture.qscale_table[xy] ); 
3634 
} 
3635 

3636 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

3637 
int i;

3638 
for(i=0; i<4; i++){ 
3639 
s>mv[0][i][0] = s>current_picture.motion_val[0][ s>block_index[i] ][0]; 
3640 
s>mv[0][i][1] = s>current_picture.motion_val[0][ s>block_index[i] ][1]; 
3641 
} 
3642 
s>mb_intra = IS_INTRA(mb_type); 
3643  
3644 
if (IS_SKIP(mb_type)) {

3645 
/* skip mb */

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

3648 
s>mv_dir = MV_DIR_FORWARD; 
3649 
s>mv_type = MV_TYPE_16X16; 
3650 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

3651 
s>mcsel=1;

3652 
s>mb_skiped = 0;

3653 
}else{

3654 
s>mcsel=0;

3655 
s>mb_skiped = 1;

3656 
} 
3657 
}else if(s>mb_intra){ 
3658 
s>ac_pred = IS_ACPRED(s>current_picture.mb_type[xy]); 
3659 
}else if(!s>mb_intra){ 
3660 
// s>mcsel= 0; //FIXME do we need to init that

3661 

3662 
s>mv_dir = MV_DIR_FORWARD; 
3663 
if (IS_8X8(mb_type)) {

3664 
s>mv_type = MV_TYPE_8X8; 
3665 
} else {

3666 
s>mv_type = MV_TYPE_16X16; 
3667 
} 
3668 
} 
3669 
} else { /* IFrame */ 
3670 
s>mb_intra = 1;

3671 
s>ac_pred = IS_ACPRED(s>current_picture.mb_type[xy]); 
3672 
} 
3673  
3674 
if (!IS_SKIP(mb_type)) {

3675 
int i;

3676 
/* decode each block */

3677 
for (i = 0; i < 6; i++) { 
3678 
if(mpeg4_decode_block(s, block[i], i, cbp&32, s>mb_intra, s>rvlc) < 0){ 
3679 
av_log(s>avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s>mb_x, s>mb_y, s>mb_intra);

3680 
return 1; 
3681 
} 
3682 
cbp+=cbp; 
3683 
} 
3684 
} 
3685  
3686 
/* perMB end of slice check */

3687  
3688 
if(s>mb_num_left <= 0){ 
3689 
//printf("%06X %d\n", show_bits(&s>gb, 24), s>gb.size_in_bits  get_bits_count(&s>gb));

3690 
if(mpeg4_is_resync(s))

3691 
return SLICE_END;

3692 
else

3693 
return SLICE_NOEND;

3694 
}else{

3695 
if(mpeg4_is_resync(s)){

3696 
const int delta= s>mb_x + 1 == s>mb_width ? 2 : 1; 
3697 
if(s>cbp_table[xy+delta])

3698 
return SLICE_END;

3699 
} 
3700 
return SLICE_OK;

3701 
} 
3702 
} 
3703  
3704 
/**

3705 
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)

3706 
*/

3707 
static void preview_obmc(MpegEncContext *s){ 
3708 
GetBitContext gb= s>gb; 
3709 

3710 
int cbpc, i, pred_x, pred_y, mx, my;

3711 
int16_t *mot_val; 
3712 
const int xy= s>mb_x + 1 + s>mb_y * s>mb_stride; 
3713 
const int stride= s>block_wrap[0]*2; 
3714 

3715 
for(i=0; i<4; i++) 
3716 
s>block_index[i]+= 2;

3717 
for(i=4; i<6; i++) 
3718 
s>block_index[i]+= 1;

3719 
s>mb_x++; 
3720 

3721 
assert(s>pict_type == P_TYPE); 
3722  
3723 
do{

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

3725 
/* skip mb */

3726 
mot_val = s>current_picture.motion_val[0][ s>block_index[0] ]; 
3727 
mot_val[0 ]= mot_val[2 ]= 
3728 
mot_val[0+stride]= mot_val[2+stride]= 0; 
3729 
mot_val[1 ]= mot_val[3 ]= 
3730 
mot_val[1+stride]= mot_val[3+stride]= 0; 
3731 

3732 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
3733 
goto end;

3734 
} 
3735 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

3736 
}while(cbpc == 20); 
3737 

3738 
if(cbpc & 4){ 
3739 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3740 
}else{

3741 
get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3742 
if (cbpc & 8) { 
3743 
if(s>modified_quant){

3744 
if(get_bits1(&s>gb)) skip_bits(&s>gb, 1); 
3745 
else skip_bits(&s>gb, 5); 
3746 
}else

3747 
skip_bits(&s>gb, 2);

3748 
} 
3749 

3750 
if ((cbpc & 16) == 0) { 
3751 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3752 
/* 16x16 motion prediction */

3753 
mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);

3754 
if (s>umvplus)

3755 
mx = h263p_decode_umotion(s, pred_x); 
3756 
else

3757 
mx = h263_decode_motion(s, pred_x, 1);

3758 

3759 
if (s>umvplus)

3760 
my = h263p_decode_umotion(s, pred_y); 
3761 
else

3762 
my = h263_decode_motion(s, pred_y, 1);

3763 

3764 
mot_val[0 ]= mot_val[2 ]= 
3765 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3766 
mot_val[1 ]= mot_val[3 ]= 
3767 
mot_val[1+stride]= mot_val[3+stride]= my; 
3768 
} else {

3769 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3770 
for(i=0;i<4;i++) { 
3771 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
3772 
if (s>umvplus)

3773 
mx = h263p_decode_umotion(s, pred_x); 
3774 
else

3775 
mx = h263_decode_motion(s, pred_x, 1);

3776 

3777 
if (s>umvplus)

3778 
my = h263p_decode_umotion(s, pred_y); 
3779 
else

3780 
my = h263_decode_motion(s, pred_y, 1);

3781 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3782 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3783 
mot_val[0] = mx;

3784 
mot_val[1] = my;

3785 
} 
3786 
} 
3787 
} 
3788 
end:

3789 

3790 
for(i=0; i<4; i++) 
3791 
s>block_index[i]= 2;

3792 
for(i=4; i<6; i++) 
3793 
s>block_index[i]= 1;

3794 
s>mb_x; 
3795  
3796 
s>gb= gb; 
3797 
} 
3798  
3799 
static void h263_decode_dquant(MpegEncContext *s){ 
3800 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3801  
3802 
if(s>modified_quant){

3803 
if(get_bits1(&s>gb))

3804 
s>qscale= modified_quant_tab[get_bits1(&s>gb)][ s>qscale ]; 
3805 
else

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

3807 
}else

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

3809 
ff_set_qscale(s, s>qscale); 
3810 
} 
3811  
3812 
int ff_h263_decode_mb(MpegEncContext *s,

3813 
DCTELEM block[6][64]) 
3814 
{ 
3815 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

3816 
int16_t *mot_val; 
3817 
const int xy= s>mb_x + s>mb_y * s>mb_stride; 
3818 

3819 
assert(!s>h263_pred); 
3820 

3821 
if (s>pict_type == P_TYPE) {

3822 
do{

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

3824 
/* skip mb */

3825 
s>mb_intra = 0;

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

3828 
s>mv_dir = MV_DIR_FORWARD; 
3829 
s>mv_type = MV_TYPE_16X16; 
3830 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
3831 
s>mv[0][0][0] = 0; 
3832 
s>mv[0][0][1] = 0; 
3833 
s>mb_skiped = !(s>obmc  s>loop_filter); 
3834 
goto end;

3835 
} 
3836 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

3837 
//fprintf(stderr, "\tCBPC: %d", cbpc);

3838 
if (cbpc < 0){ 
3839 
av_log(s>avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

3840 
return 1; 
3841 
} 
3842 
}while(cbpc == 20); 
3843 

3844 
dquant = cbpc & 8;

3845 
s>mb_intra = ((cbpc & 4) != 0); 
3846 
if (s>mb_intra) goto intra; 
3847 

3848 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3849 

3850 
if(s>alt_inter_vlc==0  (cbpc & 3)!=3) 
3851 
cbpy ^= 0xF;

3852 

3853 
cbp = (cbpc & 3)  (cbpy << 2); 
3854 
if (dquant) {

3855 
h263_decode_dquant(s); 
3856 
} 
3857 

3858 
s>mv_dir = MV_DIR_FORWARD; 
3859 
if ((cbpc & 16) == 0) { 
3860 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3861 
/* 16x16 motion prediction */

3862 
s>mv_type = MV_TYPE_16X16; 
3863 
h263_pred_motion(s, 0, &pred_x, &pred_y);

3864 
if (s>umvplus)

3865 
mx = h263p_decode_umotion(s, pred_x); 
3866 
else

3867 
mx = h263_decode_motion(s, pred_x, 1);

3868 

3869 
if (mx >= 0xffff) 
3870 
return 1; 
3871 

3872 
if (s>umvplus)

3873 
my = h263p_decode_umotion(s, pred_y); 
3874 
else

3875 
my = h263_decode_motion(s, pred_y, 1);

3876 

3877 
if (my >= 0xffff) 
3878 
return 1; 
3879 
s>mv[0][0][0] = mx; 
3880 
s>mv[0][0][1] = my; 
3881  
3882 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3883 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3884 
} else {

3885 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3886 
s>mv_type = MV_TYPE_8X8; 
3887 
for(i=0;i<4;i++) { 
3888 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
3889 
if (s>umvplus)

3890 
mx = h263p_decode_umotion(s, pred_x); 
3891 
else

3892 
mx = h263_decode_motion(s, pred_x, 1);

3893 
if (mx >= 0xffff) 
3894 
return 1; 
3895 

3896 
if (s>umvplus)

3897 
my = h263p_decode_umotion(s, pred_y); 
3898 
else

3899 
my = h263_decode_motion(s, pred_y, 1);

3900 
if (my >= 0xffff) 
3901 
return 1; 
3902 
s>mv[0][i][0] = mx; 
3903 
s>mv[0][i][1] = my; 
3904 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3905 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3906 
mot_val[0] = mx;

3907 
mot_val[1] = my;

3908 
} 
3909 
} 
3910  
3911 
/* decode each block */

3912 
for (i = 0; i < 6; i++) { 
3913 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
3914 
return 1; 
3915 
cbp+=cbp; 
3916 
} 
3917  
3918 
if(s>obmc){

3919 
if(s>pict_type == P_TYPE && s>mb_x+1<s>mb_width && s>mb_num_left != 1) 
3920 
preview_obmc(s); 
3921 
} 
3922 
} else if(s>pict_type==B_TYPE) { 
3923 
int mb_type;

3924 
const int stride= s>b8_stride; 
3925 
int16_t *mot_val0 = s>current_picture.motion_val[0][ 2*(s>mb_x + s>mb_y*stride) ]; 
3926 
int16_t *mot_val1 = s>current_picture.motion_val[1][ 2*(s>mb_x + s>mb_y*stride) ]; 
3927 
// const int mv_xy= s>mb_x + 1 + s>mb_y * s>mb_stride;

3928  
3929 
//FIXME ugly

3930 
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3931 
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3932 
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3933 
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; 
3934  
3935 
do{

3936 
mb_type= get_vlc2(&s>gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);

3937 
if (mb_type < 0){ 
3938 
av_log(s>avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s>mb_x, s>mb_y);

3939 
return 1; 
3940 
} 
3941  
3942 
mb_type= h263_mb_type_b_map[ mb_type ]; 
3943 
}while(!mb_type);

3944  
3945 
s>mb_intra = IS_INTRA(mb_type); 
3946 
if(HAS_CBP(mb_type)){

3947 
cbpc = get_vlc2(&s>gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);

3948 
if(s>mb_intra){

3949 
dquant = IS_QUANT(mb_type); 
3950 
goto intra;

3951 
} 
3952  
3953 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3954  
3955 
if (cbpy < 0){ 
3956 
av_log(s>avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

3957 
return 1; 
3958 
} 
3959 

3960 
if(s>alt_inter_vlc==0  (cbpc & 3)!=3) 
3961 
cbpy ^= 0xF;

3962 

3963 
cbp = (cbpc & 3)  (cbpy << 2); 
3964 
}else

3965 
cbp=0;

3966 

3967 
assert(!s>mb_intra); 
3968  
3969 
if(IS_QUANT(mb_type)){

3970 
h263_decode_dquant(s); 
3971 
} 
3972  
3973 
if(IS_DIRECT(mb_type)){

3974 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
3975 
mb_type = ff_mpeg4_set_direct_mv(s, 0, 0); 
3976 
}else{

3977 
s>mv_dir = 0;

3978 
s>mv_type= MV_TYPE_16X16; 
3979 
//FIXME UMV

3980  
3981 
if(USES_LIST(mb_type, 0)){ 
3982 
int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my); 
3983 
s>mv_dir = MV_DIR_FORWARD; 
3984  
3985 
mx = h263_decode_motion(s, mx, 1);

3986 
my = h263_decode_motion(s, my, 1);

3987 

3988 
s>mv[0][0][0] = mx; 
3989 
s>mv[0][0][1] = my; 
3990 
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 
3991 
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 
3992 
} 
3993 

3994 
if(USES_LIST(mb_type, 1)){ 
3995 
int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my); 
3996 
s>mv_dir = MV_DIR_BACKWARD; 
3997 

3998 
mx = h263_decode_motion(s, mx, 1);

3999 
my = h263_decode_motion(s, my, 1);

4000  
4001 
s>mv[1][0][0] = mx; 
4002 
s>mv[1][0][1] = my; 
4003 
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 
4004 
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 
4005 
} 
4006 
} 
4007 

4008 
s>current_picture.mb_type[xy]= mb_type; 
4009  
4010 
/* decode each block */

4011 
for (i = 0; i < 6; i++) { 
4012 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
4013 
return 1; 
4014 
cbp+=cbp; 
4015 
} 
4016 
} else { /* IFrame */ 
4017 
do{

4018 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

4019 
if (cbpc < 0){ 
4020 
av_log(s>avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

4021 
return 1; 
4022 
} 
4023 
}while(cbpc == 8); 
4024  
4025 
dquant = cbpc & 4;

4026 
s>mb_intra = 1;

4027 
intra:

4028 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
4029 
if (s>h263_aic) {

4030 
s>ac_pred = get_bits1(&s>gb); 
4031 
if(s>ac_pred){

4032 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA  MB_TYPE_ACPRED; 
4033 

4034 
s>h263_aic_dir = get_bits1(&s>gb); 
4035 
} 
4036 
}else

4037 
s>ac_pred = 0;

4038 

4039 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

4040 
if(cbpy<0){ 
4041 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

4042 
return 1; 
4043 
} 
4044 
cbp = (cbpc & 3)  (cbpy << 2); 
4045 
if (dquant) {

4046 
h263_decode_dquant(s); 
4047 
} 
4048  
4049 
/* decode each block */

4050 
for (i = 0; i < 6; i++) { 
4051 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
4052 
return 1; 
4053 
cbp+=cbp; 
4054 
} 
4055 
} 
4056 
end:

4057  
4058 
/* perMB end of slice check */

4059 
{ 
4060 
int v= show_bits(&s>gb, 16); 
4061 

4062 
if(get_bits_count(&s>gb) + 16 > s>gb.size_in_bits){ 
4063 
v>>= get_bits_count(&s>gb) + 16  s>gb.size_in_bits;

4064 
} 
4065  
4066 
if(v==0) 
4067 
return SLICE_END;

4068 
} 
4069  
4070 
return SLICE_OK;

4071 
} 
4072  
4073 
int ff_mpeg4_decode_mb(MpegEncContext *s,

4074 
DCTELEM block[6][64]) 
4075 
{ 
4076 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

4077 
int16_t *mot_val; 
4078 
static int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
4079 
const int xy= s>mb_x + s>mb_y * s>mb_stride; 
4080 

4081 
assert(s>h263_pred); 
4082 

4083 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

4084 
do{

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

4086 
/* skip mb */

4087 
s>mb_intra = 0;

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

4090 
s>mv_dir = MV_DIR_FORWARD; 
4091 
s>mv_type = MV_TYPE_16X16; 
4092 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

4093 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_GMC  MB_TYPE_16x16  MB_TYPE_L0; 
4094 
s>mcsel=1;

4095 
s>mv[0][0][0]= get_amv(s, 0); 
4096 
s>mv[0][0][1]= get_amv(s, 1); 
4097  
4098 
s>mb_skiped = 0;

4099 
}else{

4100 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
4101 
s>mcsel=0;

4102 
s>mv[0][0][0] = 0; 
4103 
s>mv[0][0][1] = 0; 
4104 
s>mb_skiped = 1;

4105 
} 
4106 
goto end;

4107 
} 
4108 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

4109 
//fprintf(stderr, "\tCBPC: %d", cbpc);

4110 
if (cbpc < 0){ 
4111 
av_log(s>avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

4112 
return 1; 
4113 
} 
4114 
}while(cbpc == 20); 
4115 

4116 
dquant = cbpc & 8;

4117 
s>mb_intra = ((cbpc & 4) != 0); 
4118 
if (s>mb_intra) goto intra; 
4119 

4120 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
4121 
s>mcsel= get_bits1(&s>gb); 
4122 
else s>mcsel= 0; 
4123 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; 
4124 

4125 
cbp = (cbpc & 3)  (cbpy << 2); 
4126 
if (dquant) {

4127 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

4128 
} 
4129 
if((!s>progressive_sequence) && (cbp  (s>workaround_bugs&FF_BUG_XVID_ILACE)))

4130 
s>interlaced_dct= get_bits1(&s>gb); 
4131 

4132 
s>mv_dir = MV_DIR_FORWARD; 
4133 
if ((cbpc & 16) == 0) { 
4134 
if(s>mcsel){

4135 
s>current_picture.mb_type[xy]= MB_TYPE_GMC  MB_TYPE_16x16  MB_TYPE_L0; 
4136 
/* 16x16 global motion prediction */

4137 
s>mv_type = MV_TYPE_16X16; 
4138 
mx= get_amv(s, 0);

4139 
my= get_amv(s, 1);

4140 
s>mv[0][0][0] = mx; 
4141 
s>mv[0][0][1] = my; 
4142 
}else if((!s>progressive_sequence) && get_bits1(&s>gb)){ 
4143 
s>current_picture.mb_type[xy]= MB_TYPE_16x8  MB_TYPE_L0  MB_TYPE_INTERLACED; 
4144 
/* 16x8 field motion prediction */

4145 
s>mv_type= MV_TYPE_FIELD; 
4146  
4147 
s>field_select[0][0]= get_bits1(&s>gb); 
4148 
s>field_select[0][1]= get_bits1(&s>gb); 
4149  
4150 
h263_pred_motion(s, 0, &pred_x, &pred_y);

4151 

4152 
for(i=0; i<2; i++){ 
4153 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4154 
if (mx >= 0xffff) 
4155 
return 1; 
4156 

4157 
my = h263_decode_motion(s, pred_y/2, s>f_code);

4158 
if (my >= 0xffff) 
4159 
return 1; 
4160  
4161 
s>mv[0][i][0] = mx; 
4162 
s>mv[0][i][1] = my; 
4163 
} 
4164 
}else{

4165 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
4166 
/* 16x16 motion prediction */

4167 
s>mv_type = MV_TYPE_16X16; 
4168 
h263_pred_motion(s, 0, &pred_x, &pred_y);

4169 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4170 

4171 
if (mx >= 0xffff) 
4172 
return 1; 
4173 

4174 
my = h263_decode_motion(s, pred_y, s>f_code); 
4175 

4176 
if (my >= 0xffff) 
4177 
return 1; 
4178 
s>mv[0][0][0] = mx; 
4179 
s>mv[0][0][1] = my; 
4180 
} 
4181 
} else {

4182 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
4183 
s>mv_type = MV_TYPE_8X8; 
4184 
for(i=0;i<4;i++) { 
4185 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
4186 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4187 
if (mx >= 0xffff) 
4188 
return 1; 
4189 

4190 
my = h263_decode_motion(s, pred_y, s>f_code); 
4191 
if (my >= 0xffff) 
4192 
return 1; 
4193 
s>mv[0][i][0] = mx; 
4194 
s>mv[0][i][1] = my; 
4195 
mot_val[0] = mx;

4196 
mot_val[1] = my;

4197 
} 
4198 
} 
4199 
} else if(s>pict_type==B_TYPE) { 
4200 
int modb1; // first bit of modb 
4201 
int modb2; // second bit of modb 
4202 
int mb_type;

4203  
4204 
s>mb_intra = 0; //Bframes never contain intra blocks 
4205 
s>mcsel=0; // ... true gmc blocks 
4206  
4207 
if(s>mb_x==0){ 
4208 
for(i=0; i<2; i++){ 
4209 
s>last_mv[i][0][0]= 
4210 
s>last_mv[i][0][1]= 
4211 
s>last_mv[i][1][0]= 
4212 
s>last_mv[i][1][1]= 0; 
4213 
} 
4214 
} 
4215  
4216 
/* if we skipped it in the future P Frame than skip it now too */

4217 
s>mb_skiped= s>next_picture.mbskip_table[s>mb_y * s>mb_stride + s>mb_x]; // Note, skiptab=0 if last was GMC

4218  
4219 
if(s>mb_skiped){

4220 
/* skip mb */

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

4223  
4224 
s>mv_dir = MV_DIR_FORWARD; 
4225 
s>mv_type = MV_TYPE_16X16; 
4226 
s>mv[0][0][0] = 0; 
4227 
s>mv[0][0][1] = 0; 
4228 
s>mv[1][0][0] = 0; 
4229 
s>mv[1][0][1] = 0; 
4230 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
4231 
goto end;

4232 
} 
4233  
4234 
modb1= get_bits1(&s>gb); 
4235 
if(modb1){

4236 
mb_type= MB_TYPE_DIRECT2  MB_TYPE_SKIP  MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded

4237 
cbp=0;

4238 
}else{

4239 
modb2= get_bits1(&s>gb); 
4240 
mb_type= get_vlc2(&s>gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);

4241 
if(mb_type<0){ 
4242 
av_log(s>avctx, AV_LOG_ERROR, "illegal MB_type\n");

4243 
return 1; 
4244 
} 
4245 
mb_type= mb_type_b_map[ mb_type ]; 
4246 
if(modb2) cbp= 0; 
4247 
else cbp= get_bits(&s>gb, 6); 
4248  
4249 
if ((!IS_DIRECT(mb_type)) && cbp) {

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

4251 
ff_set_qscale(s, s>qscale + get_bits1(&s>gb)*4  2); 
4252 
} 
4253 
} 
4254  
4255 
if(!s>progressive_sequence){

4256 
if(cbp)

4257 
s>interlaced_dct= get_bits1(&s>gb); 
4258  
4259 
if(!IS_DIRECT(mb_type) && get_bits1(&s>gb)){

4260 
mb_type = MB_TYPE_16x8  MB_TYPE_INTERLACED; 
4261 
mb_type &= ~MB_TYPE_16x16; 
4262  
4263 
if(USES_LIST(mb_type, 0)){ 
4264 
s>field_select[0][0]= get_bits1(&s>gb); 
4265 
s>field_select[0][1]= get_bits1(&s>gb); 
4266 
} 
4267 
if(USES_LIST(mb_type, 1)){ 
4268 
s>field_select[1][0]= get_bits1(&s>gb); 
4269 
s>field_select[1][1]= get_bits1(&s>gb); 
4270 
} 
4271 
} 
4272 
} 
4273  
4274 
s>mv_dir = 0;

4275 
if((mb_type & (MB_TYPE_DIRECT2MB_TYPE_INTERLACED)) == 0){ 
4276 
s>mv_type= MV_TYPE_16X16; 
4277  
4278 
if(USES_LIST(mb_type, 0)){ 
4279 
s>mv_dir = MV_DIR_FORWARD; 
4280  
4281 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
4282 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
4283 
s>last_mv[0][1][0]= s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
4284 
s>last_mv[0][1][1]= s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
4285 
} 
4286 

4287 
if(USES_LIST(mb_type, 1)){ 
4288 
s>mv_dir = MV_DIR_BACKWARD; 
4289  
4290 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
4291 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
4292 
s>last_mv[1][1][0]= s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
4293 
s>last_mv[1][1][1]= s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
4294 
} 
4295 
}else if(!IS_DIRECT(mb_type)){ 
4296 
s>mv_type= MV_TYPE_FIELD; 
4297  
4298 
if(USES_LIST(mb_type, 0)){ 
4299 
s>mv_dir = MV_DIR_FORWARD; 
4300 

4301 
for(i=0; i<2; i++){ 
4302 
mx = h263_decode_motion(s, s>last_mv[0][i][0] , s>f_code); 
4303 
my = h263_decode_motion(s, s>last_mv[0][i][1]/2, s>f_code); 
4304 
s>last_mv[0][i][0]= s>mv[0][i][0] = mx; 
4305 
s>last_mv[0][i][1]= (s>mv[0][i][1] = my)*2; 
4306 
} 
4307 
} 
4308 

4309 
if(USES_LIST(mb_type, 1)){ 
4310 
s>mv_dir = MV_DIR_BACKWARD; 
4311  
4312 
for(i=0; i<2; i++){ 
4313 
mx = h263_decode_motion(s, s>last_mv[1][i][0] , s>b_code); 
4314 
my = h263_decode_motion(s, s>last_mv[1][i][1]/2, s>b_code); 
4315 
s>last_mv[1][i][0]= s>mv[1][i][0] = mx; 
4316 
s>last_mv[1][i][1]= (s>mv[1][i][1] = my)*2; 
4317 
} 
4318 
} 
4319 
} 
4320 
} 
4321 

4322 
if(IS_DIRECT(mb_type)){

4323 
if(IS_SKIP(mb_type))

4324 
mx=my=0;

4325 
else{

4326 
mx = h263_decode_motion(s, 0, 1); 
4327 
my = h263_decode_motion(s, 0, 1); 
4328 
} 
4329 

4330 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
4331 
mb_type = ff_mpeg4_set_direct_mv(s, mx, my); 
4332 
} 
4333 
s>current_picture.mb_type[xy]= mb_type; 
4334 
} else { /* IFrame */ 
4335 
do{

4336 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

4337 
if (cbpc < 0){ 
4338 
av_log(s>avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

4339 
return 1; 
4340 
} 
4341 
}while(cbpc == 8); 
4342  
4343 
dquant = cbpc & 4;

4344 
s>mb_intra = 1;

4345 
intra:

4346 
s>ac_pred = get_bits1(&s>gb); 
4347 
if(s>ac_pred)

4348 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA  MB_TYPE_ACPRED; 
4349 
else

4350 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
4351 

4352 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

4353 
if(cbpy<0){ 
4354 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

4355 
return 1; 
4356 
} 
4357 
cbp = (cbpc & 3)  (cbpy << 2); 
4358 
if (dquant) {

4359 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

4360 
} 
4361 

4362 
if(!s>progressive_sequence)

4363 
s>interlaced_dct= get_bits1(&s>gb); 
4364  
4365 
/* decode each block */

4366 
for (i = 0; i < 6; i++) { 
4367 
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) 
4368 
return 1; 
4369 
cbp+=cbp; 
4370 
} 
4371 
goto end;

4372 
} 
4373  
4374 
/* decode each block */

4375 
for (i = 0; i < 6; i++) { 
4376 
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) 
4377 
return 1; 
4378 
cbp+=cbp; 
4379 
} 
4380 
end:

4381  
4382 
/* perMB end of slice check */

4383 
if(s>codec_id==CODEC_ID_MPEG4){

4384 
if(mpeg4_is_resync(s)){

4385 
const int delta= s>mb_x + 1 == s>mb_width ? 2 : 1; 
4386 
if(s>pict_type==B_TYPE && s>next_picture.mbskip_table[xy + delta])

4387 
return SLICE_OK;

4388 
return SLICE_END;

4389 
} 
4390 
} 
4391  
4392 
return SLICE_OK;

4393 
} 
4394  
4395 
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 
4396 
{ 
4397 
int code, val, sign, shift, l;

4398 
code = get_vlc2(&s>gb, mv_vlc.table, MV_VLC_BITS, 2);

4399  
4400 
if (code == 0) 
4401 
return pred;

4402 
if (code < 0) 
4403 
return 0xffff; 
4404  
4405 
sign = get_bits1(&s>gb); 
4406 
shift = f_code  1;

4407 
val = code; 
4408 
if (shift) {

4409 
val = (val  1) << shift;

4410 
val = get_bits(&s>gb, shift); 
4411 
val++; 
4412 
} 
4413 
if (sign)

4414 
val = val; 
4415 
val += pred; 
4416  
4417 
/* modulo decoding */

4418 
if (!s>h263_long_vectors) {

4419 
l = 1 << (f_code + 4); 
4420 
val = ((val + l)&(l*21))  l; 
4421 
} else {

4422 
/* horrible h263 long vector mode */

4423 
if (pred < 31 && val < 63) 
4424 
val += 64;

4425 
if (pred > 32 && val > 63) 
4426 
val = 64;

4427 

4428 
} 
4429 
return val;

4430 
} 
4431  
4432 
/* Decodes RVLC of H.263+ UMV */

4433 
static int h263p_decode_umotion(MpegEncContext * s, int pred) 
4434 
{ 
4435 
int code = 0, sign; 
4436 

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

4439 

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

4441 

4442 
while (get_bits1(&s>gb))

4443 
{ 
4444 
code <<= 1;

4445 
code += get_bits1(&s>gb); 
4446 
} 
4447 
sign = code & 1;

4448 
code >>= 1;

4449 

4450 
code = (sign) ? (pred  code) : (pred + code); 
4451 
#ifdef DEBUG

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

4453 
#endif

4454 
return code;

4455  
4456 
} 
4457  
4458 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
4459 
int n, int coded) 
4460 
{ 
4461 
int code, level, i, j, last, run;

4462 
RLTable *rl = &rl_inter; 
4463 
const uint8_t *scan_table;

4464 
GetBitContext gb= s>gb; 
4465  
4466 
scan_table = s>intra_scantable.permutated; 
4467 
if (s>h263_aic && s>mb_intra) {

4468 
rl = &rl_intra_aic; 
4469 
i = 0;

4470 
if (s>ac_pred) {

4471 
if (s>h263_aic_dir)

4472 
scan_table = s>intra_v_scantable.permutated; /* left */

4473 
else

4474 
scan_table = s>intra_h_scantable.permutated; /* top */

4475 
} 
4476 
} else if (s>mb_intra) { 
4477 
/* DC coef */

4478 
if(s>codec_id == CODEC_ID_RV10){

4479 
if (s>rv10_version == 3 && s>pict_type == I_TYPE) { 
4480 
int component, diff;

4481 
component = (n <= 3 ? 0 : n  4 + 1); 
4482 
level = s>last_dc[component]; 
4483 
if (s>rv10_first_dc_coded[component]) {

4484 
diff = rv_decode_dc(s, n); 
4485 
if (diff == 0xffff) 
4486 
return 1; 
4487 
level += diff; 
4488 
level = level & 0xff; /* handle wrap round */ 
4489 
s>last_dc[component] = level; 
4490 
} else {

4491 
s>rv10_first_dc_coded[component] = 1;

4492 
} 
4493 
} else {

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

4495 
} 
4496 
}else{

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

4498 
if((level&0x7F) == 0){ 
4499 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s>mb_x, s>mb_y);

4500 
if(s>error_resilience >= FF_ER_COMPLIANT)

4501 
return 1; 
4502 
} 
4503 
if (level == 255) 
4504 
level = 128;

4505 
} 
4506 
block[0] = level;

4507 
i = 1;

4508 
} else {

4509 
i = 0;

4510 
} 
4511 
if (!coded) {

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

4513 
goto not_coded;

4514 
s>block_last_index[n] = i  1;

4515 
return 0; 
4516 
} 
4517 
retry:

4518 
for(;;) {

4519 
code = get_vlc2(&s>gb, rl>vlc.table, TEX_VLC_BITS, 2);

4520 
if (code < 0){ 
4521 
av_log(s>avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s>mb_x, s>mb_y);

4522 
return 1; 
4523 
} 
4524 
if (code == rl>n) {

4525 
/* escape */

4526 
if (s>h263_flv > 1) { 
4527 
int is11 = get_bits1(&s>gb);

4528 
last = get_bits1(&s>gb); 
4529 
run = get_bits(&s>gb, 6);

4530 
if(is11){

4531 
level = get_sbits(&s>gb, 11);

4532 
} else {

4533 
level = get_sbits(&s>gb, 7);

4534 
} 
4535 
} else {

4536 
last = get_bits1(&s>gb); 
4537 
run = get_bits(&s>gb, 6);

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

4539 
if(level == 128){ 
4540 
if (s>codec_id == CODEC_ID_RV10) {

4541 
/* XXX: should patch encoder too */

4542 
level = get_sbits(&s>gb, 12);

4543 
}else{

4544 
level = get_bits(&s>gb, 5);

4545 
level = get_sbits(&s>gb, 6)<<5; 
4546 
} 
4547 
} 
4548 
} 
4549 
} else {

4550 
run = rl>table_run[code]; 
4551 
level = rl>table_level[code]; 
4552 
last = code >= rl>last; 
4553 
if (get_bits1(&s>gb))

4554 
level = level; 
4555 
} 
4556 
i += run; 
4557 
if (i >= 64){ 
4558 
if(s>alt_inter_vlc && rl == &rl_inter && !s>mb_intra){

4559 
//looks like a hack but no, its the way its supposed to work ...

4560 
rl = &rl_intra_aic; 
4561 
i = 0;

4562 
s>gb= gb; 
4563 
memset(block, 0, sizeof(DCTELEM)*64); 
4564 
goto retry;

4565 
} 
4566 
av_log(s>avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s>mb_x, s>mb_y);

4567 
return 1; 
4568 
} 
4569 
j = scan_table[i]; 
4570 
block[j] = level; 
4571 
if (last)

4572 
break;

4573 
i++; 
4574 
} 
4575 
not_coded:

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

4577 
h263_pred_acdc(s, block, n); 
4578 
i = 63;

4579 
} 
4580 
s>block_last_index[n] = i; 
4581 
return 0; 
4582 
} 
4583  
4584 
/**

4585 
* decodes the dc value.

4586 
* @param n block index (03 are luma, 45 are chroma)

4587 
* @param dir_ptr the prediction direction will be stored here

4588 
* @return the quantized dc

4589 
*/

4590 
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
4591 
{ 
4592 
int level, pred, code;

4593 
uint16_t *dc_val; 
4594  
4595 
if (n < 4) 
4596 
code = get_vlc2(&s>gb, dc_lum.table, DC_VLC_BITS, 1);

4597 
else

4598 
code = get_vlc2(&s>gb, dc_chrom.table, DC_VLC_BITS, 1);

4599 
if (code < 0  code > 9 /* && s>nbit<9 */){ 
4600 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc vlc\n");

4601 
return 1; 
4602 
} 
4603 
if (code == 0) { 
4604 
level = 0;

4605 
} else {

4606 
if(IS_3IV1){

4607 
if(code==1) 
4608 
level= 2*get_bits1(&s>gb)1; 
4609 
else{

4610 
if(get_bits1(&s>gb))

4611 
level = get_bits(&s>gb, code1) + (1<<(code1)); 
4612 
else

4613 
level = get_bits(&s>gb, code1)  (1<<(code1)); 
4614 
} 
4615 
}else{

4616 
level = get_xbits(&s>gb, code); 
4617 
} 
4618  
4619 
if (code > 8){ 
4620 
if(get_bits1(&s>gb)==0){ /* marker */ 
4621 
if(s>error_resilience>=2){ 
4622 
av_log(s>avctx, AV_LOG_ERROR, "dc marker bit missing\n");

4623 
return 1; 
4624 
} 
4625 
} 
4626 
} 
4627 
} 
4628 
pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
4629 
level += pred; 
4630 
if (level < 0){ 
4631 
if(s>error_resilience>=3){ 
4632 
av_log(s>avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s>mb_x, s>mb_y);

4633 
return 1; 
4634 
} 
4635 
level = 0;

4636 
} 
4637 
if (n < 4) { 
4638 
*dc_val = level * s>y_dc_scale; 
4639 
} else {

4640 
*dc_val = level * s>c_dc_scale; 
4641 
} 
4642 
if(IS_3IV1)

4643 
*dc_val = level * 8;

4644 

4645 
if(s>error_resilience>=3){ 
4646 
if(*dc_val > 2048 + s>y_dc_scale + s>c_dc_scale){ 
4647 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s>mb_x, s>mb_y);

4648 
return 1; 
4649 
} 
4650 
} 
4651 
return level;

4652 
} 
4653  
4654 
/**

4655 
* decodes a block.

4656 
* @return <0 if an error occured

4657 
*/

4658 
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
4659 
int n, int coded, int intra, int rvlc) 
4660 
{ 
4661 
int level, i, last, run;

4662 
int dc_pred_dir;

4663 
RLTable * rl; 
4664 
RL_VLC_ELEM * rl_vlc; 
4665 
const uint8_t * scan_table;

4666 
int qmul, qadd;

4667  
4668 
//Note intra & rvlc should be optimized away if this is inlined

4669 

4670 
if(intra) {

4671 
if(s>qscale < s>intra_dc_threshold){

4672 
/* DC coef */

4673 
if(s>partitioned_frame){

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

4675 
if(n<4) level= FASTDIV((level + (s>y_dc_scale>>1)), s>y_dc_scale); 
4676 
else level= FASTDIV((level + (s>c_dc_scale>>1)), s>c_dc_scale); 
4677 
dc_pred_dir= (s>pred_dir_table[s>mb_x + s>mb_y*s>mb_stride]<<n)&32;

4678 
}else{

4679 
level = mpeg4_decode_dc(s, n, &dc_pred_dir); 
4680 
if (level < 0) 
4681 
return 1; 
4682 
} 
4683 
block[0] = level;

4684 
i = 0;

4685 
}else{

4686 
i = 1;

4687 
} 
4688 
if (!coded)

4689 
goto not_coded;

4690 

4691 
if(rvlc){

4692 
rl = &rvlc_rl_intra; 
4693 
rl_vlc = rvlc_rl_intra.rl_vlc[0];

4694 
}else{

4695 
rl = &rl_intra; 
4696 
rl_vlc = rl_intra.rl_vlc[0];

4697 
} 
4698 
if (s>ac_pred) {

4699 
if (dc_pred_dir == 0) 
4700 
scan_table = s>intra_v_scantable.permutated; /* left */

4701 
else

4702 
scan_table = s>intra_h_scantable.permutated; /* top */

4703 
} else {

4704 
scan_table = s>intra_scantable.permutated; 
4705 
} 
4706 
qmul=1;

4707 
qadd=0;

4708 
} else {

4709 
i = 1;

4710 
if (!coded) {

4711 
s>block_last_index[n] = i; 
4712 
return 0; 
4713 
} 
4714 
if(rvlc) rl = &rvlc_rl_inter;

4715 
else rl = &rl_inter;

4716 

4717 
scan_table = s>intra_scantable.permutated; 
4718  
4719 
if(s>mpeg_quant){

4720 
qmul=1;

4721 
qadd=0;

4722 
if(rvlc){

4723 
rl_vlc = rvlc_rl_inter.rl_vlc[0];

4724 
}else{

4725 
rl_vlc = rl_inter.rl_vlc[0];

4726 
} 
4727 
}else{

4728 
qmul = s>qscale << 1;

4729 
qadd = (s>qscale  1)  1; 
4730 
if(rvlc){

4731 
rl_vlc = rvlc_rl_inter.rl_vlc[s>qscale]; 
4732 
}else{

4733 
rl_vlc = rl_inter.rl_vlc[s>qscale]; 
4734 
} 
4735 
} 
4736 
} 
4737 
{ 
4738 
OPEN_READER(re, &s>gb); 
4739 
for(;;) {

4740 
UPDATE_CACHE(re, &s>gb); 
4741 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2);

4742 
if (level==0) { 
4743 
/* escape */

4744 
if(rvlc){

4745 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4746 
av_log(s>avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");

4747 
return 1; 
4748 
}; SKIP_CACHE(re, &s>gb, 1);

4749 

4750 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
4751 
run= SHOW_UBITS(re, &s>gb, 6); LAST_SKIP_CACHE(re, &s>gb, 6); 
4752 
SKIP_COUNTER(re, &s>gb, 1+1+6); 
4753 
UPDATE_CACHE(re, &s>gb); 
4754 

4755 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4756 
av_log(s>avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");

4757 
return 1; 
4758 
}; SKIP_CACHE(re, &s>gb, 1);

4759 

4760 
level= SHOW_UBITS(re, &s>gb, 11); SKIP_CACHE(re, &s>gb, 11); 
4761 

4762 
if(SHOW_UBITS(re, &s>gb, 5)!=0x10){ 
4763 
av_log(s>avctx, AV_LOG_ERROR, "reverse esc missing\n");

4764 
return 1; 
4765 
}; SKIP_CACHE(re, &s>gb, 5);

4766  
4767 
level= level * qmul + qadd; 
4768 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); LAST_SKIP_CACHE(re, &s>gb, 1); 
4769 
SKIP_COUNTER(re, &s>gb, 1+11+5+1); 
4770  
4771 
i+= run + 1;

4772 
if(last) i+=192; 
4773 
}else{

4774 
int cache;

4775 
cache= GET_CACHE(re, &s>gb); 
4776  
4777 
if(IS_3IV1)

4778 
cache ^= 0xC0000000;

4779  
4 