ffmpeg / libavcodec / h263.c @ 399cec2f
History  View  Annotate  Download (205 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;

201  
202 
align_put_bits(&s>pb); 
203  
204 
/* Update the pointer to last GOB */

205 
s>ptr_lastgob = pbBufPtr(&s>pb); 
206 
put_bits(&s>pb, 22, 0x20); /* PSC */ 
207 
put_bits(&s>pb, 8, (((int64_t)s>picture_number * 30 * s>avctx>frame_rate_base) / 
208 
s>avctx>frame_rate) & 0xff);

209  
210 
put_bits(&s>pb, 1, 1); /* marker */ 
211 
put_bits(&s>pb, 1, 0); /* h263 id */ 
212 
put_bits(&s>pb, 1, 0); /* split screen off */ 
213 
put_bits(&s>pb, 1, 0); /* camera off */ 
214 
put_bits(&s>pb, 1, 0); /* freeze picture release off */ 
215 

216 
format = h263_get_picture_format(s>width, s>height); 
217 
if (!s>h263_plus) {

218 
/* H.263v1 */

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

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

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

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

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

224 
put_bits(&s>pb, 1, 0); /* unrestricted motion vector: off */ 
225 
put_bits(&s>pb, 1, 0); /* SAC: off */ 
226 
put_bits(&s>pb, 1, s>obmc); /* advanced prediction mode */ 
227 
put_bits(&s>pb, 1, 0); /* not PB frame */ 
228 
put_bits(&s>pb, 5, s>qscale);

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

231 
/* H.263v2 */

232 
/* H.263 Plus PTYPE */

233 
put_bits(&s>pb, 3, 7); 
234 
put_bits(&s>pb,3,1); /* Update Full Extended PTYPE */ 
235 
if (format == 7) 
236 
put_bits(&s>pb,3,6); /* Custom Source Format */ 
237 
else

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

239 

240 
put_bits(&s>pb,1,0); /* Custom PCF: off */ 
241 
put_bits(&s>pb,1, s>umvplus); /* Unrestricted Motion Vector */ 
242 
put_bits(&s>pb,1,0); /* SAC: off */ 
243 
put_bits(&s>pb,1,s>obmc); /* Advanced Prediction Mode */ 
244 
put_bits(&s>pb,1,s>h263_aic); /* Advanced Intra Coding */ 
245 
put_bits(&s>pb,1,s>loop_filter); /* Deblocking Filter */ 
246 
put_bits(&s>pb,1,s>h263_slice_structured); /* Slice Structured */ 
247 
put_bits(&s>pb,1,0); /* Reference Picture Selection: off */ 
248 
put_bits(&s>pb,1,0); /* Independent Segment Decoding: off */ 
249 
put_bits(&s>pb,1,s>alt_inter_vlc); /* Alternative Inter VLC */ 
250 
put_bits(&s>pb,1,s>modified_quant); /* Modified Quantization: */ 
251 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
252 
put_bits(&s>pb,3,0); /* Reserved */ 
253 

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

255 

256 
put_bits(&s>pb,1,0); /* Reference Picture Resampling: off */ 
257 
put_bits(&s>pb,1,0); /* ReducedResolution Update: off */ 
258 
put_bits(&s>pb,1,s>no_rounding); /* Rounding Type */ 
259 
put_bits(&s>pb,2,0); /* Reserved */ 
260 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
261 

262 
/* This should be here if PLUSPTYPE */

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

265 
if (format == 7) { 
266 
/* Custom Picture Format (CPFMT) */

267 
aspect_to_info(s, s>avctx>sample_aspect_ratio); 
268  
269 
put_bits(&s>pb,4,s>aspect_ratio_info);

270 
put_bits(&s>pb,9,(s>width >> 2)  1); 
271 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
272 
put_bits(&s>pb,9,(s>height >> 2)); 
273 
if (s>aspect_ratio_info == FF_ASPECT_EXTENDED){

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

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

276 
} 
277 
} 
278 

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

280 
if (s>umvplus)

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

282 
//FIXME check actual requested range

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

285 
put_bits(&s>pb,2,0); /* no weird submodes */ 
286  
287 
put_bits(&s>pb, 5, s>qscale);

288 
} 
289  
290 
put_bits(&s>pb, 1, 0); /* no PEI */ 
291  
292 
if(s>h263_slice_structured){

293 
put_bits(&s>pb, 1, 1); 
294 

295 
assert(s>mb_x == 0 && s>mb_y == 0); 
296 
ff_h263_encode_mba(s); 
297  
298 
put_bits(&s>pb, 1, 1); 
299 
} 
300  
301 
if(s>h263_aic){

302 
s>y_dc_scale_table= 
303 
s>c_dc_scale_table= ff_aic_dc_scale_table; 
304 
}else{

305 
s>y_dc_scale_table= 
306 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
307 
} 
308 
} 
309  
310 
/**

311 
* Encodes a group of blocks header.

312 
*/

313 
void h263_encode_gob_header(MpegEncContext * s, int mb_line) 
314 
{ 
315 
put_bits(&s>pb, 17, 1); /* GBSC */ 
316  
317 
if(s>h263_slice_structured){

318 
put_bits(&s>pb, 1, 1); 
319  
320 
ff_h263_encode_mba(s); 
321  
322 
if(s>mb_num > 1583) 
323 
put_bits(&s>pb, 1, 1); 
324 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
325 
put_bits(&s>pb, 1, 1); 
326 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
327 
}else{

328 
int gob_number= mb_line / s>gob_index;

329  
330 
put_bits(&s>pb, 5, gob_number); /* GN */ 
331 
put_bits(&s>pb, 2, s>pict_type == I_TYPE); /* GFID */ 
332 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
333 
} 
334 
} 
335  
336 
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ 
337 
int last=0; 
338 
int j;

339 
int rate=0; 
340  
341 
for(j=1; j<=block_last_index; j++){ 
342 
const int index= scantable[j]; 
343 
int level= block[index];

344 
if(level){

345 
level+= 64;

346 
if((level&(~127)) == 0){ 
347 
if(j<block_last_index) rate+= s>intra_ac_vlc_length [UNI_AC_ENC_INDEX(jlast1, level)]; 
348 
else rate+= s>intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(jlast1, level)]; 
349 
}else

350 
rate += s>ac_esc_length; 
351 
level= 64;

352  
353 
last= j; 
354 
} 
355 
} 
356 

357 
return rate;

358 
} 
359  
360 
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 
361 
{ 
362 
int score= 0; 
363 
int i, n;

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

365  
366 
memcpy(zigzag_last_index, s>block_last_index, sizeof(int)*6); 
367 

368 
for(n=0; n<6; n++){ 
369 
int16_t *ac_val, *ac_val1; 
370 

371 
score = get_block_rate(s, block[n], s>block_last_index[n], s>intra_scantable.permutated); 
372  
373 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
374 
ac_val1= ac_val; 
375 
if(dir[n]){

376 
const int xy= s>mb_x + s>mb_y*s>mb_stride  s>mb_stride; 
377 
/* top prediction */

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

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

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

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

385 
ac_val1[i+8]= level;

386 
} 
387 
}else{

388 
/* different qscale, we must rescale */

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

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

393 
ac_val1[i+8]= level;

394 
} 
395 
} 
396 
st[n]= s>intra_h_scantable.permutated; 
397 
}else{

398 
const int xy= s>mb_x1 + s>mb_y*s>mb_stride; 
399 
/* left prediction */

400 
ac_val= 16;

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

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

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

408 
} 
409 
}else{

410 
/* different qscale, we must rescale */

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

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

416 
} 
417 
} 
418 
st[n]= s>intra_v_scantable.permutated; 
419 
} 
420  
421 
for(i=63; i>0; i) //FIXME optimize 
422 
if(block[n][ st[n][i] ]) break; 
423 
s>block_last_index[n]= i; 
424  
425 
score += get_block_rate(s, block[n], s>block_last_index[n], st[n]); 
426 
} 
427  
428 
return score < 0; 
429 
} 
430  
431 
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 
432 
{ 
433 
int i, n;

434 
memcpy(s>block_last_index, zigzag_last_index, sizeof(int)*6); 
435  
436 
for(n=0; n<6; n++){ 
437 
int16_t *ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
438  
439 
st[n]= s>intra_scantable.permutated; 
440 
if(dir[n]){

441 
/* top prediction */

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

444 
} 
445 
}else{

446 
/* left prediction */

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

449 
} 
450 
} 
451 
} 
452 
} 
453  
454 
/**

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

456 
*/

457 
void ff_clean_h263_qscales(MpegEncContext *s){

458 
int i;

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

460 

461 
for(i=1; i<s>mb_num; i++){ 
462 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i1] ] >2) 
463 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i1] ]+2; 
464 
} 
465 
for(i=s>mb_num2; i>=0; i){ 
466 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i+1] ] >2) 
467 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i+1] ]+2; 
468 
} 
469 
} 
470  
471 
/**

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

473 
*/

474 
void ff_clean_mpeg4_qscales(MpegEncContext *s){

475 
int i;

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

477  
478 
ff_clean_h263_qscales(s); 
479 

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

482 

483 
if(qscale_table[mb_xy] != qscale_table[s>mb_index2xy[i1]] && (s>mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ 
484 
s>mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V; 
485 
s>mb_type[mb_xy]= CANDIDATE_MB_TYPE_INTER; 
486 
} 
487 
} 
488  
489 
if(s>pict_type== B_TYPE){

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

492 
for the actual adaptive quantization */

493 

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

496 
odd += qscale_table[mb_xy]&1;

497 
} 
498 

499 
if(2*odd > s>mb_num) odd=1; 
500 
else odd=0; 
501 

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

504 
if((qscale_table[mb_xy]&1) != odd) 
505 
qscale_table[mb_xy]++; 
506 
if(qscale_table[mb_xy] > 31) 
507 
qscale_table[mb_xy]= 31;

508 
} 
509 

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

512 
if(qscale_table[mb_xy] != qscale_table[s>mb_index2xy[i1]] && (s>mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ 
513 
s>mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT; 
514 
s>mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR; 
515 
} 
516 
} 
517 
} 
518 
} 
519  
520 
#endif //CONFIG_ENCODERS 
521 
/**

522 
*

523 
* @return the mb_type

524 
*/

525 
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ 
526 
const int mb_index= s>mb_x + s>mb_y*s>mb_stride; 
527 
const int colocated_mb_type= s>next_picture.mb_type[mb_index]; 
528 
int xy= s>block_index[0]; 
529 
uint16_t time_pp= s>pp_time; 
530 
uint16_t time_pb= s>pb_time; 
531 
int i;

532 

533 
//FIXME avoid divides

534 

535 
if(IS_8X8(colocated_mb_type)){

536 
s>mv_type = MV_TYPE_8X8; 
537 
for(i=0; i<4; i++){ 
538 
xy= s>block_index[i]; 
539 
s>mv[0][i][0] = s>next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx; 
540 
s>mv[0][i][1] = s>next_picture.motion_val[0][xy][1]*time_pb/time_pp + my; 
541 
s>mv[1][i][0] = mx ? s>mv[0][i][0]  s>next_picture.motion_val[0][xy][0] 
542 
: s>next_picture.motion_val[0][xy][0]*(time_pb  time_pp)/time_pp; 
543 
s>mv[1][i][1] = my ? s>mv[0][i][1]  s>next_picture.motion_val[0][xy][1] 
544 
: s>next_picture.motion_val[0][xy][1]*(time_pb  time_pp)/time_pp; 
545 
} 
546 
return MB_TYPE_DIRECT2  MB_TYPE_8x8  MB_TYPE_L0L1;

547 
} else if(IS_INTERLACED(colocated_mb_type)){ 
548 
s>mv_type = MV_TYPE_FIELD; 
549 
for(i=0; i<2; i++){ 
550 
if(s>top_field_first){

551 
time_pp= s>pp_field_time  s>p_field_select_table[i][mb_index] + i; 
552 
time_pb= s>pb_field_time  s>p_field_select_table[i][mb_index] + i; 
553 
}else{

554 
time_pp= s>pp_field_time + s>p_field_select_table[i][mb_index]  i; 
555 
time_pb= s>pb_field_time + s>p_field_select_table[i][mb_index]  i; 
556 
} 
557 
s>mv[0][i][0] = s>p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; 
558 
s>mv[0][i][1] = s>p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; 
559 
s>mv[1][i][0] = mx ? s>mv[0][i][0]  s>p_field_mv_table[i][0][mb_index][0] 
560 
: s>p_field_mv_table[i][0][mb_index][0]*(time_pb  time_pp)/time_pp; 
561 
s>mv[1][i][1] = my ? s>mv[0][i][1]  s>p_field_mv_table[i][0][mb_index][1] 
562 
: s>p_field_mv_table[i][0][mb_index][1]*(time_pb  time_pp)/time_pp; 
563 
} 
564 
return MB_TYPE_DIRECT2  MB_TYPE_16x8  MB_TYPE_L0L1  MB_TYPE_INTERLACED;

565 
}else{

566 
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; 
567 
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; 
568 
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] 
569 
: s>next_picture.motion_val[0][xy][0]*(time_pb  time_pp)/time_pp; 
570 
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] 
571 
: s>next_picture.motion_val[0][xy][1]*(time_pb  time_pp)/time_pp; 
572 
if((s>avctx>workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE)  !s>quarter_sample)

573 
s>mv_type= MV_TYPE_16X16; 
574 
else

575 
s>mv_type= MV_TYPE_8X8; 
576 
return MB_TYPE_DIRECT2  MB_TYPE_16x16  MB_TYPE_L0L1; //Note see prev line 
577 
} 
578 
} 
579  
580 
void ff_h263_update_motion_val(MpegEncContext * s){

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

583 
const int wrap = s>block_wrap[0]; 
584 
const int xy = s>block_index[0]; 
585 

586 
s>current_picture.mbskip_table[mb_xy]= s>mb_skiped; 
587  
588 
if(s>mv_type != MV_TYPE_8X8){

589 
int motion_x, motion_y;

590 
if (s>mb_intra) {

591 
motion_x = 0;

592 
motion_y = 0;

593 
} else if (s>mv_type == MV_TYPE_16X16) { 
594 
motion_x = s>mv[0][0][0]; 
595 
motion_y = s>mv[0][0][1]; 
596 
} else /*if (s>mv_type == MV_TYPE_FIELD)*/ { 
597 
int i;

598 
motion_x = s>mv[0][0][0] + s>mv[0][1][0]; 
599 
motion_y = s>mv[0][0][1] + s>mv[0][1][1]; 
600 
motion_x = (motion_x>>1)  (motion_x&1); 
601 
for(i=0; i<2; i++){ 
602 
s>p_field_mv_table[i][0][mb_xy][0]= s>mv[0][i][0]; 
603 
s>p_field_mv_table[i][0][mb_xy][1]= s>mv[0][i][1]; 
604 
s>p_field_select_table[i][mb_xy]= s>field_select[0][i];

605 
} 
606 
} 
607 

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

609 
s>current_picture.motion_val[0][xy][0] = motion_x; 
610 
s>current_picture.motion_val[0][xy][1] = motion_y; 
611 
s>current_picture.motion_val[0][xy + 1][0] = motion_x; 
612 
s>current_picture.motion_val[0][xy + 1][1] = motion_y; 
613 
s>current_picture.motion_val[0][xy + wrap][0] = motion_x; 
614 
s>current_picture.motion_val[0][xy + wrap][1] = motion_y; 
615 
s>current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; 
616 
s>current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; 
617 
} 
618  
619 
if(s>encoding){ //FIXME encoding MUST be cleaned up 
620 
if (s>mv_type == MV_TYPE_8X8)

621 
s>current_picture.mb_type[mb_xy]= MB_TYPE_L0  MB_TYPE_8x8; 
622 
else if(s>mb_intra) 
623 
s>current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; 
624 
else

625 
s>current_picture.mb_type[mb_xy]= MB_TYPE_L0  MB_TYPE_16x16; 
626 
} 
627 
} 
628  
629 
#ifdef CONFIG_ENCODERS

630  
631 
static inline int get_p_cbp(MpegEncContext * s, 
632 
DCTELEM block[6][64], 
633 
int motion_x, int motion_y){ 
634 
int cbp, i;

635  
636 
if(s>flags & CODEC_FLAG_CBP_RD){

637 
int best_cbpy_score= INT_MAX;

638 
int best_cbpc_score= INT_MAX;

639 
int cbpc = (1), cbpy= (1); 
640 
const int offset= (s>mv_type==MV_TYPE_16X16 ? 0 : 16) + (s>dquant ? 8 : 0); 
641 
const int lambda= s>lambda2 >> (FF_LAMBDA_SHIFT  6); 
642  
643 
for(i=0; i<4; i++){ 
644 
int score= inter_MCBPC_bits[i + offset] * lambda;

645 
if(i&1) score += s>coded_score[5]; 
646 
if(i&2) score += s>coded_score[4]; 
647  
648 
if(score < best_cbpc_score){

649 
best_cbpc_score= score; 
650 
cbpc= i; 
651 
} 
652 
} 
653  
654 
for(i=0; i<16; i++){ 
655 
int score= cbpy_tab[i ^ 0xF][1] * lambda; 
656 
if(i&1) score += s>coded_score[3]; 
657 
if(i&2) score += s>coded_score[2]; 
658 
if(i&4) score += s>coded_score[1]; 
659 
if(i&8) score += s>coded_score[0]; 
660  
661 
if(score < best_cbpy_score){

662 
best_cbpy_score= score; 
663 
cbpy= i; 
664 
} 
665 
} 
666 
cbp= cbpc + 4*cbpy;

667 
if ((motion_x  motion_y  s>dquant) == 0 && s>mv_type==MV_TYPE_16X16){ 
668 
if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) 
669 
cbp= 0;

670 
} 
671  
672 
for (i = 0; i < 6; i++) { 
673 
if (s>block_last_index[i] >= 0 && ((cbp >> (5  i))&1)==0 ){ 
674 
s>block_last_index[i]= 1;

675 
memset(s>block[i], 0, sizeof(DCTELEM)*64); 
676 
} 
677 
} 
678 
}else{

679 
cbp= 0;

680 
for (i = 0; i < 6; i++) { 
681 
if (s>block_last_index[i] >= 0) 
682 
cbp = 1 << (5  i); 
683 
} 
684 
} 
685 
return cbp;

686 
} 
687  
688 
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], 
689 
int motion_x, int motion_y, int mb_type){ 
690 
int cbp=0, i; 
691  
692 
if(s>flags & CODEC_FLAG_CBP_RD){

693 
int score=0; 
694 
const int lambda= s>lambda2 >> (FF_LAMBDA_SHIFT  6); 
695 

696 
for(i=0; i<6; i++){ 
697 
if(s>coded_score[i] < 0){ 
698 
score += s>coded_score[i]; 
699 
cbp = 1 << (5  i); 
700 
} 
701 
} 
702 

703 
if(cbp){

704 
int zero_score= 6; 
705 
if ((motion_x  motion_y  s>dquant  mb_type) == 0){ 
706 
zero_score= 4; //2*MV + mb_type + cbp bit 
707 
} 
708  
709 
zero_score*= lambda; 
710 
if(zero_score <= score){

711 
cbp=0;

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

718 
memset(s>block[i], 0, sizeof(DCTELEM)*64); 
719 
} 
720 
} 
721 
}else{

722 
for (i = 0; i < 6; i++) { 
723 
if (s>block_last_index[i] >= 0) 
724 
cbp = 1 << (5  i); 
725 
} 
726 
} 
727 
return cbp;

728 
} 
729  
730 
void mpeg4_encode_mb(MpegEncContext * s,

731 
DCTELEM block[6][64], 
732 
int motion_x, int motion_y) 
733 
{ 
734 
int cbpc, cbpy, pred_x, pred_y;

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

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

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

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

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

742 
if (!s>mb_intra) {

743 
int i, cbp;

744 

745 
if(s>pict_type==B_TYPE){

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

748  
749 
if(s>mb_x==0){ 
750 
for(i=0; i<2; i++){ 
751 
s>last_mv[i][0][0]= 
752 
s>last_mv[i][0][1]= 
753 
s>last_mv[i][1][0]= 
754 
s>last_mv[i][1][1]= 0; 
755 
} 
756 
} 
757 

758 
assert(s>dquant>=2 && s>dquant<=2); 
759 
assert((s>dquant&1)==0); 
760 
assert(mb_type>=0);

761  
762 
/* nothing to do if this MB was skiped in the next P Frame */

763 
if(s>next_picture.mbskip_table[s>mb_y * s>mb_stride + s>mb_x]){ //FIXME avoid DCT & ... 
764 
s>skip_count++; 
765 
s>mv[0][0][0]= 
766 
s>mv[0][0][1]= 
767 
s>mv[1][0][0]= 
768 
s>mv[1][0][1]= 0; 
769 
s>mv_dir= MV_DIR_FORWARD; //doesnt matter

770 
s>qscale = s>dquant; 
771 
// s>mb_skiped=1;

772  
773 
return;

774 
} 
775 

776 
cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); 
777 

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

780 
assert(s>dquant==0);

781 

782 
put_bits(&s>pb, 1, 1); /* mb not coded modb1=1 */ 
783  
784 
if(interleaved_stats){

785 
s>misc_bits++; 
786 
s>last_bits++; 
787 
} 
788 
s>skip_count++; 
789 
return;

790 
} 
791 

792 
put_bits(&s>pb, 1, 0); /* mb coded modb1=0 */ 
793 
put_bits(&s>pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge 
794 
put_bits(&s>pb, mb_type+1, 1); // this table is so simple that we dont need it :) 
795 
if(cbp) put_bits(&s>pb, 6, cbp); 
796 

797 
if(cbp && mb_type){

798 
if(s>dquant)

799 
put_bits(&s>pb, 2, (s>dquant>>2)+3); 
800 
else

801 
put_bits(&s>pb, 1, 0); 
802 
}else

803 
s>qscale = s>dquant; 
804 

805 
if(!s>progressive_sequence){

806 
if(cbp)

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

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

810 
} 
811  
812 
if(interleaved_stats){

813 
s>misc_bits+= get_bits_diff(s); 
814 
} 
815  
816 
if(mb_type == 0){ 
817 
assert(s>mv_dir & MV_DIRECT); 
818 
h263_encode_motion(s, motion_x, 1);

819 
h263_encode_motion(s, motion_y, 1);

820 
s>b_count++; 
821 
s>f_count++; 
822 
}else{

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

825 
if(s>mv_dir & MV_DIR_FORWARD){

826 
h263_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
827 
h263_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
828 
s>last_mv[0][0][0]= s>last_mv[0][1][0]= s>mv[0][0][0]; 
829 
s>last_mv[0][0][1]= s>last_mv[0][1][1]= s>mv[0][0][1]; 
830 
s>f_count++; 
831 
} 
832 
if(s>mv_dir & MV_DIR_BACKWARD){

833 
h263_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
834 
h263_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
835 
s>last_mv[1][0][0]= s>last_mv[1][1][0]= s>mv[1][0][0]; 
836 
s>last_mv[1][0][1]= s>last_mv[1][1][1]= s>mv[1][0][1]; 
837 
s>b_count++; 
838 
} 
839 
}else{

840 
if(s>mv_dir & MV_DIR_FORWARD){

841 
put_bits(&s>pb, 1, s>field_select[0][0]); 
842 
put_bits(&s>pb, 1, s>field_select[0][1]); 
843 
} 
844 
if(s>mv_dir & MV_DIR_BACKWARD){

845 
put_bits(&s>pb, 1, s>field_select[1][0]); 
846 
put_bits(&s>pb, 1, s>field_select[1][1]); 
847 
} 
848 
if(s>mv_dir & MV_DIR_FORWARD){

849 
for(i=0; i<2; i++){ 
850 
h263_encode_motion(s, s>mv[0][i][0]  s>last_mv[0][i][0] , s>f_code); 
851 
h263_encode_motion(s, s>mv[0][i][1]  s>last_mv[0][i][1]/2, s>f_code); 
852 
s>last_mv[0][i][0]= s>mv[0][i][0]; 
853 
s>last_mv[0][i][1]= s>mv[0][i][1]*2; 
854 
} 
855 
s>f_count++; 
856 
} 
857 
if(s>mv_dir & MV_DIR_BACKWARD){

858 
for(i=0; i<2; i++){ 
859 
h263_encode_motion(s, s>mv[1][i][0]  s>last_mv[1][i][0] , s>b_code); 
860 
h263_encode_motion(s, s>mv[1][i][1]  s>last_mv[1][i][1]/2, s>b_code); 
861 
s>last_mv[1][i][0]= s>mv[1][i][0]; 
862 
s>last_mv[1][i][1]= s>mv[1][i][1]*2; 
863 
} 
864 
s>b_count++; 
865 
} 
866 
} 
867 
} 
868  
869 
if(interleaved_stats){

870 
s>mv_bits+= get_bits_diff(s); 
871 
} 
872  
873 
/* encode each block */

874 
for (i = 0; i < 6; i++) { 
875 
mpeg4_encode_block(s, block[i], i, 0, s>intra_scantable.permutated, NULL, &s>pb); 
876 
} 
877  
878 
if(interleaved_stats){

879 
s>p_tex_bits+= get_bits_diff(s); 
880 
} 
881  
882 
}else{ /* s>pict_type==B_TYPE */ 
883 
cbp= get_p_cbp(s, block, motion_x, motion_y); 
884 

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

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

888 
if(s>max_b_frames>0){ 
889 
int i;

890 
int x,y, offset;

891 
uint8_t *p_pic; 
892  
893 
x= s>mb_x*16;

894 
y= s>mb_y*16;

895 
if(x+16 > s>width) x= s>width16; 
896 
if(y+16 > s>height) y= s>height16; 
897  
898 
offset= x + y*s>linesize; 
899 
p_pic= s>new_picture.data[0] + offset;

900 

901 
s>mb_skiped=1;

902 
for(i=0; i<s>max_b_frames; i++){ 
903 
uint8_t *b_pic; 
904 
int diff;

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

906  
907 
if(pic==NULL  pic>pict_type!=B_TYPE) break; 
908  
909 
b_pic= pic>data[0] + offset + 16; //FIXME +16 
910 
diff= s>dsp.sad[0](NULL, p_pic, b_pic, s>linesize, 16); 
911 
if(diff>s>qscale*70){ //FIXME check that 70 is optimal 
912 
s>mb_skiped=0;

913 
break;

914 
} 
915 
} 
916 
}else

917 
s>mb_skiped=1;

918  
919 
if(s>mb_skiped==1){ 
920 
/* skip macroblock */

921 
put_bits(&s>pb, 1, 1); 
922  
923 
if(interleaved_stats){

924 
s>misc_bits++; 
925 
s>last_bits++; 
926 
} 
927 
s>skip_count++; 
928 

929 
return;

930 
} 
931 
} 
932  
933 
put_bits(&s>pb, 1, 0); /* mb coded */ 
934 
cbpc = cbp & 3;

935 
cbpy = cbp >> 2;

936 
cbpy ^= 0xf;

937 
if(s>mv_type==MV_TYPE_16X16){

938 
if(s>dquant) cbpc+= 8; 
939 
put_bits(&s>pb, 
940 
inter_MCBPC_bits[cbpc], 
941 
inter_MCBPC_code[cbpc]); 
942  
943 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
944 
if(s>dquant)

945 
put_bits(pb2, 2, dquant_code[s>dquant+2]); 
946  
947 
if(!s>progressive_sequence){

948 
if(cbp)

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

950 
put_bits(pb2, 1, 0); 
951 
} 
952 

953 
if(interleaved_stats){

954 
s>misc_bits+= get_bits_diff(s); 
955 
} 
956  
957 
/* motion vectors: 16x16 mode */

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

959 

960 
h263_encode_motion(s, motion_x  pred_x, s>f_code); 
961 
h263_encode_motion(s, motion_y  pred_y, s>f_code); 
962 
}else if(s>mv_type==MV_TYPE_FIELD){ 
963 
if(s>dquant) cbpc+= 8; 
964 
put_bits(&s>pb, 
965 
inter_MCBPC_bits[cbpc], 
966 
inter_MCBPC_code[cbpc]); 
967  
968 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
969 
if(s>dquant)

970 
put_bits(pb2, 2, dquant_code[s>dquant+2]); 
971  
972 
assert(!s>progressive_sequence); 
973 
if(cbp)

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

975 
put_bits(pb2, 1, 1); 
976 

977 
if(interleaved_stats){

978 
s>misc_bits+= get_bits_diff(s); 
979 
} 
980  
981 
/* motion vectors: 16x8 interlaced mode */

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

983 
pred_y /=2;

984 

985 
put_bits(&s>pb, 1, s>field_select[0][0]); 
986 
put_bits(&s>pb, 1, s>field_select[0][1]); 
987 

988 
h263_encode_motion(s, s>mv[0][0][0]  pred_x, s>f_code); 
989 
h263_encode_motion(s, s>mv[0][0][1]  pred_y, s>f_code); 
990 
h263_encode_motion(s, s>mv[0][1][0]  pred_x, s>f_code); 
991 
h263_encode_motion(s, s>mv[0][1][1]  pred_y, s>f_code); 
992 
}else{

993 
assert(s>mv_type==MV_TYPE_8X8); 
994 
put_bits(&s>pb, 
995 
inter_MCBPC_bits[cbpc+16],

996 
inter_MCBPC_code[cbpc+16]);

997 
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
998  
999 
if(!s>progressive_sequence){

1000 
if(cbp)

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

1002 
} 
1003 

1004 
if(interleaved_stats){

1005 
s>misc_bits+= get_bits_diff(s); 
1006 
} 
1007  
1008 
for(i=0; i<4; i++){ 
1009 
/* motion vectors: 8x8 mode*/

1010 
h263_pred_motion(s, i, &pred_x, &pred_y); 
1011  
1012 
h263_encode_motion(s, s>current_picture.motion_val[0][ s>block_index[i] ][0]  pred_x, s>f_code); 
1013 
h263_encode_motion(s, s>current_picture.motion_val[0][ s>block_index[i] ][1]  pred_y, s>f_code); 
1014 
} 
1015 
} 
1016  
1017 
if(interleaved_stats){

1018 
s>mv_bits+= get_bits_diff(s); 
1019 
} 
1020  
1021 
/* encode each block */

1022 
for (i = 0; i < 6; i++) { 
1023 
mpeg4_encode_block(s, block[i], i, 0, s>intra_scantable.permutated, NULL, tex_pb); 
1024 
} 
1025  
1026 
if(interleaved_stats){

1027 
s>p_tex_bits+= get_bits_diff(s); 
1028 
} 
1029 
s>f_count++; 
1030 
} 
1031 
} else {

1032 
int cbp;

1033 
int dc_diff[6]; //dc values with the dc prediction subtracted 
1034 
int dir[6]; //prediction direction 
1035 
int zigzag_last_index[6]; 
1036 
uint8_t *scan_table[6];

1037 
int i;

1038  
1039 
for(i=0; i<6; i++){ 
1040 
const int level= block[i][0]; 
1041 
uint16_t *dc_ptr; 
1042  
1043 
dc_diff[i]= level  ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); 
1044 
if (i < 4) { 
1045 
*dc_ptr = level * s>y_dc_scale; 
1046 
} else {

1047 
*dc_ptr = level * s>c_dc_scale; 
1048 
} 
1049 
} 
1050  
1051 
if(s>flags & CODEC_FLAG_AC_PRED){

1052 
s>ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); 
1053 
if(!s>ac_pred)

1054 
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 
1055 
}else{

1056 
for(i=0; i<6; i++) 
1057 
scan_table[i]= s>intra_scantable.permutated; 
1058 
} 
1059  
1060 
/* compute cbp */

1061 
cbp = 0;

1062 
for (i = 0; i < 6; i++) { 
1063 
if (s>block_last_index[i] >= 1) 
1064 
cbp = 1 << (5  i); 
1065 
} 
1066  
1067 
cbpc = cbp & 3;

1068 
if (s>pict_type == I_TYPE) {

1069 
if(s>dquant) cbpc+=4; 
1070 
put_bits(&s>pb, 
1071 
intra_MCBPC_bits[cbpc], 
1072 
intra_MCBPC_code[cbpc]); 
1073 
} else {

1074 
if(s>dquant) cbpc+=8; 
1075 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1076 
put_bits(&s>pb, 
1077 
inter_MCBPC_bits[cbpc + 4],

1078 
inter_MCBPC_code[cbpc + 4]);

1079 
} 
1080 
put_bits(pb2, 1, s>ac_pred);

1081 
cbpy = cbp >> 2;

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

1084 
put_bits(dc_pb, 2, dquant_code[s>dquant+2]); 
1085  
1086 
if(!s>progressive_sequence){

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

1088 
} 
1089  
1090 
if(interleaved_stats){

1091 
s>misc_bits+= get_bits_diff(s); 
1092 
} 
1093  
1094 
/* encode each block */

1095 
for (i = 0; i < 6; i++) { 
1096 
mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); 
1097 
} 
1098  
1099 
if(interleaved_stats){

1100 
s>i_tex_bits+= get_bits_diff(s); 
1101 
} 
1102 
s>i_count++; 
1103  
1104 
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */

1105 
if(s>ac_pred)

1106 
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 
1107 
} 
1108 
} 
1109  
1110 
void h263_encode_mb(MpegEncContext * s,

1111 
DCTELEM block[6][64], 
1112 
int motion_x, int motion_y) 
1113 
{ 
1114 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

1115 
int16_t pred_dc; 
1116 
int16_t rec_intradc[6];

1117 
uint16_t *dc_ptr[6];

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

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

1122 
if (!s>mb_intra) {

1123 
/* compute cbp */

1124 
cbp= get_p_cbp(s, block, motion_x, motion_y); 
1125  
1126 
if ((cbp  motion_x  motion_y  s>dquant  (s>mv_type  MV_TYPE_16X16)) == 0) { 
1127 
/* skip macroblock */

1128 
put_bits(&s>pb, 1, 1); 
1129 
if(interleaved_stats){

1130 
s>misc_bits++; 
1131 
s>last_bits++; 
1132 
} 
1133 
s>skip_count++; 
1134  
1135 
return;

1136 
} 
1137 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1138 

1139 
cbpc = cbp & 3;

1140 
cbpy = cbp >> 2;

1141 
if(s>alt_inter_vlc==0  cbpc!=3) 
1142 
cbpy ^= 0xF;

1143 
if(s>dquant) cbpc+= 8; 
1144 
if(s>mv_type==MV_TYPE_16X16){

1145 
put_bits(&s>pb, 
1146 
inter_MCBPC_bits[cbpc], 
1147 
inter_MCBPC_code[cbpc]); 
1148  
1149 
put_bits(&s>pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 
1150 
if(s>dquant)

1151 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1152 

1153 
if(interleaved_stats){

1154 
s>misc_bits+= get_bits_diff(s); 
1155 
} 
1156  
1157 
/* motion vectors: 16x16 mode */

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

1159 

1160 
if (!s>umvplus) {

1161 
h263_encode_motion(s, motion_x  pred_x, 1);

1162 
h263_encode_motion(s, motion_y  pred_y, 1);

1163 
} 
1164 
else {

1165 
h263p_encode_umotion(s, motion_x  pred_x); 
1166 
h263p_encode_umotion(s, motion_y  pred_y); 
1167 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
1168 
/* To prevent Start Code emulation */

1169 
put_bits(&s>pb,1,1); 
1170 
} 
1171 
}else{

1172 
put_bits(&s>pb, 
1173 
inter_MCBPC_bits[cbpc+16],

1174 
inter_MCBPC_code[cbpc+16]);

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

1177 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1178  
1179 
if(interleaved_stats){

1180 
s>misc_bits+= get_bits_diff(s); 
1181 
} 
1182  
1183 
for(i=0; i<4; i++){ 
1184 
/* motion vectors: 8x8 mode*/

1185 
h263_pred_motion(s, i, &pred_x, &pred_y); 
1186  
1187 
motion_x= s>current_picture.motion_val[0][ s>block_index[i] ][0]; 
1188 
motion_y= s>current_picture.motion_val[0][ s>block_index[i] ][1]; 
1189 
if (!s>umvplus) {

1190 
h263_encode_motion(s, motion_x  pred_x, 1);

1191 
h263_encode_motion(s, motion_y  pred_y, 1);

1192 
} 
1193 
else {

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

1198 
put_bits(&s>pb,1,1); 
1199 
} 
1200 
} 
1201 
} 
1202  
1203 
if(interleaved_stats){

1204 
s>mv_bits+= get_bits_diff(s); 
1205 
} 
1206 
} else {

1207 
assert(s>mb_intra); 
1208 

1209 
cbp = 0;

1210 
if (s>h263_aic) {

1211 
/* Predict DC */

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

1214 
int scale;

1215 

1216 
if(i<4) scale= s>y_dc_scale; 
1217 
else scale= s>c_dc_scale;

1218  
1219 
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); 
1220 
level = pred_dc; 
1221 
/* Quant */

1222 
if (level >= 0) 
1223 
level = (level + (scale>>1))/scale;

1224 
else

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

1226 

1227 
/* AIC can change CBP */

1228 
if (level == 0 && s>block_last_index[i] == 0) 
1229 
s>block_last_index[i] = 1;

1230  
1231 
if(!s>modified_quant){

1232 
if (level < 127) 
1233 
level = 127;

1234 
else if (level > 127) 
1235 
level = 127;

1236 
} 
1237  
1238 
block[i][0] = level;

1239 
/* Reconstruction */

1240 
rec_intradc[i] = scale*level + pred_dc; 
1241 
/* Oddify */

1242 
rec_intradc[i] = 1;

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

1244 
// rec_intradc[i]++;

1245 
/* Clipping */

1246 
if (rec_intradc[i] < 0) 
1247 
rec_intradc[i] = 0;

1248 
else if (rec_intradc[i] > 2047) 
1249 
rec_intradc[i] = 2047;

1250 

1251 
/* Update AC/DC tables */

1252 
*dc_ptr[i] = rec_intradc[i]; 
1253 
if (s>block_last_index[i] >= 0) 
1254 
cbp = 1 << (5  i); 
1255 
} 
1256 
}else{

1257 
for(i=0; i<6; i++) { 
1258 
/* compute cbp */

1259 
if (s>block_last_index[i] >= 1) 
1260 
cbp = 1 << (5  i); 
1261 
} 
1262 
} 
1263  
1264 
cbpc = cbp & 3;

1265 
if (s>pict_type == I_TYPE) {

1266 
if(s>dquant) cbpc+=4; 
1267 
put_bits(&s>pb, 
1268 
intra_MCBPC_bits[cbpc], 
1269 
intra_MCBPC_code[cbpc]); 
1270 
} else {

1271 
if(s>dquant) cbpc+=8; 
1272 
put_bits(&s>pb, 1, 0); /* mb coded */ 
1273 
put_bits(&s>pb, 
1274 
inter_MCBPC_bits[cbpc + 4],

1275 
inter_MCBPC_code[cbpc + 4]);

1276 
} 
1277 
if (s>h263_aic) {

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

1279 
put_bits(&s>pb, 1, 0); /* no AC prediction */ 
1280 
} 
1281 
cbpy = cbp >> 2;

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

1284 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
1285  
1286 
if(interleaved_stats){

1287 
s>misc_bits+= get_bits_diff(s); 
1288 
} 
1289 
} 
1290  
1291 
for(i=0; i<6; i++) { 
1292 
/* encode each block */

1293 
h263_encode_block(s, block[i], i); 
1294 

1295 
/* Update INTRADC for decoding */

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

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

1298 

1299 
} 
1300 
} 
1301  
1302 
if(interleaved_stats){

1303 
if (!s>mb_intra) {

1304 
s>p_tex_bits+= get_bits_diff(s); 
1305 
s>f_count++; 
1306 
}else{

1307 
s>i_tex_bits+= get_bits_diff(s); 
1308 
s>i_count++; 
1309 
} 
1310 
} 
1311 
} 
1312 
#endif

1313  
1314 
void ff_h263_loop_filter(MpegEncContext * s){

1315 
int qp_c;

1316 
const int linesize = s>linesize; 
1317 
const int uvlinesize= s>uvlinesize; 
1318 
const int xy = s>mb_y * s>mb_stride + s>mb_x; 
1319 
uint8_t *dest_y = s>dest[0];

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

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

1322 

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

1324  
1325 
/*

1326 
Diag Top

1327 
Left Center

1328 
*/

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

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

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

1334 
qp_c= 0;

1335  
1336 
if(s>mb_y){

1337 
int qp_dt, qp_t, qp_tc;

1338  
1339 
if(IS_SKIP(s>current_picture.mb_type[xys>mb_stride]))

1340 
qp_t=0;

1341 
else

1342 
qp_t= s>current_picture.qscale_table[xys>mb_stride]; 
1343  
1344 
if(qp_c)

1345 
qp_tc= qp_c; 
1346 
else

1347 
qp_tc= qp_t; 
1348 

1349 
if(qp_tc){

1350 
const int chroma_qp= s>chroma_qscale_table[qp_tc]; 
1351 
s>dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); 
1352 
s>dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);

1353 

1354 
s>dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); 
1355 
s>dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); 
1356 
} 
1357 

1358 
if(qp_t)

1359 
s>dsp.h263_h_loop_filter(dest_y8*linesize+8 , linesize, qp_t); 
1360 

1361 
if(s>mb_x){

1362 
if(qp_t  IS_SKIP(s>current_picture.mb_type[xy1s>mb_stride])) 
1363 
qp_dt= qp_t; 
1364 
else

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

1366 

1367 
if(qp_dt){

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

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

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

1372 
} 
1373 
} 
1374 
} 
1375  
1376 
if(qp_c){

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

1378 
if(s>mb_y + 1 == s>mb_height) 
1379 
s>dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); 
1380 
} 
1381 

1382 
if(s>mb_x){

1383 
int qp_lc;

1384 
if(qp_c  IS_SKIP(s>current_picture.mb_type[xy1])) 
1385 
qp_lc= qp_c; 
1386 
else

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

1388 

1389 
if(qp_lc){

1390 
s>dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); 
1391 
if(s>mb_y + 1 == s>mb_height){ 
1392 
const int chroma_qp= s>chroma_qscale_table[qp_lc]; 
1393 
s>dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);

1394 
s>dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); 
1395 
s>dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); 
1396 
} 
1397 
} 
1398 
} 
1399 
} 
1400  
1401 
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr) 
1402 
{ 
1403 
int x, y, wrap, a, c, pred_dc, scale;

1404 
int16_t *dc_val, *ac_val; 
1405  
1406 
/* find prediction */

1407 
if (n < 4) { 
1408 
x = 2 * s>mb_x + 1 + (n & 1); 
1409 
y = 2 * s>mb_y + 1 + ((n & 2) >> 1); 
1410 
wrap = s>mb_width * 2 + 2; 
1411 
dc_val = s>dc_val[0];

1412 
ac_val = s>ac_val[0][0]; 
1413 
scale = s>y_dc_scale; 
1414 
} else {

1415 
x = s>mb_x + 1;

1416 
y = s>mb_y + 1;

1417 
wrap = s>mb_width + 2;

1418 
dc_val = s>dc_val[n  4 + 1]; 
1419 
ac_val = s>ac_val[n  4 + 1][0]; 
1420 
scale = s>c_dc_scale; 
1421 
} 
1422 
/* B C

1423 
* A X

1424 
*/

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

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

1427 

1428 
/* No prediction outside GOB boundary */

1429 
if (s>first_slice_line && ((n < 2)  (n > 3))) 
1430 
c = 1024;

1431 
pred_dc = 1024;

1432 
/* just DC prediction */

1433 
if (a != 1024 && c != 1024) 
1434 
pred_dc = (a + c) >> 1;

1435 
else if (a != 1024) 
1436 
pred_dc = a; 
1437 
else

1438 
pred_dc = c; 
1439 

1440 
/* we assume pred is positive */

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

1442 
*dc_val_ptr = &dc_val[x + y * wrap]; 
1443 
return pred_dc;

1444 
} 
1445  
1446 
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) 
1447 
{ 
1448 
int x, y, wrap, a, c, pred_dc, scale, i;

1449 
int16_t *dc_val, *ac_val, *ac_val1; 
1450  
1451 
/* find prediction */

1452 
if (n < 4) { 
1453 
x = 2 * s>mb_x + 1 + (n & 1); 
1454 
y = 2 * s>mb_y + 1 + (n>> 1); 
1455 
wrap = s>mb_width * 2 + 2; 
1456 
dc_val = s>dc_val[0];

1457 
ac_val = s>ac_val[0][0]; 
1458 
scale = s>y_dc_scale; 
1459 
} else {

1460 
x = s>mb_x + 1;

1461 
y = s>mb_y + 1;

1462 
wrap = s>mb_width + 2;

1463 
dc_val = s>dc_val[n  4 + 1]; 
1464 
ac_val = s>ac_val[n  4 + 1][0]; 
1465 
scale = s>c_dc_scale; 
1466 
} 
1467 

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

1469 
ac_val1 = ac_val; 
1470 

1471 
/* B C

1472 
* A X

1473 
*/

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

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

1476 

1477 
/* No prediction outside GOB boundary */

1478 
if(s>first_slice_line && n!=3){ 
1479 
if(n!=2) c= 1024; 
1480 
if(n!=1 && s>mb_x == s>resync_mb_x) a= 1024; 
1481 
} 
1482 

1483 
if (s>ac_pred) {

1484 
pred_dc = 1024;

1485 
if (s>h263_aic_dir) {

1486 
/* left prediction */

1487 
if (a != 1024) { 
1488 
ac_val = 16;

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

1491 
} 
1492 
pred_dc = a; 
1493 
} 
1494 
} else {

1495 
/* top prediction */

1496 
if (c != 1024) { 
1497 
ac_val = 16 * wrap;

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

1500 
} 
1501 
pred_dc = c; 
1502 
} 
1503 
} 
1504 
} else {

1505 
/* just DC prediction */

1506 
if (a != 1024 && c != 1024) 
1507 
pred_dc = (a + c) >> 1;

1508 
else if (a != 1024) 
1509 
pred_dc = a; 
1510 
else

1511 
pred_dc = c; 
1512 
} 
1513 

1514 
/* we assume pred is positive */

1515 
block[0]=block[0]*scale + pred_dc; 
1516 

1517 
if (block[0] < 0) 
1518 
block[0] = 0; 
1519 
else

1520 
block[0] = 1; 
1521 

1522 
/* Update AC/DC tables */

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

1524 

1525 
/* left copy */

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

1528 
/* top copy */

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

1531 
} 
1532  
1533 
int16_t *h263_pred_motion(MpegEncContext * s, int block,

1534 
int *px, int *py) 
1535 
{ 
1536 
int xy, wrap;

1537 
int16_t *A, *B, *C, *mot_val; 
1538 
static const int off[4]= {2, 1, 1, 1}; 
1539  
1540 
wrap = s>block_wrap[0];

1541 
xy = s>block_index[block]; 
1542  
1543 
mot_val = s>current_picture.motion_val[0][xy];

1544  
1545 
A = s>current_picture.motion_val[0][xy  1]; 
1546 
/* special case for first (slice) line */

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

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

1550 
if(block==0){ //most common case 
1551 
if(s>mb_x == s>resync_mb_x){ //rare 
1552 
*px= *py = 0;

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

1555 
if(s>mb_x==0){ 
1556 
*px = C[0];

1557 
*py = C[1];

1558 
}else{

1559 
*px = mid_pred(A[0], 0, C[0]); 
1560 
*py = mid_pred(A[1], 0, C[1]); 
1561 
} 
1562 
}else{

1563 
*px = A[0];

1564 
*py = A[1];

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

1569 
*px = mid_pred(A[0], 0, C[0]); 
1570 
*py = mid_pred(A[1], 0, C[1]); 
1571 
}else{

1572 
*px = A[0];

1573 
*py = A[1];

1574 
} 
1575 
}else{ /* block==2*/ 
1576 
B = s>current_picture.motion_val[0][xy  wrap];

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

1578 
if(s>mb_x == s>resync_mb_x) //rare 
1579 
A[0]=A[1]=0; 
1580 

1581 
*px = mid_pred(A[0], B[0], C[0]); 
1582 
*py = mid_pred(A[1], B[1], C[1]); 
1583 
} 
1584 
} else {

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

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

1587 
*px = mid_pred(A[0], B[0], C[0]); 
1588 
*py = mid_pred(A[1], B[1], C[1]); 
1589 
} 
1590 
return mot_val;

1591 
} 
1592  
1593 
// identical to above but with s>current_picture>motion_val, the above one will be removed, and this renamed to it

1594 
int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir, 
1595 
int *px, int *py) 
1596 
{ 
1597 
int xy, wrap;

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

1599 
static const int off[4]= {2, 1, 1, 1}; 
1600  
1601 
wrap = s>b8_stride; 
1602 
xy = 2*(s>mb_x + s>mb_y * wrap);

1603  
1604 
mot_val = s>current_picture.motion_val[dir] + xy; 
1605  
1606 
A = mot_val[  1];

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

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

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

1611 
if(block==0){ //most common case 
1612 
if(s>mb_x == s>resync_mb_x){ //rare 
1613 
*px= *py = 0;

1614 
}else if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1615 
C = mot_val[off[block]  wrap]; 
1616 
if(s>mb_x==0){ 
1617 
*px = C[0];

1618 
*py = C[1];

1619 
}else{

1620 
*px = mid_pred(A[0], 0, C[0]); 
1621 
*py = mid_pred(A[1], 0, C[1]); 
1622 
} 
1623 
}else{

1624 
*px = A[0];

1625 
*py = A[1];

1626 
} 
1627 
}else if(block==1){ 
1628 
if(s>mb_x + 1 == s>resync_mb_x && s>h263_pred){ //rare 
1629 
C = mot_val[off[block]  wrap]; 
1630 
*px = mid_pred(A[0], 0, C[0]); 
1631 
*py = mid_pred(A[1], 0, C[1]); 
1632 
}else{

1633 
*px = A[0];

1634 
*py = A[1];

1635 
} 
1636 
}else{ /* block==2*/ 
1637 
B = mot_val[  wrap]; 
1638 
C = mot_val[off[block]  wrap]; 
1639 
if(s>mb_x == s>resync_mb_x) //rare 
1640 
A[0]=A[1]=0; 
1641 

1642 
*px = mid_pred(A[0], B[0], C[0]); 
1643 
*py = mid_pred(A[1], B[1], C[1]); 
1644 
} 
1645 
} else {

1646 
B = mot_val[  wrap]; 
1647 
C = mot_val[off[block]  wrap]; 
1648 
*px = mid_pred(A[0], B[0], C[0]); 
1649 
*py = mid_pred(A[1], B[1], C[1]); 
1650 
} 
1651 
return *mot_val;

1652 
} 
1653  
1654 
#ifdef CONFIG_ENCODERS

1655 
static void h263_encode_motion(MpegEncContext * s, int val, int f_code) 
1656 
{ 
1657 
int range, l, bit_size, sign, code, bits;

1658  
1659 
if (val == 0) { 
1660 
/* zero vector */

1661 
code = 0;

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

1664 
bit_size = f_code  1;

1665 
range = 1 << bit_size;

1666 
/* modulo encoding */

1667 
l = range * 32;

1668 
#if 1 
1669 
val+= l; 
1670 
val&= 2*l1; 
1671 
val= l; 
1672 
sign = val>>31;

1673 
val= (val^sign)sign; 
1674 
sign&=1;

1675 
#else

1676 
if (val < l) {

1677 
val += 2*l;

1678 
} else if (val >= l) { 
1679 
val = 2*l;

1680 
} 
1681  
1682 
assert(val>=l && val<l); 
1683  
1684 
if (val >= 0) { 
1685 
sign = 0;

1686 
} else {

1687 
val = val; 
1688 
sign = 1;

1689 
} 
1690 
#endif

1691 
val; 
1692 
code = (val >> bit_size) + 1;

1693 
bits = val & (range  1);

1694  
1695 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
1696 
if (bit_size > 0) { 
1697 
put_bits(&s>pb, bit_size, bits); 
1698 
} 
1699 
} 
1700  
1701 
} 
1702  
1703 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

1704 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
1705 
{ 
1706 
short sval = 0; 
1707 
short i = 0; 
1708 
short n_bits = 0; 
1709 
short temp_val;

1710 
int code = 0; 
1711 
int tcode;

1712 

1713 
if ( val == 0) 
1714 
put_bits(&s>pb, 1, 1); 
1715 
else if (val == 1) 
1716 
put_bits(&s>pb, 3, 0); 
1717 
else if (val == 1) 
1718 
put_bits(&s>pb, 3, 2); 
1719 
else {

1720 

1721 
sval = ((val < 0) ? (short)(val):(short)val); 
1722 
temp_val = sval; 
1723 

1724 
while (temp_val != 0) { 
1725 
temp_val = temp_val >> 1;

1726 
n_bits++; 
1727 
} 
1728 

1729 
i = n_bits  1;

1730 
while (i > 0) { 
1731 
tcode = (sval & (1 << (i1))) >> (i1); 
1732 
tcode = (tcode << 1)  1; 
1733 
code = (code << 2)  tcode;

1734 
i; 
1735 
} 
1736 
code = ((code << 1)  (val < 0)) << 1; 
1737 
put_bits(&s>pb, (2*n_bits)+1, code); 
1738 
//printf("\nVal = %d\tCode = %d", sval, code);

1739 
} 
1740 
} 
1741  
1742 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
1743 
{ 
1744 
int f_code;

1745 
int mv;

1746 

1747 
if(mv_penalty==NULL) 
1748 
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); 
1749 

1750 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
1751 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

1752 
int len;

1753  
1754 
if(mv==0) len= mvtab[0][1]; 
1755 
else{

1756 
int val, bit_size, range, code;

1757  
1758 
bit_size = s>f_code  1;

1759 
range = 1 << bit_size;

1760  
1761 
val=mv; 
1762 
if (val < 0) 
1763 
val = val; 
1764 
val; 
1765 
code = (val >> bit_size) + 1;

1766 
if(code<33){ 
1767 
len= mvtab[code][1] + 1 + bit_size; 
1768 
}else{

1769 
len= mvtab[32][1] + 2 + bit_size; 
1770 
} 
1771 
} 
1772  
1773 
mv_penalty[f_code][mv+MAX_MV]= len; 
1774 
} 
1775 
} 
1776  
1777 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
1778 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
1779 
fcode_tab[mv+MAX_MV]= f_code; 
1780 
} 
1781 
} 
1782  
1783 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
1784 
umv_fcode_tab[mv]= 1;

1785 
} 
1786 
} 
1787 
#endif

1788  
1789 
#ifdef CONFIG_ENCODERS

1790  
1791 
static void init_uni_dc_tab(void) 
1792 
{ 
1793 
int level, uni_code, uni_len;

1794  
1795 
for(level=256; level<256; level++){ 
1796 
int size, v, l;

1797 
/* find number of bits */

1798 
size = 0;

1799 
v = abs(level); 
1800 
while (v) {

1801 
v >>= 1;

1802 
size++; 
1803 
} 
1804  
1805 
if (level < 0) 
1806 
l= (level) ^ ((1 << size)  1); 
1807 
else

1808 
l= level; 
1809  
1810 
/* luminance */

1811 
uni_code= DCtab_lum[size][0];

1812 
uni_len = DCtab_lum[size][1];

1813  
1814 
if (size > 0) { 
1815 
uni_code<<=size; uni_code=l; 
1816 
uni_len+=size; 
1817 
if (size > 8){ 
1818 
uni_code<<=1; uni_code=1; 
1819 
uni_len++; 
1820 
} 
1821 
} 
1822 
uni_DCtab_lum_bits[level+256]= uni_code;

1823 
uni_DCtab_lum_len [level+256]= uni_len;

1824  
1825 
/* chrominance */

1826 
uni_code= DCtab_chrom[size][0];

1827 
uni_len = DCtab_chrom[size][1];

1828 

1829 
if (size > 0) { 
1830 
uni_code<<=size; uni_code=l; 
1831 
uni_len+=size; 
1832 
if (size > 8){ 
1833 
uni_code<<=1; uni_code=1; 
1834 
uni_len++; 
1835 
} 
1836 
} 
1837 
uni_DCtab_chrom_bits[level+256]= uni_code;

1838 
uni_DCtab_chrom_len [level+256]= uni_len;

1839  
1840 
} 
1841 
} 
1842  
1843 
#endif //CONFIG_ENCODERS 
1844  
1845 
#ifdef CONFIG_ENCODERS

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

1848 

1849 
assert(MAX_LEVEL >= 64);

1850 
assert(MAX_RUN >= 63);

1851  
1852 
for(slevel=64; slevel<64; slevel++){ 
1853 
if(slevel==0) continue; 
1854 
for(run=0; run<64; run++){ 
1855 
for(last=0; last<=1; last++){ 
1856 
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); 
1857 
int level= slevel < 0 ? slevel : slevel; 
1858 
int sign= slevel < 0 ? 1 : 0; 
1859 
int bits, len, code;

1860 
int level1, run1;

1861 

1862 
len_tab[index]= 100;

1863 

1864 
/* ESC0 */

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

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

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

1869 

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

1871 
bits_tab[index]= bits; 
1872 
len_tab [index]= len; 
1873 
} 
1874 
#if 1 
1875 
/* ESC1 */

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

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

1878 
bits=bits*2; len++; //esc1 
1879 
level1= level  rl>max_level[last][run]; 
1880 
if(level1>0){ 
1881 
code= get_rl_index(rl, last, run, level1); 
1882 
bits<<= rl>table_vlc[code][1];

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

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

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

1886 

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

1888 
bits_tab[index]= bits; 
1889 
len_tab [index]= len; 
1890 
} 
1891 
} 
1892 
#endif

1893 
#if 1 
1894 
/* ESC2 */

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

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

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

1899 
if(run1>=0){ 
1900 
code= get_rl_index(rl, last, run1, level); 
1901 
bits<<= rl>table_vlc[code][1];

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

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

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

1905 

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

1907 
bits_tab[index]= bits; 
1908 
len_tab [index]= len; 
1909 
} 
1910 
} 
1911 
#endif

1912 
/* ESC3 */

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

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

1915 
bits=bits*4+3; len+=2; //esc3 
1916 
bits=bits*2+last; len++;

1917 
bits=bits*64+run; len+=6; 
1918 
bits=bits*2+1; len++; //marker 
1919 
bits=bits*4096+(slevel&0xfff); len+=12; 
1920 
bits=bits*2+1; len++; //marker 
1921 

1922 
if(len < len_tab[index]){

1923 
bits_tab[index]= bits; 
1924 
len_tab [index]= len; 
1925 
} 
1926 
} 
1927 
} 
1928 
} 
1929 
} 
1930  
1931 
void h263_encode_init(MpegEncContext *s)

1932 
{ 
1933 
static int done = 0; 
1934  
1935 
if (!done) {

1936 
done = 1;

1937  
1938 
init_uni_dc_tab(); 
1939  
1940 
init_rl(&rl_inter); 
1941 
init_rl(&rl_intra); 
1942 
init_rl(&rl_intra_aic); 
1943 

1944 
init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); 
1945 
init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); 
1946  
1947 
init_mv_penalty_and_fcode(s); 
1948 
} 
1949 
s>me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

1950 

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

1952 
switch(s>codec_id){

1953 
case CODEC_ID_MPEG4:

1954 
s>fcode_tab= fcode_tab; 
1955 
s>min_qcoeff= 2048;

1956 
s>max_qcoeff= 2047;

1957 
s>intra_ac_vlc_length = uni_mpeg4_intra_rl_len; 
1958 
s>intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; 
1959 
s>inter_ac_vlc_length = uni_mpeg4_inter_rl_len; 
1960 
s>inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; 
1961 
s>luma_dc_vlc_length= uni_DCtab_lum_len; 
1962 
s>chroma_dc_vlc_length= uni_DCtab_chrom_len; 
1963 
s>ac_esc_length= 7+2+1+6+1+12+1; 
1964 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 
1965 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
1966  
1967 
if(s>flags & CODEC_FLAG_GLOBAL_HEADER){

1968  
1969 
s>avctx>extradata= av_malloc(1024);

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

1971 

1972 
mpeg4_encode_visual_object_header(s); 
1973 
mpeg4_encode_vol_header(s, 0, 0); 
1974  
1975 
// ff_mpeg4_stuffing(&s>pb); ?

1976 
flush_put_bits(&s>pb); 
1977 
s>avctx>extradata_size= (put_bits_count(&s>pb)+7)>>3; 
1978 
} 
1979 

1980 
break;

1981 
case CODEC_ID_H263P:

1982 
if(s>umvplus)

1983 
s>fcode_tab= umv_fcode_tab; 
1984 
if(s>modified_quant){

1985 
s>min_qcoeff= 2047;

1986 
s>max_qcoeff= 2047;

1987 
}else{

1988 
s>min_qcoeff= 127;

1989 
s>max_qcoeff= 127;

1990 
} 
1991 
break;

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

1993 
case CODEC_ID_FLV1:

1994 
if (s>h263_flv > 1) { 
1995 
s>min_qcoeff= 1023;

1996 
s>max_qcoeff= 1023;

1997 
} else {

1998 
s>min_qcoeff= 127;

1999 
s>max_qcoeff= 127;

2000 
} 
2001 
s>y_dc_scale_table= 
2002 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
2003 
break;

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

2006 
s>max_qcoeff= 127;

2007 
s>y_dc_scale_table= 
2008 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
2009 
} 
2010 
} 
2011  
2012 
/**

2013 
* encodes a 8x8 block.

2014 
* @param block the 8x8 block

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

2016 
*/

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

2020 
RLTable *rl; 
2021  
2022 
rl = &rl_inter; 
2023 
if (s>mb_intra && !s>h263_aic) {

2024 
/* DC coef */

2025 
level = block[0];

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

2027 
if (level > 254) { 
2028 
level = 254;

2029 
block[0] = 254; 
2030 
} 
2031 
/* 0 cannot be represented also */

2032 
else if (level < 1) { 
2033 
level = 1;

2034 
block[0] = 1; 
2035 
} 
2036 
if (level == 128) //FIXME check rv10 
2037 
put_bits(&s>pb, 8, 0xff); 
2038 
else

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

2040 
i = 1;

2041 
} else {

2042 
i = 0;

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

2044 
rl = &rl_intra_aic; 
2045 

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

2047 
int aic_vlc_bits=0; 
2048 
int inter_vlc_bits=0; 
2049 
int wrong_pos=1; 
2050 
int aic_code;

2051 

2052 
last_index = s>block_last_index[n]; 
2053 
last_non_zero = i  1;

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

2055 
j = s>intra_scantable.permutated[i]; 
2056 
level = block[j]; 
2057 
if (level) {

2058 
run = i  last_non_zero  1;

2059 
last = (i == last_index); 
2060 

2061 
if(level<0) level= level; 
2062 

2063 
code = get_rl_index(rl, last, run, level); 
2064 
aic_code = get_rl_index(&rl_intra_aic, last, run, level); 
2065 
inter_vlc_bits += rl>table_vlc[code][1]+1; 
2066 
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; 
2067  
2068 
if (code == rl>n) {

2069 
inter_vlc_bits += 1+6+81; 
2070 
} 
2071 
if (aic_code == rl_intra_aic.n) {

2072 
aic_vlc_bits += 1+6+81; 
2073 
wrong_pos += run + 1;

2074 
}else

2075 
wrong_pos += wrong_run[aic_code]; 
2076 
last_non_zero = i; 
2077 
} 
2078 
} 
2079 
i = 0;

2080 
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) 
2081 
rl = &rl_intra_aic; 
2082 
} 
2083 
} 
2084 

2085 
/* AC coefs */

2086 
last_index = s>block_last_index[n]; 
2087 
last_non_zero = i  1;

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

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

2092 
run = i  last_non_zero  1;

2093 
last = (i == last_index); 
2094 
sign = 0;

2095 
slevel = level; 
2096 
if (level < 0) { 
2097 
sign = 1;

2098 
level = level; 
2099 
} 
2100 
code = get_rl_index(rl, last, run, level); 
2101 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2102 
if (code == rl>n) {

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

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

2106 

2107 
assert(slevel != 0);

2108  
2109 
if(level < 128) 
2110 
put_bits(&s>pb, 8, slevel & 0xff); 
2111 
else{

2112 
put_bits(&s>pb, 8, 128); 
2113 
put_bits(&s>pb, 5, slevel & 0x1f); 
2114 
put_bits(&s>pb, 6, (slevel>>5)&0x3f); 
2115 
} 
2116 
}else{

2117 
if(level < 64) { // 7bit level 
2118 
put_bits(&s>pb, 1, 0); 
2119 
put_bits(&s>pb, 1, last);

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

2121  
2122 
put_bits(&s>pb, 7, slevel & 0x7f); 
2123 
} else {

2124 
/* 11bit level */

2125 
put_bits(&s>pb, 1, 1); 
2126 
put_bits(&s>pb, 1, last);

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

2128  
2129 
put_bits(&s>pb, 11, slevel & 0x7ff); 
2130 
} 
2131 
} 
2132 
} else {

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

2134 
} 
2135 
last_non_zero = i; 
2136 
} 
2137 
} 
2138 
} 
2139 
#endif

2140  
2141 
#ifdef CONFIG_ENCODERS

2142  
2143 
/***************************************************/

2144 
/**

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

2146 
*/

2147 
void ff_mpeg4_stuffing(PutBitContext * pbc)

2148 
{ 
2149 
int length;

2150 
put_bits(pbc, 1, 0); 
2151 
length= (put_bits_count(pbc))&7;

2152 
if(length) put_bits(pbc, length, (1<<length)1); 
2153 
} 
2154  
2155 
/* must be called before writing the header */

2156 
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ 
2157 
int time_div, time_mod;

2158  
2159 
assert(s>current_picture_ptr>pts != AV_NOPTS_VALUE); 
2160 
s>time= (s>current_picture_ptr>pts*s>time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;

2161  
2162 
time_div= s>time/s>time_increment_resolution; 
2163 
time_mod= s>time%s>time_increment_resolution; 
2164  
2165 
if(s>pict_type==B_TYPE){

2166 
s>pb_time= s>pp_time  (s>last_non_b_time  s>time); 
2167 
}else{

2168 
s>last_time_base= s>time_base; 
2169 
s>time_base= time_div; 
2170 
s>pp_time= s>time  s>last_non_b_time; 
2171 
s>last_non_b_time= s>time; 
2172 
} 
2173 
} 
2174  
2175 
static void mpeg4_encode_gop_header(MpegEncContext * s){ 
2176 
int hours, minutes, seconds;

2177 
int64_t time; 
2178 

2179 
put_bits(&s>pb, 16, 0); 
2180 
put_bits(&s>pb, 16, GOP_STARTCODE);

2181 

2182 
time= s>current_picture_ptr>pts; 
2183 
if(s>reordered_input_picture[1]) 
2184 
time= FFMIN(time, s>reordered_input_picture[1]>pts);

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

2186  
2187 
seconds= time/s>time_increment_resolution; 
2188 
minutes= seconds/60; seconds %= 60; 
2189 
hours= minutes/60; minutes %= 60; 
2190 
hours%=24;

2191  
2192 
put_bits(&s>pb, 5, hours);

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

2194 
put_bits(&s>pb, 1, 1); 
2195 
put_bits(&s>pb, 6, seconds);

2196 

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

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

2200 
s>last_time_base= time / s>time_increment_resolution; 
2201  
2202 
ff_mpeg4_stuffing(&s>pb); 
2203 
} 
2204  
2205 
static void mpeg4_encode_visual_object_header(MpegEncContext * s){ 
2206 
int profile_and_level_indication;

2207 
int vo_ver_id;

2208 

2209 
if(s>max_b_frames  s>quarter_sample){

2210 
profile_and_level_indication= 0xF1; // adv simple level 1 
2211 
vo_ver_id= 5;

2212 
}else{

2213 
profile_and_level_indication= 0x01; // simple level 1 
2214 
vo_ver_id= 1;

2215 
} 
2216 
//FIXME levels

2217  
2218 
put_bits(&s>pb, 16, 0); 
2219 
put_bits(&s>pb, 16, VOS_STARTCODE);

2220  
2221 
put_bits(&s>pb, 8, profile_and_level_indication);

2222  
2223 
put_bits(&s>pb, 16, 0); 
2224 
put_bits(&s>pb, 16, VISUAL_OBJ_STARTCODE);

2225 

2226 
put_bits(&s>pb, 1, 1); 
2227 
put_bits(&s>pb, 4, vo_ver_id);

2228 
put_bits(&s>pb, 3, 1); //priority 
2229 

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

2232 
put_bits(&s>pb, 1, 0); //video signal type == no clue //FIXME 
2233  
2234 
ff_mpeg4_stuffing(&s>pb); 
2235 
} 
2236  
2237 
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) 
2238 
{ 
2239 
int vo_ver_id;

2240  
2241 
if(s>max_b_frames  s>quarter_sample){

2242 
vo_ver_id= 5;

2243 
s>vo_type= ADV_SIMPLE_VO_TYPE; 
2244 
}else{

2245 
vo_ver_id= 1;

2246 
s>vo_type= SIMPLE_VO_TYPE; 
2247 
} 
2248  
2249 
put_bits(&s>pb, 16, 0); 
2250 
put_bits(&s>pb, 16, 0x100 + vo_number); /* video obj */ 
2251 
put_bits(&s>pb, 16, 0); 
2252 
put_bits(&s>pb, 16, 0x120 + vol_number); /* video obj layer */ 
2253  
2254 
put_bits(&s>pb, 1, 0); /* random access vol */ 
2255 
put_bits(&s>pb, 8, s>vo_type); /* video obj type indication */ 
2256 
put_bits(&s>pb, 1, 1); /* is obj layer id= yes */ 
2257 
put_bits(&s>pb, 4, vo_ver_id); /* is obj layer ver id */ 
2258 
put_bits(&s>pb, 3, 1); /* is obj layer priority */ 
2259 

2260 
aspect_to_info(s, s>avctx>sample_aspect_ratio); 
2261  
2262 
put_bits(&s>pb, 4, s>aspect_ratio_info);/* aspect ratio info */ 
2263 
if (s>aspect_ratio_info == FF_ASPECT_EXTENDED){

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

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

2266 
} 
2267  
2268 
if(s>low_delay){

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

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

2274 
put_bits(&s>pb, 1, 0); /* vol control parameters= no */ 
2275 
} 
2276  
2277 
put_bits(&s>pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 
2278 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2279 

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

2281 
if (s>time_increment_bits < 1) 
2282 
s>time_increment_bits = 1;

2283 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2284 
put_bits(&s>pb, 1, 0); /* fixed vop rate=no */ 
2285 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2286 
put_bits(&s>pb, 13, s>width); /* vol width */ 
2287 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2288 
put_bits(&s>pb, 13, s>height); /* vol height */ 
2289 
put_bits(&s>pb, 1, 1); /* marker bit */ 
2290 
put_bits(&s>pb, 1, s>progressive_sequence ? 0 : 1); 
2291 
put_bits(&s>pb, 1, 1); /* obmc disable */ 
2292 
if (vo_ver_id == 1) { 
2293 
put_bits(&s>pb, 1, s>vol_sprite_usage); /* sprite enable */ 
2294 
}else{

2295 
put_bits(&s>pb, 2, s>vol_sprite_usage); /* sprite enable */ 
2296 
} 
2297 

2298 
put_bits(&s>pb, 1, 0); /* not 8 bit == false */ 
2299 
put_bits(&s>pb, 1, s>mpeg_quant); /* quant type= (0=h263 style)*/ 
2300  
2301 
if(s>mpeg_quant){

2302 
ff_write_quant_matrix(&s>pb, s>avctx>intra_matrix); 
2303 
ff_write_quant_matrix(&s>pb, s>avctx>inter_matrix); 
2304 
} 
2305  
2306 
if (vo_ver_id != 1) 
2307 
put_bits(&s>pb, 1, s>quarter_sample);

2308 
put_bits(&s>pb, 1, 1); /* complexity estimation disable */ 
2309 
s>resync_marker= s>rtp_mode; 
2310 
put_bits(&s>pb, 1, s>resync_marker ? 0 : 1);/* resync marker disable */ 
2311 
put_bits(&s>pb, 1, s>data_partitioning ? 1 : 0); 
2312 
if(s>data_partitioning){

2313 
put_bits(&s>pb, 1, 0); /* no rvlc */ 
2314 
} 
2315  
2316 
if (vo_ver_id != 1){ 
2317 
put_bits(&s>pb, 1, 0); /* newpred */ 
2318 
put_bits(&s>pb, 1, 0); /* reduced res vop */ 
2319 
} 
2320 
put_bits(&s>pb, 1, 0); /* scalability */ 
2321 

2322 
ff_mpeg4_stuffing(&s>pb); 
2323  
2324 
/* user data */

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

2326 
put_bits(&s>pb, 16, 0); 
2327 
put_bits(&s>pb, 16, 0x1B2); /* user_data */ 
2328 
put_string(&s>pb, LIBAVCODEC_IDENT, 0);

2329 
} 
2330 
} 
2331  
2332 
/* write mpeg4 VOP header */

2333 
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
2334 
{ 
2335 
int time_incr;

2336 
int time_div, time_mod;

2337 

2338 
if(s>pict_type==I_TYPE){

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

2340 
if(s>strict_std_compliance < 2) //HACK, the reference sw is buggy 
2341 
mpeg4_encode_visual_object_header(s); 
2342 
if(s>strict_std_compliance < 2  picture_number==0) //HACK, the reference sw is buggy 
2343 
mpeg4_encode_vol_header(s, 0, 0); 
2344 
} 
2345 
mpeg4_encode_gop_header(s); 
2346 
} 
2347 

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

2351 

2352 
put_bits(&s>pb, 16, 0); /* vop header */ 
2353 
put_bits(&s>pb, 16, VOP_STARTCODE); /* vop header */ 
2354 
put_bits(&s>pb, 2, s>pict_type  1); /* pict type: I = 0 , P = 1 */ 
2355  
2356 
time_div= s>time/s>time_increment_resolution; 
2357 
time_mod= s>time%s>time_increment_resolution; 
2358 
time_incr= time_div  s>last_time_base; 
2359 
while(time_incr)

2360 
put_bits(&s>pb, 1, 1); 
2361 

2362 
put_bits(&s>pb, 1, 0); 
2363  
2364 
put_bits(&s>pb, 1, 1); /* marker */ 
2365 
put_bits(&s>pb, s>time_increment_bits, time_mod); /* time increment */

2366 
put_bits(&s>pb, 1, 1); /* marker */ 
2367 
put_bits(&s>pb, 1, 1); /* vop coded */ 
2368 
if ( s>pict_type == P_TYPE

2369 
 (s>pict_type == S_TYPE && s>vol_sprite_usage==GMC_SPRITE)) { 
2370 
put_bits(&s>pb, 1, s>no_rounding); /* rounding type */ 
2371 
} 
2372 
put_bits(&s>pb, 3, 0); /* intra dc VLC threshold */ 
2373 
if(!s>progressive_sequence){

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

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

2376 
} 
2377 
//FIXME sprite stuff

2378  
2379 
put_bits(&s>pb, 5, s>qscale);

2380  
2381 
if (s>pict_type != I_TYPE)

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

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

2386 
} 
2387  
2388 
#endif //CONFIG_ENCODERS 
2389  
2390 
/**

2391 
* set qscale and update qscale dependant variables.

2392 
*/

2393 
void ff_set_qscale(MpegEncContext * s, int qscale) 
2394 
{ 
2395 
if (qscale < 1) 
2396 
qscale = 1;

2397 
else if (qscale > 31) 
2398 
qscale = 31;

2399 

2400 
s>qscale = qscale; 
2401 
s>chroma_qscale= s>chroma_qscale_table[qscale]; 
2402  
2403 
s>y_dc_scale= s>y_dc_scale_table[ qscale ]; 
2404 
s>c_dc_scale= s>c_dc_scale_table[ s>chroma_qscale ]; 
2405 
} 
2406  
2407 
/**

2408 
* predicts the dc.

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

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

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

2412 
* @return the quantized predicted dc

2413 
*/

2414 
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) 
2415 
{ 
2416 
int a, b, c, wrap, pred, scale;

2417 
uint16_t *dc_val; 
2418  
2419 
/* find prediction */

2420 
if (n < 4) { 
2421 
scale = s>y_dc_scale; 
2422 
} else {

2423 
scale = s>c_dc_scale; 
2424 
} 
2425 
if(IS_3IV1)

2426 
scale= 8;

2427  
2428 
wrap= s>block_wrap[n]; 
2429 
dc_val = s>dc_val[0] + s>block_index[n];

2430  
2431 
/* B C

2432 
* A X

2433 
*/

2434 
a = dc_val[  1];

2435 
b = dc_val[  1  wrap];

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

2439 
if(s>first_slice_line && n!=3){ 
2440 
if(n!=2) b=c= 1024; 
2441 
if(n!=1 && s>mb_x == s>resync_mb_x) b=a= 1024; 
2442 
} 
2443 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1){ 
2444 
if(n==0  n==4  n==5) 
2445 
b=1024;

2446 
} 
2447  
2448 
if (abs(a  b) < abs(b  c)) {

2449 
pred = c; 
2450 
*dir_ptr = 1; /* top */ 
2451 
} else {

2452 
pred = a; 
2453 
*dir_ptr = 0; /* left */ 
2454 
} 
2455 
/* we assume pred is positive */

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

2457  
2458 
/* prepare address for prediction update */

2459 
*dc_val_ptr = &dc_val[0];

2460  
2461 
return pred;

2462 
} 
2463  
2464 
/**

2465 
* predicts the ac.

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

2467 
* @param dir the ac prediction direction

2468 
*/

2469 
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, 
2470 
int dir)

2471 
{ 
2472 
int i;

2473 
int16_t *ac_val, *ac_val1; 
2474 
int8_t * const qscale_table= s>current_picture.qscale_table;

2475  
2476 
/* find prediction */

2477 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
2478 
ac_val1 = ac_val; 
2479 
if (s>ac_pred) {

2480 
if (dir == 0) { 
2481 
const int xy= s>mb_x1 + s>mb_y*s>mb_stride; 
2482 
/* left prediction */

2483 
ac_val = 16;

2484 

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

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

2489 
} 
2490 
}else{

2491 
/* different qscale, we must rescale */

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

2494 
} 
2495 
} 
2496 
} else {

2497 
const int xy= s>mb_x + s>mb_y*s>mb_stride  s>mb_stride; 
2498 
/* top prediction */

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

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

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

2505 
} 
2506 
}else{

2507 
/* different qscale, we must rescale */

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

2510 
} 
2511 
} 
2512 
} 
2513 
} 
2514 
/* left copy */

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

2517  
2518 
/* top copy */

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

2521  
2522 
} 
2523  
2524 
#ifdef CONFIG_ENCODERS

2525  
2526 
/**

2527 
* encodes the dc value.

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

2529 
*/

2530 
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) 
2531 
{ 
2532 
#if 1 
2533 
// if(level<255  level>255) printf("dc overflow\n");

2534 
level+=256;

2535 
if (n < 4) { 
2536 
/* luminance */

2537 
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); 
2538 
} else {

2539 
/* chrominance */

2540 
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); 
2541 
} 
2542 
#else

2543 
int size, v;

2544 
/* find number of bits */

2545 
size = 0;

2546 
v = abs(level); 
2547 
while (v) {

2548 
v >>= 1;

2549 
size++; 
2550 
} 
2551  
2552 
if (n < 4) { 
2553 
/* luminance */

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

2556 
/* chrominance */

2557 
put_bits(&s>pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 
2558 
} 
2559  
2560 
/* encode remaining bits */

2561 
if (size > 0) { 
2562 
if (level < 0) 
2563 
level = (level) ^ ((1 << size)  1); 
2564 
put_bits(&s>pb, size, level); 
2565 
if (size > 8) 
2566 
put_bits(&s>pb, 1, 1); 
2567 
} 
2568 
#endif

2569 
} 
2570  
2571 
/**

2572 
* encodes a 8x8 block

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

2574 
*/

2575 
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2576 
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) 
2577 
{ 
2578 
int i, last_non_zero;

2579 
#if 0 //variables for the outcommented version

2580 
int code, sign, last;

2581 
#endif

2582 
const RLTable *rl;

2583 
uint32_t *bits_tab; 
2584 
uint8_t *len_tab; 
2585 
const int last_index = s>block_last_index[n]; 
2586  
2587 
if (s>mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 
2588 
/* mpeg4 based DC predictor */

2589 
mpeg4_encode_dc(dc_pb, intra_dc, n); 
2590 
if(last_index<1) return; 
2591 
i = 1;

2592 
rl = &rl_intra; 
2593 
bits_tab= uni_mpeg4_intra_rl_bits; 
2594 
len_tab = uni_mpeg4_intra_rl_len; 
2595 
} else {

2596 
if(last_index<0) return; 
2597 
i = 0;

2598 
rl = &rl_inter; 
2599 
bits_tab= uni_mpeg4_inter_rl_bits; 
2600 
len_tab = uni_mpeg4_inter_rl_len; 
2601 
} 
2602  
2603 
/* AC coefs */

2604 
last_non_zero = i  1;

2605 
#if 1 
2606 
for (; i < last_index; i++) {

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

2608 
if (level) {

2609 
int run = i  last_non_zero  1; 
2610 
level+=64;

2611 
if((level&(~127)) == 0){ 
2612 
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 
2613 
put_bits(ac_pb, len_tab[index], bits_tab[index]); 
2614 
}else{ //ESC3 
2615 
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); 
2616 
} 
2617 
last_non_zero = i; 
2618 
} 
2619 
} 
2620 
/*if(i<=last_index)*/{

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

2622 
int run = i  last_non_zero  1; 
2623 
level+=64;

2624 
if((level&(~127)) == 0){ 
2625 
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 
2626 
put_bits(ac_pb, len_tab[index], bits_tab[index]); 
2627 
}else{ //ESC3 
2628 
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); 
2629 
} 
2630 
} 
2631 
#else

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

2633 
const int slevel = block[ scan_table[i] ]; 
2634 
if (slevel) {

2635 
int level;

2636 
int run = i  last_non_zero  1; 
2637 
last = (i == last_index); 
2638 
sign = 0;

2639 
level = slevel; 
2640 
if (level < 0) { 
2641 
sign = 1;

2642 
level = level; 
2643 
} 
2644 
code = get_rl_index(rl, last, run, level); 
2645 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2646 
if (code == rl>n) {

2647 
int level1, run1;

2648 
level1 = level  rl>max_level[last][run]; 
2649 
if (level1 < 1) 
2650 
goto esc2;

2651 
code = get_rl_index(rl, last, run, level1); 
2652 
if (code == rl>n) {

2653 
esc2:

2654 
put_bits(ac_pb, 1, 1); 
2655 
if (level > MAX_LEVEL)

2656 
goto esc3;

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

2658 
if (run1 < 0) 
2659 
goto esc3;

2660 
code = get_rl_index(rl, last, run1, level); 
2661 
if (code == rl>n) {

2662 
esc3:

2663 
/* third escape */

2664 
put_bits(ac_pb, 1, 1); 
2665 
put_bits(ac_pb, 1, last);

2666 
put_bits(ac_pb, 6, run);

2667 
put_bits(ac_pb, 1, 1); 
2668 
put_bits(ac_pb, 12, slevel & 0xfff); 
2669 
put_bits(ac_pb, 1, 1); 
2670 
} else {

2671 
/* second escape */

2672 
put_bits(ac_pb, 1, 0); 
2673 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2674 
put_bits(ac_pb, 1, sign);

2675 
} 
2676 
} else {

2677 
/* first escape */

2678 
put_bits(ac_pb, 1, 0); 
2679 
put_bits(ac_pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
2680 
put_bits(ac_pb, 1, sign);

2681 
} 
2682 
} else {

2683 
put_bits(ac_pb, 1, sign);

2684 
} 
2685 
last_non_zero = i; 
2686 
} 
2687 
} 
2688 
#endif

2689 
} 
2690  
2691 
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 
2692 
uint8_t *scan_table) 
2693 
{ 
2694 
int i, last_non_zero;

2695 
const RLTable *rl;

2696 
uint8_t *len_tab; 
2697 
const int last_index = s>block_last_index[n]; 
2698 
int len=0; 
2699  
2700 
if (s>mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 
2701 
/* mpeg4 based DC predictor */

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

2703 
if(last_index<1) return len; 
2704 
i = 1;

2705 
rl = &rl_intra; 
2706 
len_tab = uni_mpeg4_intra_rl_len; 
2707 
} else {

2708 
if(last_index<0) return 0; 
2709 
i = 0;

2710 
rl = &rl_inter; 
2711 
len_tab = uni_mpeg4_inter_rl_len; 
2712 
} 
2713  
2714 
/* AC coefs */

2715 
last_non_zero = i  1;

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

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

2718 
if (level) {

2719 
int run = i  last_non_zero  1; 
2720 
level+=64;

2721 
if((level&(~127)) == 0){ 
2722 
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 
2723 
len += len_tab[index]; 
2724 
}else{ //ESC3 
2725 
len += 7+2+1+6+1+12+1; 
2726 
} 
2727 
last_non_zero = i; 
2728 
} 
2729 
} 
2730 
/*if(i<=last_index)*/{

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

2732 
int run = i  last_non_zero  1; 
2733 
level+=64;

2734 
if((level&(~127)) == 0){ 
2735 
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 
2736 
len += len_tab[index]; 
2737 
}else{ //ESC3 
2738 
len += 7+2+1+6+1+12+1; 
2739 
} 
2740 
} 
2741 

2742 
return len;

2743 
} 
2744  
2745 
#endif

2746  
2747  
2748 
/***********************************************/

2749 
/* decoding */

2750  
2751 
static VLC intra_MCBPC_vlc;

2752 
static VLC inter_MCBPC_vlc;

2753 
static VLC cbpy_vlc;

2754 
static VLC mv_vlc;

2755 
static VLC dc_lum, dc_chrom;

2756 
static VLC sprite_trajectory;

2757 
static VLC mb_type_b_vlc;

2758 
static VLC h263_mbtype_b_vlc;

2759 
static VLC cbpc_b_vlc;

2760  
2761 
void init_vlc_rl(RLTable *rl)

2762 
{ 
2763 
int i, q;

2764 

2765 
init_vlc(&rl>vlc, 9, rl>n + 1, 
2766 
&rl>table_vlc[0][1], 4, 2, 
2767 
&rl>table_vlc[0][0], 4, 2); 
2768  
2769 

2770 
for(q=0; q<32; q++){ 
2771 
int qmul= q*2; 
2772 
int qadd= (q1)1; 
2773 

2774 
if(q==0){ 
2775 
qmul=1;

2776 
qadd=0;

2777 
} 
2778 

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

2780 
for(i=0; i<rl>vlc.table_size; i++){ 
2781 
int code= rl>vlc.table[i][0]; 
2782 
int len = rl>vlc.table[i][1]; 
2783 
int level, run;

2784 

2785 
if(len==0){ // illegal code 
2786 
run= 66;

2787 
level= MAX_LEVEL; 
2788 
}else if(len<0){ //more bits needed 
2789 
run= 0;

2790 
level= code; 
2791 
}else{

2792 
if(code==rl>n){ //esc 
2793 
run= 66;

2794 
level= 0;

2795 
}else{

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

2797 
level= rl>table_level[code] * qmul + qadd; 
2798 
if(code >= rl>last) run+=192; 
2799 
} 
2800 
} 
2801 
rl>rl_vlc[q][i].len= len; 
2802 
rl>rl_vlc[q][i].level= level; 
2803 
rl>rl_vlc[q][i].run= run; 
2804 
} 
2805 
} 
2806 
} 
2807  
2808 
/* init vlcs */

2809  
2810 
/* XXX: find a better solution to handle static init */

2811 
void h263_decode_init_vlc(MpegEncContext *s)

2812 
{ 
2813 
static int done = 0; 
2814  
2815 
if (!done) {

2816 
done = 1;

2817  
2818 
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,

2819 
intra_MCBPC_bits, 1, 1, 
2820 
intra_MCBPC_code, 1, 1); 
2821 
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,

2822 
inter_MCBPC_bits, 1, 1, 
2823 
inter_MCBPC_code, 1, 1); 
2824 
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,

2825 
&cbpy_tab[0][1], 2, 1, 
2826 
&cbpy_tab[0][0], 2, 1); 
2827 
init_vlc(&mv_vlc, MV_VLC_BITS, 33,

2828 
&mvtab[0][1], 2, 1, 
2829 
&mvtab[0][0], 2, 1); 
2830 
init_rl(&rl_inter); 
2831 
init_rl(&rl_intra); 
2832 
init_rl(&rvlc_rl_inter); 
2833 
init_rl(&rvlc_rl_intra); 
2834 
init_rl(&rl_intra_aic); 
2835 
init_vlc_rl(&rl_inter); 
2836 
init_vlc_rl(&rl_intra); 
2837 
init_vlc_rl(&rvlc_rl_inter); 
2838 
init_vlc_rl(&rvlc_rl_intra); 
2839 
init_vlc_rl(&rl_intra_aic); 
2840 
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, 
2841 
&DCtab_lum[0][1], 2, 1, 
2842 
&DCtab_lum[0][0], 2, 1); 
2843 
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, 
2844 
&DCtab_chrom[0][1], 2, 1, 
2845 
&DCtab_chrom[0][0], 2, 1); 
2846 
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,

2847 
&sprite_trajectory_tab[0][1], 4, 2, 
2848 
&sprite_trajectory_tab[0][0], 4, 2); 
2849 
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,

2850 
&mb_type_b_tab[0][1], 2, 1, 
2851 
&mb_type_b_tab[0][0], 2, 1); 
2852 
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,

2853 
&h263_mbtype_b_tab[0][1], 2, 1, 
2854 
&h263_mbtype_b_tab[0][0], 2, 1); 
2855 
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,

2856 
&cbpc_b_tab[0][1], 2, 1, 
2857 
&cbpc_b_tab[0][0], 2, 1); 
2858 
} 
2859 
} 
2860  
2861 
/**

2862 
* Get the GOB height based on picture height.

2863 
*/

2864 
int ff_h263_get_gob_height(MpegEncContext *s){

2865 
if (s>height <= 400) 
2866 
return 1; 
2867 
else if (s>height <= 800) 
2868 
return 2; 
2869 
else

2870 
return 4; 
2871 
} 
2872  
2873 
int ff_h263_decode_mba(MpegEncContext *s)

2874 
{ 
2875 
int i, mb_pos;

2876  
2877 
for(i=0; i<6; i++){ 
2878 
if(s>mb_num1 <= ff_mba_max[i]) break; 
2879 
} 
2880 
mb_pos= get_bits(&s>gb, ff_mba_length[i]); 
2881 
s>mb_x= mb_pos % s>mb_width; 
2882 
s>mb_y= mb_pos / s>mb_width; 
2883  
2884 
return mb_pos;

2885 
} 
2886  
2887 
void ff_h263_encode_mba(MpegEncContext *s)

2888 
{ 
2889 
int i, mb_pos;

2890  
2891 
for(i=0; i<6; i++){ 
2892 
if(s>mb_num1 <= ff_mba_max[i]) break; 
2893 
} 
2894 
mb_pos= s>mb_x + s>mb_width*s>mb_y; 
2895 
put_bits(&s>pb, ff_mba_length[i], mb_pos); 
2896 
} 
2897  
2898 
/**

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

2900 
* @return <0 if an error occured

2901 
*/

2902 
static int h263_decode_gob_header(MpegEncContext *s) 
2903 
{ 
2904 
unsigned int val, gfid, gob_number; 
2905 
int left;

2906 

2907 
/* Check for GOB Start Code */

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

2909 
if(val)

2910 
return 1; 
2911  
2912 
/* We have a GBSC probably with GSTUFF */

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

2916 
for(;left>13; left){ 
2917 
if(get_bits1(&s>gb)) break; /* Seek the '1' bit */ 
2918 
} 
2919 
if(left<=13) 
2920 
return 1; 
2921  
2922 
if(s>h263_slice_structured){

2923 
if(get_bits1(&s>gb)==0) 
2924 
return 1; 
2925  
2926 
ff_h263_decode_mba(s); 
2927  
2928 
if(s>mb_num > 1583) 
2929 
if(get_bits1(&s>gb)==0) 
2930 
return 1; 
2931 

2932 
s>qscale = get_bits(&s>gb, 5); /* SQUANT */ 
2933 
if(get_bits1(&s>gb)==0) 
2934 
return 1; 
2935 
gfid = get_bits(&s>gb, 2); /* GFID */ 
2936 
}else{

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

2939 
s>mb_y= s>gob_index* gob_number; 
2940 
gfid = get_bits(&s>gb, 2); /* GFID */ 
2941 
s>qscale = get_bits(&s>gb, 5); /* GQUANT */ 
2942 
} 
2943 

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

2945 
return 1; 
2946  
2947 
if(s>qscale==0) 
2948 
return 1; 
2949  
2950 
return 0; 
2951 
} 
2952  
2953 
static inline void memsetw(short *tab, int val, int n) 
2954 
{ 
2955 
int i;

2956 
for(i=0;i<n;i++) 
2957 
tab[i] = val; 
2958 
} 
2959  
2960 
#ifdef CONFIG_ENCODERS

2961  
2962 
void ff_mpeg4_init_partitions(MpegEncContext *s)

2963 
{ 
2964 
uint8_t *start= pbBufPtr(&s>pb); 
2965 
uint8_t *end= s>pb.buf_end; 
2966 
int size= end  start;

2967 
int pb_size = size/3; 
2968 
int pb2_size= size/3; 
2969 
int tex_size= size  pb_size  pb2_size;

2970 

2971 
set_put_bits_buffer_size(&s>pb, pb_size); 
2972 
init_put_bits(&s>tex_pb, start + pb_size , tex_size); 
2973 
init_put_bits(&s>pb2 , start + pb_size + tex_size, pb2_size); 
2974 
} 
2975  
2976 
void ff_mpeg4_merge_partitions(MpegEncContext *s)

2977 
{ 
2978 
const int pb2_len = put_bits_count(&s>pb2 ); 
2979 
const int tex_pb_len= put_bits_count(&s>tex_pb); 
2980 
const int bits= put_bits_count(&s>pb); 
2981  
2982 
if(s>pict_type==I_TYPE){

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

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

2985 
s>i_tex_bits+= tex_pb_len; 
2986 
}else{

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

2988 
s>misc_bits+=17 + pb2_len;

2989 
s>mv_bits+= bits  s>last_bits; 
2990 
s>p_tex_bits+= tex_pb_len; 
2991 
} 
2992  
2993 
flush_put_bits(&s>pb2); 
2994 
flush_put_bits(&s>tex_pb); 
2995  
2996 
set_put_bits_buffer_size(&s>pb, s>pb2.buf_end  s>pb.buf); 
2997 
ff_copy_bits(&s>pb, s>pb2.buf , pb2_len); 
2998 
ff_copy_bits(&s>pb, s>tex_pb.buf, tex_pb_len); 
2999 
s>last_bits= put_bits_count(&s>pb); 
3000 
} 
3001  
3002 
#endif //CONFIG_ENCODERS 
3003  
3004 
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){

3005 
switch(s>pict_type){

3006 
case I_TYPE:

3007 
return 16; 
3008 
case P_TYPE:

3009 
case S_TYPE:

3010 
return s>f_code+15; 
3011 
case B_TYPE:

3012 
return FFMAX(FFMAX(s>f_code, s>b_code)+15, 17); 
3013 
default:

3014 
return 1; 
3015 
} 
3016 
} 
3017  
3018 
#ifdef CONFIG_ENCODERS

3019  
3020 
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)

3021 
{ 
3022 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
3023  
3024 
put_bits(&s>pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);

3025 
put_bits(&s>pb, 1, 1); 
3026 

3027 
put_bits(&s>pb, mb_num_bits, s>mb_x + s>mb_y*s>mb_width); 
3028 
put_bits(&s>pb, s>quant_precision, s>qscale); 
3029 
put_bits(&s>pb, 1, 0); /* no HEC */ 
3030 
} 
3031  
3032 
#endif //CONFIG_ENCODERS 
3033  
3034 
/**

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

3036 
* @return 0 if not

3037 
*/

3038 
static inline int mpeg4_is_resync(MpegEncContext *s){ 
3039 
const int bits_count= get_bits_count(&s>gb); 
3040 

3041 
if(s>workaround_bugs&FF_BUG_NO_PADDING){

3042 
return 0; 
3043 
} 
3044  
3045 
if(bits_count + 8 >= s>gb.size_in_bits){ 
3046 
int v= show_bits(&s>gb, 8); 
3047 
v= 0x7F >> (7(bits_count&7)); 
3048 

3049 
if(v==0x7F) 
3050 
return 1; 
3051 
}else{

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

3054 
GetBitContext gb= s>gb; 
3055 

3056 
skip_bits(&s>gb, 1);

3057 
align_get_bits(&s>gb); 
3058 

3059 
for(len=0; len<32; len++){ 
3060 
if(get_bits1(&s>gb)) break; 
3061 
} 
3062  
3063 
s>gb= gb; 
3064  
3065 
if(len>=ff_mpeg4_get_video_packet_prefix_length(s))

3066 
return 1; 
3067 
} 
3068 
} 
3069 
return 0; 
3070 
} 
3071  
3072 
/**

3073 
* decodes the next video packet.

3074 
* @return <0 if something went wrong

3075 
*/

3076 
static int mpeg4_decode_video_packet_header(MpegEncContext *s) 
3077 
{ 
3078 
int mb_num_bits= av_log2(s>mb_num  1) + 1; 
3079 
int header_extension=0, mb_num, len; 
3080 

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

3082 
if( get_bits_count(&s>gb) > s>gb.size_in_bits20) return 1; 
3083  
3084 
for(len=0; len<32; len++){ 
3085 
if(get_bits1(&s>gb)) break; 
3086 
} 
3087  
3088 
if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){

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

3090 
return 1; 
3091 
} 
3092 

3093 
if(s>shape != RECT_SHAPE){

3094 
header_extension= get_bits1(&s>gb); 
3095 
//FIXME more stuff here

3096 
} 
3097  
3098 
mb_num= get_bits(&s>gb, mb_num_bits); 
3099 
if(mb_num>=s>mb_num){

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

3101 
return 1; 
3102 
} 
3103 
if(s>pict_type == B_TYPE){

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

3105 
if(mb_num >= s>mb_num) return 1; // slice contains just skiped MBs which where allready decoded 
3106 
} 
3107 

3108 
s>mb_x= mb_num % s>mb_width; 
3109 
s>mb_y= mb_num / s>mb_width; 
3110  
3111 
if(s>shape != BIN_ONLY_SHAPE){

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

3113 
if(qscale)

3114 
s>chroma_qscale=s>qscale= qscale; 
3115 
} 
3116  
3117 
if(s>shape == RECT_SHAPE){

3118 
header_extension= get_bits1(&s>gb); 
3119 
} 
3120 
if(header_extension){

3121 
int time_increment;

3122 
int time_incr=0; 
3123  
3124 
while (get_bits1(&s>gb) != 0) 
3125 
time_incr++; 
3126  
3127 
check_marker(&s>gb, "before time_increment in video packed header");

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

3130 

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

3133  
3134 
if(s>shape != BIN_ONLY_SHAPE){

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

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

3138 
mpeg4_decode_sprite_trajectory(s); 
3139 
av_log(s>avctx, AV_LOG_ERROR, "untested\n");

3140 
} 
3141  
3142 
//FIXME reduced res stuff here

3143 

3144 
if (s>pict_type != I_TYPE) {

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

3148 
} 
3149 
} 
3150 
if (s>pict_type == B_TYPE) {

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

3154 
} 
3155 
} 
3156 
} 
3157 
} 
3158 
//FIXME newpred stuff

3159 

3160 
//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));

3161  
3162 
return 0; 
3163 
} 
3164  
3165 
void ff_mpeg4_clean_buffers(MpegEncContext *s)

3166 
{ 
3167 
int c_wrap, c_xy, l_wrap, l_xy;

3168  
3169 
l_wrap= s>block_wrap[0];

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

3172 
c_xy= s>mb_y*c_wrap + s>mb_x; 
3173  
3174 
#if 0

3175 
/* clean DC */

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

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

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

3179 
#endif

3180  
3181 
/* clean AC */

3182 
memset(s>ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); 
3183 
memset(s>ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 
3184 
memset(s>ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 
3185  
3186 
/* clean MV */

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

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

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

3190 
s>last_mv[0][0][0]= 
3191 
s>last_mv[0][0][1]= 
3192 
s>last_mv[1][0][0]= 
3193 
s>last_mv[1][0][1]= 0; 
3194 
} 
3195  
3196 
/**

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

3198 
* @return <0 if no resync found

3199 
*/

3200 
int ff_h263_resync(MpegEncContext *s){

3201 
int left, ret;

3202 

3203 
if(s>codec_id==CODEC_ID_MPEG4){

3204 
skip_bits1(&s>gb); 
3205 
align_get_bits(&s>gb); 
3206 
} 
3207  
3208 
if(show_bits(&s>gb, 16)==0){ 
3209 
if(s>codec_id==CODEC_ID_MPEG4)

3210 
ret= mpeg4_decode_video_packet_header(s); 
3211 
else

3212 
ret= h263_decode_gob_header(s); 
3213 
if(ret>=0) 
3214 
return 0; 
3215 
} 
3216 
//ok, its not where its supposed to be ...

3217 
s>gb= s>last_resync_gb; 
3218 
align_get_bits(&s>gb); 
3219 
left= s>gb.size_in_bits  get_bits_count(&s>gb); 
3220 

3221 
for(;left>16+1+5+5; left=8){ 
3222 
if(show_bits(&s>gb, 16)==0){ 
3223 
GetBitContext bak= s>gb; 
3224  
3225 
if(s>codec_id==CODEC_ID_MPEG4)

3226 
ret= mpeg4_decode_video_packet_header(s); 
3227 
else

3228 
ret= h263_decode_gob_header(s); 
3229 
if(ret>=0) 
3230 
return 0; 
3231  
3232 
s>gb= bak; 
3233 
} 
3234 
skip_bits(&s>gb, 8);

3235 
} 
3236 

3237 
return 1; 
3238 
} 
3239  
3240 
/**

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

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

3243 
* @returns the average MV for a GMC MB

3244 
*/

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

3247 
int len = 1 << (s>f_code + 4); 
3248 
const int a= s>sprite_warping_accuracy; 
3249  
3250 
if(s>real_sprite_warping_points==1){ 
3251 
if(s>divx_version==500 && s>divx_build==413) 
3252 
sum= s>sprite_offset[0][n] / (1<<(a  s>quarter_sample)); 
3253 
else

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

3255 
}else{

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

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

3258 
shift= s>sprite_shift[0];

3259 
if(n) dy = 1<<(shift + a + 1); 
3260 
else dx = 1<<(shift + a + 1); 
3261 
mb_v= s>sprite_offset[0][n] + dx*s>mb_x*16 + dy*s>mb_y*16; 
3262  
3263 
sum=0;

3264 
for(y=0; y<16; y++){ 
3265 
int v;

3266 

3267 
v= mb_v + dy*y; 
3268 
//XXX FIXME optimize

3269 
for(x=0; x<16; x++){ 
3270 
sum+= v>>shift; 
3271 
v+= dx; 
3272 
} 
3273 
} 
3274 
sum= RSHIFT(sum, a+8s>quarter_sample);

3275 
} 
3276  
3277 
if (sum < len) sum= len;

3278 
else if (sum >= len) sum= len1; 
3279  
3280 
return sum;

3281 
} 
3282  
3283 
/**

3284 
* decodes first partition.

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

3286 
*/

3287 
static int mpeg4_decode_partition_a(MpegEncContext *s){ 
3288 
int mb_num;

3289 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3290 

3291 
/* decode first partition */

3292 
mb_num=0;

3293 
s>first_slice_line=1;

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

3295 
ff_init_block_index(s); 
3296 
for(; s>mb_x<s>mb_width; s>mb_x++){

3297 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3298 
int cbpc;

3299 
int dir=0; 
3300 

3301 
mb_num++; 
3302 
ff_update_block_index(s); 
3303 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1) 
3304 
s>first_slice_line=0;

3305 

3306 
if(s>pict_type==I_TYPE){

3307 
int i;

3308  
3309 
if(show_bits_long(&s>gb, 19)==DC_MARKER){ 
3310 
return mb_num1; 
3311 
} 
3312  
3313 
do{

3314 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

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

3317 
return 1; 
3318 
} 
3319 
}while(cbpc == 8); 
3320  
3321 
s>cbp_table[xy]= cbpc & 3;

3322 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3323 
s>mb_intra = 1;

3324  
3325 
if(cbpc & 4) { 
3326 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3327 
} 
3328 
s>current_picture.qscale_table[xy]= s>qscale; 
3329  
3330 
s>mbintra_table[xy]= 1;

3331 
for(i=0; i<6; i++){ 
3332 
int dc_pred_dir;

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

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

3336 
return 1; 
3337 
} 
3338 
dir<<=1;

3339 
if(dc_pred_dir) dir=1; 
3340 
} 
3341 
s>pred_dir_table[xy]= dir; 
3342 
}else{ /* P/S_TYPE */ 
3343 
int mx, my, pred_x, pred_y, bits;

3344 
int16_t * const mot_val= s>current_picture.motion_val[0][s>block_index[0]]; 
3345 
const int stride= s>block_wrap[0]*2; 
3346  
3347 
// do{ //FIXME

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

3349 
if(bits==MOTION_MARKER){

3350 
return mb_num1; 
3351 
} 
3352 
skip_bits1(&s>gb); 
3353 
if(bits&0x10000){ 
3354 
/* skip mb */

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

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

3358 
my= get_amv(s, 1);

3359 
}else{

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

3362 
} 
3363 
mot_val[0 ]= mot_val[2 ]= 
3364 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3365 
mot_val[1 ]= mot_val[3 ]= 
3366 
mot_val[1+stride]= mot_val[3+stride]= my; 
3367  
3368 
if(s>mbintra_table[xy])

3369 
ff_clean_intra_table_entries(s); 
3370 
continue;

3371 
} 
3372  
3373 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

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

3376 
return 1; 
3377 
} 
3378 
// }while(cbpc == 20);

3379  
3380 
s>cbp_table[xy]= cbpc&(8+3); //8 is dquant 
3381 

3382 
s>mb_intra = ((cbpc & 4) != 0); 
3383 

3384 
if(s>mb_intra){

3385 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3386 
s>mbintra_table[xy]= 1;

3387 
mot_val[0 ]= mot_val[2 ]= 
3388 
mot_val[0+stride]= mot_val[2+stride]= 0; 
3389 
mot_val[1 ]= mot_val[3 ]= 
3390 
mot_val[1+stride]= mot_val[3+stride]= 0; 
3391 
}else{

3392 
if(s>mbintra_table[xy])

3393 
ff_clean_intra_table_entries(s); 
3394  
3395 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
3396 
s>mcsel= get_bits1(&s>gb); 
3397 
else s>mcsel= 0; 
3398 

3399 
if ((cbpc & 16) == 0) { 
3400 
/* 16x16 motion prediction */

3401  
3402 
h263_pred_motion(s, 0, &pred_x, &pred_y);

3403 
if(!s>mcsel){

3404 
mx = h263_decode_motion(s, pred_x, s>f_code); 
3405 
if (mx >= 0xffff) 
3406 
return 1; 
3407  
3408 
my = h263_decode_motion(s, pred_y, s>f_code); 
3409 
if (my >= 0xffff) 
3410 
return 1; 
3411 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3412 
} else {

3413 
mx = get_amv(s, 0);

3414 
my = get_amv(s, 1);

3415 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_GMC  MB_TYPE_L0; 
3416 
} 
3417  
3418 
mot_val[0 ]= mot_val[2 ] = 
3419 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3420 
mot_val[1 ]= mot_val[3 ]= 
3421 
mot_val[1+stride]= mot_val[3+stride]= my; 
3422 
} else {

3423 
int i;

3424 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3425 
for(i=0;i<4;i++) { 
3426 
int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); 
3427 
mx = h263_decode_motion(s, pred_x, s>f_code); 
3428 
if (mx >= 0xffff) 
3429 
return 1; 
3430 

3431 
my = h263_decode_motion(s, pred_y, s>f_code); 
3432 
if (my >= 0xffff) 
3433 
return 1; 
3434 
mot_val[0] = mx;

3435 
mot_val[1] = my;

3436 
} 
3437 
} 
3438 
} 
3439 
} 
3440 
} 
3441 
s>mb_x= 0;

3442 
} 
3443  
3444 
return mb_num;

3445 
} 
3446  
3447 
/**

3448 
* decode second partition.

3449 
* @return <0 if an error occured

3450 
*/

3451 
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ 
3452 
int mb_num=0; 
3453 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3454  
3455 
s>mb_x= s>resync_mb_x; 
3456 
s>first_slice_line=1;

3457 
for(s>mb_y= s>resync_mb_y; mb_num < mb_count; s>mb_y++){

3458 
ff_init_block_index(s); 
3459 
for(; mb_num < mb_count && s>mb_x<s>mb_width; s>mb_x++){

3460 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3461  
3462 
mb_num++; 
3463 
ff_update_block_index(s); 
3464 
if(s>mb_x == s>resync_mb_x && s>mb_y == s>resync_mb_y+1) 
3465 
s>first_slice_line=0;

3466 

3467 
if(s>pict_type==I_TYPE){

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

3469 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3470 
if(cbpy<0){ 
3471 
av_log(s>avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3472 
return 1; 
3473 
} 
3474 

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

3476 
s>current_picture.mb_type[xy] = ac_pred*MB_TYPE_ACPRED; 
3477 
}else{ /* P  S_TYPE */ 
3478 
if(IS_INTRA(s>current_picture.mb_type[xy])){

3479 
int dir=0,i; 
3480 
int ac_pred = get_bits1(&s>gb);

3481 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3482  
3483 
if(cbpy<0){ 
3484 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3485 
return 1; 
3486 
} 
3487 

3488 
if(s>cbp_table[xy] & 8) { 
3489 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3490 
} 
3491 
s>current_picture.qscale_table[xy]= s>qscale; 
3492  
3493 
for(i=0; i<6; i++){ 
3494 
int dc_pred_dir;

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

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

3498 
return 1; 
3499 
} 
3500 
dir<<=1;

3501 
if(dc_pred_dir) dir=1; 
3502 
} 
3503 
s>cbp_table[xy]&= 3; //remove dquant 
3504 
s>cbp_table[xy]= cbpy<<2;

3505 
s>current_picture.mb_type[xy] = ac_pred*MB_TYPE_ACPRED; 
3506 
s>pred_dir_table[xy]= dir; 
3507 
}else if(IS_SKIP(s>current_picture.mb_type[xy])){ 
3508 
s>current_picture.qscale_table[xy]= s>qscale; 
3509 
s>cbp_table[xy]= 0;

3510 
}else{

3511 
int cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 
3512  
3513 
if(cbpy<0){ 
3514 
av_log(s>avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s>mb_x, s>mb_y);

3515 
return 1; 
3516 
} 
3517 

3518 
if(s>cbp_table[xy] & 8) { 
3519 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

3520 
} 
3521 
s>current_picture.qscale_table[xy]= s>qscale; 
3522  
3523 
s>cbp_table[xy]&= 3; //remove dquant 
3524 
s>cbp_table[xy]= (cbpy^0xf)<<2; 
3525 
} 
3526 
} 
3527 
} 
3528 
if(mb_num >= mb_count) return 0; 
3529 
s>mb_x= 0;

3530 
} 
3531 
return 0; 
3532 
} 
3533  
3534 
/**

3535 
* decodes the first & second partition

3536 
* @return <0 if error (and sets error type in the error_status_table)

3537 
*/

3538 
int ff_mpeg4_decode_partitions(MpegEncContext *s)

3539 
{ 
3540 
int mb_num;

3541 
const int part_a_error= s>pict_type==I_TYPE ? (DC_ERRORMV_ERROR) : MV_ERROR; 
3542 
const int part_a_end = s>pict_type==I_TYPE ? (DC_END MV_END) : MV_END; 
3543 

3544 
mb_num= mpeg4_decode_partition_a(s); 
3545 
if(mb_num<0){ 
3546 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, part_a_error); 
3547 
return 1; 
3548 
} 
3549 

3550 
if(s>resync_mb_x + s>resync_mb_y*s>mb_width + mb_num > s>mb_num){

3551 
av_log(s>avctx, AV_LOG_ERROR, "slice below monitor ...\n");

3552 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, part_a_error); 
3553 
return 1; 
3554 
} 
3555  
3556 
s>mb_num_left= mb_num; 
3557 

3558 
if(s>pict_type==I_TYPE){

3559 
if(get_bits_long(&s>gb, 19)!=DC_MARKER){ 
3560 
av_log(s>avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s>mb_x, s>mb_y);

3561 
return 1; 
3562 
} 
3563 
}else{

3564 
if(get_bits(&s>gb, 17)!=MOTION_MARKER){ 
3565 
av_log(s>avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s>mb_x, s>mb_y);

3566 
return 1; 
3567 
} 
3568 
} 
3569 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x1, s>mb_y, part_a_end);

3570 

3571 
if( mpeg4_decode_partition_b(s, mb_num) < 0){ 
3572 
if(s>pict_type==P_TYPE)

3573 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y, DC_ERROR); 
3574 
return 1; 
3575 
}else{

3576 
if(s>pict_type==P_TYPE)

3577 
ff_er_add_slice(s, s>resync_mb_x, s>resync_mb_y, s>mb_x1, s>mb_y, DC_END);

3578 
} 
3579  
3580 
return 0; 
3581 
} 
3582  
3583 
/**

3584 
* decode partition C of one MB.

3585 
* @return <0 if an error occured

3586 
*/

3587 
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) 
3588 
{ 
3589 
int cbp, mb_type;

3590 
const int xy= s>mb_x + s>mb_y*s>mb_stride; 
3591  
3592 
mb_type= s>current_picture.mb_type[xy]; 
3593 
cbp = s>cbp_table[xy]; 
3594  
3595 
if(s>current_picture.qscale_table[xy] != s>qscale){

3596 
ff_set_qscale(s, s>current_picture.qscale_table[xy] ); 
3597 
} 
3598 

3599 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

3600 
int i;

3601 
for(i=0; i<4; i++){ 
3602 
s>mv[0][i][0] = s>current_picture.motion_val[0][ s>block_index[i] ][0]; 
3603 
s>mv[0][i][1] = s>current_picture.motion_val[0][ s>block_index[i] ][1]; 
3604 
} 
3605 
s>mb_intra = IS_INTRA(mb_type); 
3606  
3607 
if (IS_SKIP(mb_type)) {

3608 
/* skip mb */

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

3611 
s>mv_dir = MV_DIR_FORWARD; 
3612 
s>mv_type = MV_TYPE_16X16; 
3613 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

3614 
s>mcsel=1;

3615 
s>mb_skiped = 0;

3616 
}else{

3617 
s>mcsel=0;

3618 
s>mb_skiped = 1;

3619 
} 
3620 
}else if(s>mb_intra){ 
3621 
s>ac_pred = IS_ACPRED(s>current_picture.mb_type[xy]); 
3622 
}else if(!s>mb_intra){ 
3623 
// s>mcsel= 0; //FIXME do we need to init that

3624 

3625 
s>mv_dir = MV_DIR_FORWARD; 
3626 
if (IS_8X8(mb_type)) {

3627 
s>mv_type = MV_TYPE_8X8; 
3628 
} else {

3629 
s>mv_type = MV_TYPE_16X16; 
3630 
} 
3631 
} 
3632 
} else { /* IFrame */ 
3633 
s>mb_intra = 1;

3634 
s>ac_pred = IS_ACPRED(s>current_picture.mb_type[xy]); 
3635 
} 
3636  
3637 
if (!IS_SKIP(mb_type)) {

3638 
int i;

3639 
/* decode each block */

3640 
for (i = 0; i < 6; i++) { 
3641 
if(mpeg4_decode_block(s, block[i], i, cbp&32, s>mb_intra, s>rvlc) < 0){ 
3642 
av_log(s>avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s>mb_x, s>mb_y, s>mb_intra);

3643 
return 1; 
3644 
} 
3645 
cbp+=cbp; 
3646 
} 
3647 
} 
3648  
3649 
/* perMB end of slice check */

3650  
3651 
if(s>mb_num_left <= 0){ 
3652 
//printf("%06X %d\n", show_bits(&s>gb, 24), s>gb.size_in_bits  get_bits_count(&s>gb));

3653 
if(mpeg4_is_resync(s))

3654 
return SLICE_END;

3655 
else

3656 
return SLICE_NOEND;

3657 
}else{

3658 
if(mpeg4_is_resync(s)){

3659 
const int delta= s>mb_x + 1 == s>mb_width ? 2 : 1; 
3660 
if(s>cbp_table[xy+delta])

3661 
return SLICE_END;

3662 
} 
3663 
return SLICE_OK;

3664 
} 
3665 
} 
3666  
3667 
/**

3668 
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)

3669 
*/

3670 
static void preview_obmc(MpegEncContext *s){ 
3671 
GetBitContext gb= s>gb; 
3672 

3673 
int cbpc, i, pred_x, pred_y, mx, my;

3674 
int16_t *mot_val; 
3675 
const int xy= s>mb_x + 1 + s>mb_y * s>mb_stride; 
3676 
const int stride= s>block_wrap[0]*2; 
3677 

3678 
for(i=0; i<4; i++) 
3679 
s>block_index[i]+= 2;

3680 
for(i=4; i<6; i++) 
3681 
s>block_index[i]+= 1;

3682 
s>mb_x++; 
3683 

3684 
assert(s>pict_type == P_TYPE); 
3685  
3686 
do{

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

3688 
/* skip mb */

3689 
mot_val = s>current_picture.motion_val[0][ s>block_index[0] ]; 
3690 
mot_val[0 ]= mot_val[2 ]= 
3691 
mot_val[0+stride]= mot_val[2+stride]= 0; 
3692 
mot_val[1 ]= mot_val[3 ]= 
3693 
mot_val[1+stride]= mot_val[3+stride]= 0; 
3694 

3695 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
3696 
goto end;

3697 
} 
3698 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

3699 
}while(cbpc == 20); 
3700 

3701 
if(cbpc & 4){ 
3702 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3703 
}else{

3704 
get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3705 
if (cbpc & 8) { 
3706 
if(s>modified_quant){

3707 
if(get_bits1(&s>gb)) skip_bits(&s>gb, 1); 
3708 
else skip_bits(&s>gb, 5); 
3709 
}else

3710 
skip_bits(&s>gb, 2);

3711 
} 
3712 

3713 
if ((cbpc & 16) == 0) { 
3714 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3715 
/* 16x16 motion prediction */

3716 
mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);

3717 
if (s>umvplus)

3718 
mx = h263p_decode_umotion(s, pred_x); 
3719 
else

3720 
mx = h263_decode_motion(s, pred_x, 1);

3721 

3722 
if (s>umvplus)

3723 
my = h263p_decode_umotion(s, pred_y); 
3724 
else

3725 
my = h263_decode_motion(s, pred_y, 1);

3726 

3727 
mot_val[0 ]= mot_val[2 ]= 
3728 
mot_val[0+stride]= mot_val[2+stride]= mx; 
3729 
mot_val[1 ]= mot_val[3 ]= 
3730 
mot_val[1+stride]= mot_val[3+stride]= my; 
3731 
} else {

3732 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3733 
for(i=0;i<4;i++) { 
3734 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
3735 
if (s>umvplus)

3736 
mx = h263p_decode_umotion(s, pred_x); 
3737 
else

3738 
mx = h263_decode_motion(s, pred_x, 1);

3739 

3740 
if (s>umvplus)

3741 
my = h263p_decode_umotion(s, pred_y); 
3742 
else

3743 
my = h263_decode_motion(s, pred_y, 1);

3744 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3745 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3746 
mot_val[0] = mx;

3747 
mot_val[1] = my;

3748 
} 
3749 
} 
3750 
} 
3751 
end:

3752 

3753 
for(i=0; i<4; i++) 
3754 
s>block_index[i]= 2;

3755 
for(i=4; i<6; i++) 
3756 
s>block_index[i]= 1;

3757 
s>mb_x; 
3758  
3759 
s>gb= gb; 
3760 
} 
3761  
3762 
static void h263_decode_dquant(MpegEncContext *s){ 
3763 
static const int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
3764  
3765 
if(s>modified_quant){

3766 
if(get_bits1(&s>gb))

3767 
s>qscale= modified_quant_tab[get_bits1(&s>gb)][ s>qscale ]; 
3768 
else

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

3770 
}else

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

3772 
ff_set_qscale(s, s>qscale); 
3773 
} 
3774  
3775 
int ff_h263_decode_mb(MpegEncContext *s,

3776 
DCTELEM block[6][64]) 
3777 
{ 
3778 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

3779 
int16_t *mot_val; 
3780 
const int xy= s>mb_x + s>mb_y * s>mb_stride; 
3781 

3782 
assert(!s>h263_pred); 
3783 

3784 
if (s>pict_type == P_TYPE) {

3785 
do{

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

3787 
/* skip mb */

3788 
s>mb_intra = 0;

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

3791 
s>mv_dir = MV_DIR_FORWARD; 
3792 
s>mv_type = MV_TYPE_16X16; 
3793 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
3794 
s>mv[0][0][0] = 0; 
3795 
s>mv[0][0][1] = 0; 
3796 
s>mb_skiped = !(s>obmc  s>loop_filter); 
3797 
goto end;

3798 
} 
3799 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

3800 
//fprintf(stderr, "\tCBPC: %d", cbpc);

3801 
if (cbpc < 0){ 
3802 
av_log(s>avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

3803 
return 1; 
3804 
} 
3805 
}while(cbpc == 20); 
3806 

3807 
dquant = cbpc & 8;

3808 
s>mb_intra = ((cbpc & 4) != 0); 
3809 
if (s>mb_intra) goto intra; 
3810 

3811 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3812 

3813 
if(s>alt_inter_vlc==0  (cbpc & 3)!=3) 
3814 
cbpy ^= 0xF;

3815 

3816 
cbp = (cbpc & 3)  (cbpy << 2); 
3817 
if (dquant) {

3818 
h263_decode_dquant(s); 
3819 
} 
3820 

3821 
s>mv_dir = MV_DIR_FORWARD; 
3822 
if ((cbpc & 16) == 0) { 
3823 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
3824 
/* 16x16 motion prediction */

3825 
s>mv_type = MV_TYPE_16X16; 
3826 
h263_pred_motion(s, 0, &pred_x, &pred_y);

3827 
if (s>umvplus)

3828 
mx = h263p_decode_umotion(s, pred_x); 
3829 
else

3830 
mx = h263_decode_motion(s, pred_x, 1);

3831 

3832 
if (mx >= 0xffff) 
3833 
return 1; 
3834 

3835 
if (s>umvplus)

3836 
my = h263p_decode_umotion(s, pred_y); 
3837 
else

3838 
my = h263_decode_motion(s, pred_y, 1);

3839 

3840 
if (my >= 0xffff) 
3841 
return 1; 
3842 
s>mv[0][0][0] = mx; 
3843 
s>mv[0][0][1] = my; 
3844  
3845 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3846 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3847 
} else {

3848 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
3849 
s>mv_type = MV_TYPE_8X8; 
3850 
for(i=0;i<4;i++) { 
3851 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
3852 
if (s>umvplus)

3853 
mx = h263p_decode_umotion(s, pred_x); 
3854 
else

3855 
mx = h263_decode_motion(s, pred_x, 1);

3856 
if (mx >= 0xffff) 
3857 
return 1; 
3858 

3859 
if (s>umvplus)

3860 
my = h263p_decode_umotion(s, pred_y); 
3861 
else

3862 
my = h263_decode_motion(s, pred_y, 1);

3863 
if (my >= 0xffff) 
3864 
return 1; 
3865 
s>mv[0][i][0] = mx; 
3866 
s>mv[0][i][1] = my; 
3867 
if (s>umvplus && (mx  pred_x) == 1 && (my  pred_y) == 1) 
3868 
skip_bits1(&s>gb); /* Bit stuffing to prevent PSC */

3869 
mot_val[0] = mx;

3870 
mot_val[1] = my;

3871 
} 
3872 
} 
3873  
3874 
/* decode each block */

3875 
for (i = 0; i < 6; i++) { 
3876 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
3877 
return 1; 
3878 
cbp+=cbp; 
3879 
} 
3880  
3881 
if(s>obmc){

3882 
if(s>pict_type == P_TYPE && s>mb_x+1<s>mb_width && s>mb_num_left != 1) 
3883 
preview_obmc(s); 
3884 
} 
3885 
} else if(s>pict_type==B_TYPE) { 
3886 
int mb_type;

3887 
const int stride= s>b8_stride; 
3888 
int16_t *mot_val0 = s>current_picture.motion_val[0][ 2*(s>mb_x + s>mb_y*stride) ]; 
3889 
int16_t *mot_val1 = s>current_picture.motion_val[1][ 2*(s>mb_x + s>mb_y*stride) ]; 
3890 
// const int mv_xy= s>mb_x + 1 + s>mb_y * s>mb_stride;

3891  
3892 
//FIXME ugly

3893 
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 
3894 
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 
3895 
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 
3896 
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; 
3897  
3898 
do{

3899 
mb_type= get_vlc2(&s>gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);

3900 
if (mb_type < 0){ 
3901 
av_log(s>avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s>mb_x, s>mb_y);

3902 
return 1; 
3903 
} 
3904  
3905 
mb_type= h263_mb_type_b_map[ mb_type ]; 
3906 
}while(!mb_type);

3907  
3908 
s>mb_intra = IS_INTRA(mb_type); 
3909 
if(HAS_CBP(mb_type)){

3910 
cbpc = get_vlc2(&s>gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);

3911 
if(s>mb_intra){

3912 
dquant = IS_QUANT(mb_type); 
3913 
goto intra;

3914 
} 
3915  
3916 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

3917  
3918 
if (cbpy < 0){ 
3919 
av_log(s>avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

3920 
return 1; 
3921 
} 
3922 

3923 
if(s>alt_inter_vlc==0  (cbpc & 3)!=3) 
3924 
cbpy ^= 0xF;

3925 

3926 
cbp = (cbpc & 3)  (cbpy << 2); 
3927 
}else

3928 
cbp=0;

3929 

3930 
assert(!s>mb_intra); 
3931  
3932 
if(IS_QUANT(mb_type)){

3933 
h263_decode_dquant(s); 
3934 
} 
3935  
3936 
if(IS_DIRECT(mb_type)){

3937 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
3938 
mb_type = ff_mpeg4_set_direct_mv(s, 0, 0); 
3939 
}else{

3940 
s>mv_dir = 0;

3941 
s>mv_type= MV_TYPE_16X16; 
3942 
//FIXME UMV

3943  
3944 
if(USES_LIST(mb_type, 0)){ 
3945 
int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my); 
3946 
s>mv_dir = MV_DIR_FORWARD; 
3947  
3948 
mx = h263_decode_motion(s, mx, 1);

3949 
my = h263_decode_motion(s, my, 1);

3950 

3951 
s>mv[0][0][0] = mx; 
3952 
s>mv[0][0][1] = my; 
3953 
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 
3954 
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 
3955 
} 
3956 

3957 
if(USES_LIST(mb_type, 1)){ 
3958 
int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my); 
3959 
s>mv_dir = MV_DIR_BACKWARD; 
3960 

3961 
mx = h263_decode_motion(s, mx, 1);

3962 
my = h263_decode_motion(s, my, 1);

3963  
3964 
s>mv[1][0][0] = mx; 
3965 
s>mv[1][0][1] = my; 
3966 
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 
3967 
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 
3968 
} 
3969 
} 
3970 

3971 
s>current_picture.mb_type[xy]= mb_type; 
3972  
3973 
/* decode each block */

3974 
for (i = 0; i < 6; i++) { 
3975 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
3976 
return 1; 
3977 
cbp+=cbp; 
3978 
} 
3979 
} else { /* IFrame */ 
3980 
do{

3981 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

3982 
if (cbpc < 0){ 
3983 
av_log(s>avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

3984 
return 1; 
3985 
} 
3986 
}while(cbpc == 8); 
3987  
3988 
dquant = cbpc & 4;

3989 
s>mb_intra = 1;

3990 
intra:

3991 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
3992 
if (s>h263_aic) {

3993 
s>ac_pred = get_bits1(&s>gb); 
3994 
if(s>ac_pred){

3995 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA  MB_TYPE_ACPRED; 
3996 

3997 
s>h263_aic_dir = get_bits1(&s>gb); 
3998 
} 
3999 
}else

4000 
s>ac_pred = 0;

4001 

4002 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

4003 
if(cbpy<0){ 
4004 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

4005 
return 1; 
4006 
} 
4007 
cbp = (cbpc & 3)  (cbpy << 2); 
4008 
if (dquant) {

4009 
h263_decode_dquant(s); 
4010 
} 
4011  
4012 
/* decode each block */

4013 
for (i = 0; i < 6; i++) { 
4014 
if (h263_decode_block(s, block[i], i, cbp&32) < 0) 
4015 
return 1; 
4016 
cbp+=cbp; 
4017 
} 
4018 
} 
4019 
end:

4020  
4021 
/* perMB end of slice check */

4022 
{ 
4023 
int v= show_bits(&s>gb, 16); 
4024 

4025 
if(get_bits_count(&s>gb) + 16 > s>gb.size_in_bits){ 
4026 
v>>= get_bits_count(&s>gb) + 16  s>gb.size_in_bits;

4027 
} 
4028  
4029 
if(v==0) 
4030 
return SLICE_END;

4031 
} 
4032  
4033 
return SLICE_OK;

4034 
} 
4035  
4036 
int ff_mpeg4_decode_mb(MpegEncContext *s,

4037 
DCTELEM block[6][64]) 
4038 
{ 
4039 
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

4040 
int16_t *mot_val; 
4041 
static int8_t quant_tab[4] = { 1, 2, 1, 2 }; 
4042 
const int xy= s>mb_x + s>mb_y * s>mb_stride; 
4043 

4044 
assert(s>h263_pred); 
4045 

4046 
if (s>pict_type == P_TYPE  s>pict_type==S_TYPE) {

4047 
do{

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

4049 
/* skip mb */

4050 
s>mb_intra = 0;

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

4053 
s>mv_dir = MV_DIR_FORWARD; 
4054 
s>mv_type = MV_TYPE_16X16; 
4055 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE){

4056 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_GMC  MB_TYPE_16x16  MB_TYPE_L0; 
4057 
s>mcsel=1;

4058 
s>mv[0][0][0]= get_amv(s, 0); 
4059 
s>mv[0][0][1]= get_amv(s, 1); 
4060  
4061 
s>mb_skiped = 0;

4062 
}else{

4063 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
4064 
s>mcsel=0;

4065 
s>mv[0][0][0] = 0; 
4066 
s>mv[0][0][1] = 0; 
4067 
s>mb_skiped = 1;

4068 
} 
4069 
goto end;

4070 
} 
4071 
cbpc = get_vlc2(&s>gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

4072 
//fprintf(stderr, "\tCBPC: %d", cbpc);

4073 
if (cbpc < 0){ 
4074 
av_log(s>avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

4075 
return 1; 
4076 
} 
4077 
}while(cbpc == 20); 
4078 

4079 
dquant = cbpc & 8;

4080 
s>mb_intra = ((cbpc & 4) != 0); 
4081 
if (s>mb_intra) goto intra; 
4082 

4083 
if(s>pict_type==S_TYPE && s>vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 
4084 
s>mcsel= get_bits1(&s>gb); 
4085 
else s>mcsel= 0; 
4086 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; 
4087 

4088 
cbp = (cbpc & 3)  (cbpy << 2); 
4089 
if (dquant) {

4090 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

4091 
} 
4092 
if((!s>progressive_sequence) && (cbp  (s>workaround_bugs&FF_BUG_XVID_ILACE)))

4093 
s>interlaced_dct= get_bits1(&s>gb); 
4094 

4095 
s>mv_dir = MV_DIR_FORWARD; 
4096 
if ((cbpc & 16) == 0) { 
4097 
if(s>mcsel){

4098 
s>current_picture.mb_type[xy]= MB_TYPE_GMC  MB_TYPE_16x16  MB_TYPE_L0; 
4099 
/* 16x16 global motion prediction */

4100 
s>mv_type = MV_TYPE_16X16; 
4101 
mx= get_amv(s, 0);

4102 
my= get_amv(s, 1);

4103 
s>mv[0][0][0] = mx; 
4104 
s>mv[0][0][1] = my; 
4105 
}else if((!s>progressive_sequence) && get_bits1(&s>gb)){ 
4106 
s>current_picture.mb_type[xy]= MB_TYPE_16x8  MB_TYPE_L0  MB_TYPE_INTERLACED; 
4107 
/* 16x8 field motion prediction */

4108 
s>mv_type= MV_TYPE_FIELD; 
4109  
4110 
s>field_select[0][0]= get_bits1(&s>gb); 
4111 
s>field_select[0][1]= get_bits1(&s>gb); 
4112  
4113 
h263_pred_motion(s, 0, &pred_x, &pred_y);

4114 

4115 
for(i=0; i<2; i++){ 
4116 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4117 
if (mx >= 0xffff) 
4118 
return 1; 
4119 

4120 
my = h263_decode_motion(s, pred_y/2, s>f_code);

4121 
if (my >= 0xffff) 
4122 
return 1; 
4123  
4124 
s>mv[0][i][0] = mx; 
4125 
s>mv[0][i][1] = my; 
4126 
} 
4127 
}else{

4128 
s>current_picture.mb_type[xy]= MB_TYPE_16x16  MB_TYPE_L0; 
4129 
/* 16x16 motion prediction */

4130 
s>mv_type = MV_TYPE_16X16; 
4131 
h263_pred_motion(s, 0, &pred_x, &pred_y);

4132 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4133 

4134 
if (mx >= 0xffff) 
4135 
return 1; 
4136 

4137 
my = h263_decode_motion(s, pred_y, s>f_code); 
4138 

4139 
if (my >= 0xffff) 
4140 
return 1; 
4141 
s>mv[0][0][0] = mx; 
4142 
s>mv[0][0][1] = my; 
4143 
} 
4144 
} else {

4145 
s>current_picture.mb_type[xy]= MB_TYPE_8x8  MB_TYPE_L0; 
4146 
s>mv_type = MV_TYPE_8X8; 
4147 
for(i=0;i<4;i++) { 
4148 
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); 
4149 
mx = h263_decode_motion(s, pred_x, s>f_code); 
4150 
if (mx >= 0xffff) 
4151 
return 1; 
4152 

4153 
my = h263_decode_motion(s, pred_y, s>f_code); 
4154 
if (my >= 0xffff) 
4155 
return 1; 
4156 
s>mv[0][i][0] = mx; 
4157 
s>mv[0][i][1] = my; 
4158 
mot_val[0] = mx;

4159 
mot_val[1] = my;

4160 
} 
4161 
} 
4162 
} else if(s>pict_type==B_TYPE) { 
4163 
int modb1; // first bit of modb 
4164 
int modb2; // second bit of modb 
4165 
int mb_type;

4166  
4167 
s>mb_intra = 0; //Bframes never contain intra blocks 
4168 
s>mcsel=0; // ... true gmc blocks 
4169  
4170 
if(s>mb_x==0){ 
4171 
for(i=0; i<2; i++){ 
4172 
s>last_mv[i][0][0]= 
4173 
s>last_mv[i][0][1]= 
4174 
s>last_mv[i][1][0]= 
4175 
s>last_mv[i][1][1]= 0; 
4176 
} 
4177 
} 
4178  
4179 
/* if we skipped it in the future P Frame than skip it now too */

4180 
s>mb_skiped= s>next_picture.mbskip_table[s>mb_y * s>mb_stride + s>mb_x]; // Note, skiptab=0 if last was GMC

4181  
4182 
if(s>mb_skiped){

4183 
/* skip mb */

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

4186  
4187 
s>mv_dir = MV_DIR_FORWARD; 
4188 
s>mv_type = MV_TYPE_16X16; 
4189 
s>mv[0][0][0] = 0; 
4190 
s>mv[0][0][1] = 0; 
4191 
s>mv[1][0][0] = 0; 
4192 
s>mv[1][0][1] = 0; 
4193 
s>current_picture.mb_type[xy]= MB_TYPE_SKIP  MB_TYPE_16x16  MB_TYPE_L0; 
4194 
goto end;

4195 
} 
4196  
4197 
modb1= get_bits1(&s>gb); 
4198 
if(modb1){

4199 
mb_type= MB_TYPE_DIRECT2  MB_TYPE_SKIP  MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded

4200 
cbp=0;

4201 
}else{

4202 
modb2= get_bits1(&s>gb); 
4203 
mb_type= get_vlc2(&s>gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);

4204 
if(mb_type<0){ 
4205 
av_log(s>avctx, AV_LOG_ERROR, "illegal MB_type\n");

4206 
return 1; 
4207 
} 
4208 
mb_type= mb_type_b_map[ mb_type ]; 
4209 
if(modb2) cbp= 0; 
4210 
else cbp= get_bits(&s>gb, 6); 
4211  
4212 
if ((!IS_DIRECT(mb_type)) && cbp) {

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

4214 
ff_set_qscale(s, s>qscale + get_bits1(&s>gb)*4  2); 
4215 
} 
4216 
} 
4217  
4218 
if(!s>progressive_sequence){

4219 
if(cbp)

4220 
s>interlaced_dct= get_bits1(&s>gb); 
4221  
4222 
if(!IS_DIRECT(mb_type) && get_bits1(&s>gb)){

4223 
mb_type = MB_TYPE_16x8  MB_TYPE_INTERLACED; 
4224 
mb_type &= ~MB_TYPE_16x16; 
4225  
4226 
if(USES_LIST(mb_type, 0)){ 
4227 
s>field_select[0][0]= get_bits1(&s>gb); 
4228 
s>field_select[0][1]= get_bits1(&s>gb); 
4229 
} 
4230 
if(USES_LIST(mb_type, 1)){ 
4231 
s>field_select[1][0]= get_bits1(&s>gb); 
4232 
s>field_select[1][1]= get_bits1(&s>gb); 
4233 
} 
4234 
} 
4235 
} 
4236  
4237 
s>mv_dir = 0;

4238 
if((mb_type & (MB_TYPE_DIRECT2MB_TYPE_INTERLACED)) == 0){ 
4239 
s>mv_type= MV_TYPE_16X16; 
4240  
4241 
if(USES_LIST(mb_type, 0)){ 
4242 
s>mv_dir = MV_DIR_FORWARD; 
4243  
4244 
mx = h263_decode_motion(s, s>last_mv[0][0][0], s>f_code); 
4245 
my = h263_decode_motion(s, s>last_mv[0][0][1], s>f_code); 
4246 
s>last_mv[0][1][0]= s>last_mv[0][0][0]= s>mv[0][0][0] = mx; 
4247 
s>last_mv[0][1][1]= s>last_mv[0][0][1]= s>mv[0][0][1] = my; 
4248 
} 
4249 

4250 
if(USES_LIST(mb_type, 1)){ 
4251 
s>mv_dir = MV_DIR_BACKWARD; 
4252  
4253 
mx = h263_decode_motion(s, s>last_mv[1][0][0], s>b_code); 
4254 
my = h263_decode_motion(s, s>last_mv[1][0][1], s>b_code); 
4255 
s>last_mv[1][1][0]= s>last_mv[1][0][0]= s>mv[1][0][0] = mx; 
4256 
s>last_mv[1][1][1]= s>last_mv[1][0][1]= s>mv[1][0][1] = my; 
4257 
} 
4258 
}else if(!IS_DIRECT(mb_type)){ 
4259 
s>mv_type= MV_TYPE_FIELD; 
4260  
4261 
if(USES_LIST(mb_type, 0)){ 
4262 
s>mv_dir = MV_DIR_FORWARD; 
4263 

4264 
for(i=0; i<2; i++){ 
4265 
mx = h263_decode_motion(s, s>last_mv[0][i][0] , s>f_code); 
4266 
my = h263_decode_motion(s, s>last_mv[0][i][1]/2, s>f_code); 
4267 
s>last_mv[0][i][0]= s>mv[0][i][0] = mx; 
4268 
s>last_mv[0][i][1]= (s>mv[0][i][1] = my)*2; 
4269 
} 
4270 
} 
4271 

4272 
if(USES_LIST(mb_type, 1)){ 
4273 
s>mv_dir = MV_DIR_BACKWARD; 
4274  
4275 
for(i=0; i<2; i++){ 
4276 
mx = h263_decode_motion(s, s>last_mv[1][i][0] , s>b_code); 
4277 
my = h263_decode_motion(s, s>last_mv[1][i][1]/2, s>b_code); 
4278 
s>last_mv[1][i][0]= s>mv[1][i][0] = mx; 
4279 
s>last_mv[1][i][1]= (s>mv[1][i][1] = my)*2; 
4280 
} 
4281 
} 
4282 
} 
4283 
} 
4284 

4285 
if(IS_DIRECT(mb_type)){

4286 
if(IS_SKIP(mb_type))

4287 
mx=my=0;

4288 
else{

4289 
mx = h263_decode_motion(s, 0, 1); 
4290 
my = h263_decode_motion(s, 0, 1); 
4291 
} 
4292 

4293 
s>mv_dir = MV_DIR_FORWARD  MV_DIR_BACKWARD  MV_DIRECT; 
4294 
mb_type = ff_mpeg4_set_direct_mv(s, mx, my); 
4295 
} 
4296 
s>current_picture.mb_type[xy]= mb_type; 
4297 
} else { /* IFrame */ 
4298 
do{

4299 
cbpc = get_vlc2(&s>gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

4300 
if (cbpc < 0){ 
4301 
av_log(s>avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s>mb_x, s>mb_y);

4302 
return 1; 
4303 
} 
4304 
}while(cbpc == 8); 
4305  
4306 
dquant = cbpc & 4;

4307 
s>mb_intra = 1;

4308 
intra:

4309 
s>ac_pred = get_bits1(&s>gb); 
4310 
if(s>ac_pred)

4311 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA  MB_TYPE_ACPRED; 
4312 
else

4313 
s>current_picture.mb_type[xy]= MB_TYPE_INTRA; 
4314 

4315 
cbpy = get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

4316 
if(cbpy<0){ 
4317 
av_log(s>avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s>mb_x, s>mb_y);

4318 
return 1; 
4319 
} 
4320 
cbp = (cbpc & 3)  (cbpy << 2); 
4321 
if (dquant) {

4322 
ff_set_qscale(s, s>qscale + quant_tab[get_bits(&s>gb, 2)]);

4323 
} 
4324 

4325 
if(!s>progressive_sequence)

4326 
s>interlaced_dct= get_bits1(&s>gb); 
4327  
4328 
/* decode each block */

4329 
for (i = 0; i < 6; i++) { 
4330 
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) 
4331 
return 1; 
4332 
cbp+=cbp; 
4333 
} 
4334 
goto end;

4335 
} 
4336  
4337 
/* decode each block */

4338 
for (i = 0; i < 6; i++) { 
4339 
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) 
4340 
return 1; 
4341 
cbp+=cbp; 
4342 
} 
4343 
end:

4344  
4345 
/* perMB end of slice check */

4346 
if(s>codec_id==CODEC_ID_MPEG4){

4347 
if(mpeg4_is_resync(s)){

4348 
const int delta= s>mb_x + 1 == s>mb_width ? 2 : 1; 
4349 
if(s>pict_type==B_TYPE && s>next_picture.mbskip_table[xy + delta])

4350 
return SLICE_OK;

4351 
return SLICE_END;

4352 
} 
4353 
} 
4354  
4355 
return SLICE_OK;

4356 
} 
4357  
4358 
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 
4359 
{ 
4360 
int code, val, sign, shift, l;

4361 
code = get_vlc2(&s>gb, mv_vlc.table, MV_VLC_BITS, 2);

4362  
4363 
if (code == 0) 
4364 
return pred;

4365 
if (code < 0) 
4366 
return 0xffff; 
4367  
4368 
sign = get_bits1(&s>gb); 
4369 
shift = f_code  1;

4370 
val = code; 
4371 
if (shift) {

4372 
val = (val  1) << shift;

4373 
val = get_bits(&s>gb, shift); 
4374 
val++; 
4375 
} 
4376 
if (sign)

4377 
val = val; 
4378 
val += pred; 
4379  
4380 
/* modulo decoding */

4381 
if (!s>h263_long_vectors) {

4382 
l = 1 << (f_code + 4); 
4383 
val = ((val + l)&(l*21))  l; 
4384 
} else {

4385 
/* horrible h263 long vector mode */

4386 
if (pred < 31 && val < 63) 
4387 
val += 64;

4388 
if (pred > 32 && val > 63) 
4389 
val = 64;

4390 

4391 
} 
4392 
return val;

4393 
} 
4394  
4395 
/* Decodes RVLC of H.263+ UMV */

4396 
static int h263p_decode_umotion(MpegEncContext * s, int pred) 
4397 
{ 
4398 
int code = 0, sign; 
4399 

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

4402 

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

4404 

4405 
while (get_bits1(&s>gb))

4406 
{ 
4407 
code <<= 1;

4408 
code += get_bits1(&s>gb); 
4409 
} 
4410 
sign = code & 1;

4411 
code >>= 1;

4412 

4413 
code = (sign) ? (pred  code) : (pred + code); 
4414 
#ifdef DEBUG

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

4416 
#endif

4417 
return code;

4418  
4419 
} 
4420  
4421 
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 
4422 
int n, int coded) 
4423 
{ 
4424 
int code, level, i, j, last, run;

4425 
RLTable *rl = &rl_inter; 
4426 
const uint8_t *scan_table;

4427 
GetBitContext gb= s>gb; 
4428  
4429 
scan_table = s>intra_scantable.permutated; 
4430 
if (s>h263_aic && s>mb_intra) {

4431 
rl = &rl_intra_aic; 
4432 
i = 0;

4433 
if (s>ac_pred) {

4434 
if (s>h263_aic_dir)

4435 
scan_table = s>intra_v_scantable.permutated; /* left */

4436 
else

4437 
scan_table = s>intra_h_scantable.permutated; /* top */

4438 
} 
4439 
} else if (s>mb_intra) { 
4440 
/* DC coef */

4441 
if(s>codec_id == CODEC_ID_RV10){

4442 
if (s>rv10_version == 3 && s>pict_type == I_TYPE) { 
4443 
int component, diff;

4444 
component = (n <= 3 ? 0 : n  4 + 1); 
4445 
level = s>last_dc[component]; 
4446 
if (s>rv10_first_dc_coded[component]) {

4447 
diff = rv_decode_dc(s, n); 
4448 
if (diff == 0xffff) 
4449 
return 1; 
4450 
level += diff; 
4451 
level = level & 0xff; /* handle wrap round */ 
4452 
s>last_dc[component] = level; 
4453 
} else {

4454 
s>rv10_first_dc_coded[component] = 1;

4455 
} 
4456 
} else {

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

4458 
} 
4459 
}else{

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

4461 
if((level&0x7F) == 0){ 
4462 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s>mb_x, s>mb_y);

4463 
if(s>error_resilience >= FF_ER_COMPLIANT)

4464 
return 1; 
4465 
} 
4466 
if (level == 255) 
4467 
level = 128;

4468 
} 
4469 
block[0] = level;

4470 
i = 1;

4471 
} else {

4472 
i = 0;

4473 
} 
4474 
if (!coded) {

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

4476 
goto not_coded;

4477 
s>block_last_index[n] = i  1;

4478 
return 0; 
4479 
} 
4480 
retry:

4481 
for(;;) {

4482 
code = get_vlc2(&s>gb, rl>vlc.table, TEX_VLC_BITS, 2);

4483 
if (code < 0){ 
4484 
av_log(s>avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s>mb_x, s>mb_y);

4485 
return 1; 
4486 
} 
4487 
if (code == rl>n) {

4488 
/* escape */

4489 
if (s>h263_flv > 1) { 
4490 
int is11 = get_bits1(&s>gb);

4491 
last = get_bits1(&s>gb); 
4492 
run = get_bits(&s>gb, 6);

4493 
if(is11){

4494 
level = get_sbits(&s>gb, 11);

4495 
} else {

4496 
level = get_sbits(&s>gb, 7);

4497 
} 
4498 
} else {

4499 
last = get_bits1(&s>gb); 
4500 
run = get_bits(&s>gb, 6);

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

4502 
if(level == 128){ 
4503 
if (s>codec_id == CODEC_ID_RV10) {

4504 
/* XXX: should patch encoder too */

4505 
level = get_sbits(&s>gb, 12);

4506 
}else{

4507 
level = get_bits(&s>gb, 5);

4508 
level = get_sbits(&s>gb, 6)<<5; 
4509 
} 
4510 
} 
4511 
} 
4512 
} else {

4513 
run = rl>table_run[code]; 
4514 
level = rl>table_level[code]; 
4515 
last = code >= rl>last; 
4516 
if (get_bits1(&s>gb))

4517 
level = level; 
4518 
} 
4519 
i += run; 
4520 
if (i >= 64){ 
4521 
if(s>alt_inter_vlc && rl == &rl_inter && !s>mb_intra){

4522 
//looks like a hack but no, its the way its supposed to work ...

4523 
rl = &rl_intra_aic; 
4524 
i = 0;

4525 
s>gb= gb; 
4526 
memset(block, 0, sizeof(DCTELEM)*64); 
4527 
goto retry;

4528 
} 
4529 
av_log(s>avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s>mb_x, s>mb_y);

4530 
return 1; 
4531 
} 
4532 
j = scan_table[i]; 
4533 
block[j] = level; 
4534 
if (last)

4535 
break;

4536 
i++; 
4537 
} 
4538 
not_coded:

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

4540 
h263_pred_acdc(s, block, n); 
4541 
i = 63;

4542 
} 
4543 
s>block_last_index[n] = i; 
4544 
return 0; 
4545 
} 
4546  
4547 
/**

4548 
* decodes the dc value.

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

4550 
* @param dir_ptr the prediction direction will be stored here

4551 
* @return the quantized dc

4552 
*/

4553 
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
4554 
{ 
4555 
int level, pred, code;

4556 
uint16_t *dc_val; 
4557  
4558 
if (n < 4) 
4559 
code = get_vlc2(&s>gb, dc_lum.table, DC_VLC_BITS, 1);

4560 
else

4561 
code = get_vlc2(&s>gb, dc_chrom.table, DC_VLC_BITS, 1);

4562 
if (code < 0  code > 9 /* && s>nbit<9 */){ 
4563 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc vlc\n");

4564 
return 1; 
4565 
} 
4566 
if (code == 0) { 
4567 
level = 0;

4568 
} else {

4569 
if(IS_3IV1){

4570 
if(code==1) 
4571 
level= 2*get_bits1(&s>gb)1; 
4572 
else{

4573 
if(get_bits1(&s>gb))

4574 
level = get_bits(&s>gb, code1) + (1<<(code1)); 
4575 
else

4576 
level = get_bits(&s>gb, code1)  (1<<(code1)); 
4577 
} 
4578 
}else{

4579 
level = get_xbits(&s>gb, code); 
4580 
} 
4581  
4582 
if (code > 8){ 
4583 
if(get_bits1(&s>gb)==0){ /* marker */ 
4584 
if(s>error_resilience>=2){ 
4585 
av_log(s>avctx, AV_LOG_ERROR, "dc marker bit missing\n");

4586 
return 1; 
4587 
} 
4588 
} 
4589 
} 
4590 
} 
4591 
pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
4592 
level += pred; 
4593 
if (level < 0){ 
4594 
if(s>error_resilience>=3){ 
4595 
av_log(s>avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s>mb_x, s>mb_y);

4596 
return 1; 
4597 
} 
4598 
level = 0;

4599 
} 
4600 
if (n < 4) { 
4601 
*dc_val = level * s>y_dc_scale; 
4602 
} else {

4603 
*dc_val = level * s>c_dc_scale; 
4604 
} 
4605 
if(IS_3IV1)

4606 
*dc_val = level * 8;

4607 

4608 
if(s>error_resilience>=3){ 
4609 
if(*dc_val > 2048 + s>y_dc_scale + s>c_dc_scale){ 
4610 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s>mb_x, s>mb_y);

4611 
return 1; 
4612 
} 
4613 
} 
4614 
return level;

4615 
} 
4616  
4617 
/**

4618 
* decodes a block.

4619 
* @return <0 if an error occured

4620 
*/

4621 
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
4622 
int n, int coded, int intra, int rvlc) 
4623 
{ 
4624 
int level, i, last, run;

4625 
int dc_pred_dir;

4626 
RLTable * rl; 
4627 
RL_VLC_ELEM * rl_vlc; 
4628 
const uint8_t * scan_table;

4629 
int qmul, qadd;

4630  
4631 
//Note intra & rvlc should be optimized away if this is inlined

4632 

4633 
if(intra) {

4634 
if(s>qscale < s>intra_dc_threshold){

4635 
/* DC coef */

4636 
if(s>partitioned_frame){

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

4638 
if(n<4) level= FASTDIV((level + (s>y_dc_scale>>1)), s>y_dc_scale); 
4639 
else level= FASTDIV((level + (s>c_dc_scale>>1)), s>c_dc_scale); 
4640 
dc_pred_dir= (s>pred_dir_table[s>mb_x + s>mb_y*s>mb_stride]<<n)&32;

4641 
}else{

4642 
level = mpeg4_decode_dc(s, n, &dc_pred_dir); 
4643 
if (level < 0) 
4644 
return 1; 
4645 
} 
4646 
block[0] = level;

4647 
i = 0;

4648 
}else{

4649 
i = 1;

4650 
} 
4651 
if (!coded)

4652 
goto not_coded;

4653 

4654 
if(rvlc){

4655 
rl = &rvlc_rl_intra; 
4656 
rl_vlc = rvlc_rl_intra.rl_vlc[0];

4657 
}else{

4658 
rl = &rl_intra; 
4659 
rl_vlc = rl_intra.rl_vlc[0];

4660 
} 
4661 
if (s>ac_pred) {

4662 
if (dc_pred_dir == 0) 
4663 
scan_table = s>intra_v_scantable.permutated; /* left */

4664 
else

4665 
scan_table = s>intra_h_scantable.permutated; /* top */

4666 
} else {

4667 
scan_table = s>intra_scantable.permutated; 
4668 
} 
4669 
qmul=1;

4670 
qadd=0;

4671 
} else {

4672 
i = 1;

4673 
if (!coded) {

4674 
s>block_last_index[n] = i; 
4675 
return 0; 
4676 
} 
4677 
if(rvlc) rl = &rvlc_rl_inter;

4678 
else rl = &rl_inter;

4679 

4680 
scan_table = s>intra_scantable.permutated; 
4681  
4682 
if(s>mpeg_quant){

4683 
qmul=1;

4684 
qadd=0;

4685 
if(rvlc){

4686 
rl_vlc = rvlc_rl_inter.rl_vlc[0];

4687 
}else{

4688 
rl_vlc = rl_inter.rl_vlc[0];

4689 
} 
4690 
}else{

4691 
qmul = s>qscale << 1;

4692 
qadd = (s>qscale  1)  1; 
4693 
if(rvlc){

4694 
rl_vlc = rvlc_rl_inter.rl_vlc[s>qscale]; 
4695 
}else{

4696 
rl_vlc = rl_inter.rl_vlc[s>qscale]; 
4697 
} 
4698 
} 
4699 
} 
4700 
{ 
4701 
OPEN_READER(re, &s>gb); 
4702 
for(;;) {

4703 
UPDATE_CACHE(re, &s>gb); 
4704 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2);

4705 
if (level==0) { 
4706 
/* escape */

4707 
if(rvlc){

4708 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4709 
av_log(s>avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");

4710 
return 1; 
4711 
}; SKIP_CACHE(re, &s>gb, 1);

4712 

4713 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
4714 
run= SHOW_UBITS(re, &s>gb, 6); LAST_SKIP_CACHE(re, &s>gb, 6); 
4715 
SKIP_COUNTER(re, &s>gb, 1+1+6); 
4716 
UPDATE_CACHE(re, &s>gb); 
4717 

4718 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4719 
av_log(s>avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");

4720 
return 1; 
4721 
}; SKIP_CACHE(re, &s>gb, 1);

4722 

4723 
level= SHOW_UBITS(re, &s>gb, 11); SKIP_CACHE(re, &s>gb, 11); 
4724 

4725 
if(SHOW_UBITS(re, &s>gb, 5)!=0x10){ 
4726 
av_log(s>avctx, AV_LOG_ERROR, "reverse esc missing\n");

4727 
return 1; 
4728 
}; SKIP_CACHE(re, &s>gb, 5);

4729  
4730 
level= level * qmul + qadd; 
4731 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); LAST_SKIP_CACHE(re, &s>gb, 1); 
4732 
SKIP_COUNTER(re, &s>gb, 1+11+5+1); 
4733  
4734 
i+= run + 1;

4735 
if(last) i+=192; 
4736 
}else{

4737 
int cache;

4738 
cache= GET_CACHE(re, &s>gb); 
4739  
4740 
if(IS_3IV1)

4741 
cache ^= 0xC0000000;

4742  
4743 
if (cache&0x80000000) { 
4744 
if (cache&0x40000000) { 
4745 
/* third escape */

4746 
SKIP_CACHE(re, &s>gb, 2);

4747 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
4748 
run= SHOW_UBITS(re, &s>gb, 6); LAST_SKIP_CACHE(re, &s>gb, 6); 
4749 
SKIP_COUNTER(re, &s>gb, 2+1+6); 
4750 
UPDATE_CACHE(re, &s>gb); 
4751  
4752 
if(IS_3IV1){

4753 
level= SHOW_SBITS(re, &s>gb, 12); LAST_SKIP_BITS(re, &s>gb, 12); 
4754 
}else{

4755 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4756 
av_log(s>avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");

4757 
return 1; 
4758 
}; SKIP_CACHE(re, &s>gb, 1);

4759  
4760 
level= SHOW_SBITS(re, &s>gb, 12); SKIP_CACHE(re, &s>gb, 12); 
4761  
4762 
if(SHOW_UBITS(re, &s>gb, 1)==0){ 
4763 
av_log(s>avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");

4764 
return 1; 
4765 
}; LAST_SKIP_CACHE(re, &s>gb, 1);

4766  
4767 
SKIP_COUNTER(re, &s>gb, 1+12+1); 
4768 
} 
4769 

4770 
if(level*s>qscale>1024  level*s>qscale<1024){ 
4771 
av_log(s>avctx, AV_LOG_ERROR, "level overflow in 3. esc, qp=%d\n", s>qscale);

4772 
return 1; 
4773 
} 
4774 
#if 0

4775 
if(s>error_resilience >= FF_ER_COMPLIANT){
