ffmpeg / libavcodec / ituh263enc.c @ 2912e87a
History  View  Annotate  Download (26.5 KB)
1 
/*


2 
* ITU H263 bitstream encoder

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 file is part of Libav.

9 
*

10 
* Libav is free software; you can redistribute it and/or

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

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

13 
* version 2.1 of the License, or (at your option) any later version.

14 
*

15 
* Libav is distributed in the hope that it will be useful,

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

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

18 
* Lesser General Public License for more details.

19 
*

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

21 
* License along with Libav; if not, write to the Free Software

22 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

23 
*/

24  
25 
/**

26 
* @file

27 
* h263 bitstream encoder.

28 
*/

29  
30 
//#define DEBUG

31 
#include <limits.h> 
32  
33 
#include "dsputil.h" 
34 
#include "avcodec.h" 
35 
#include "mpegvideo.h" 
36 
#include "h263.h" 
37 
#include "mathops.h" 
38 
#include "unary.h" 
39 
#include "flv.h" 
40 
#include "mpeg4video.h" 
41 
#include "internal.h" 
42  
43 
//#undef NDEBUG

44 
//#include <assert.h>

45  
46 
/**

47 
* Table of number of bits a motion vector component needs.

48 
*/

49 
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 
50  
51 
/**

52 
* Minimal fcode that a motion vector component would need.

53 
*/

54 
static uint8_t fcode_tab[MAX_MV*2+1]; 
55  
56 
/**

57 
* Minimal fcode that a motion vector component would need in umv.

58 
* All entries in this table are 1.

59 
*/

60 
static uint8_t umv_fcode_tab[MAX_MV*2+1]; 
61  
62 
//unified encoding tables for run length encoding of coefficients

63 
//unified in the sense that the specification specifies the encoding in several steps.

64 
static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; 
65 
static uint8_t uni_h263_inter_rl_len [64*64*2*2]; 
66 
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))

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

68 
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) 
69  
70 
static const uint8_t wrong_run[102] = { 
71 
1, 2, 3, 5, 4, 10, 9, 8, 
72 
11, 15, 17, 16, 23, 22, 21, 20, 
73 
19, 18, 25, 24, 27, 26, 11, 7, 
74 
6, 1, 2, 13, 2, 2, 2, 2, 
75 
6, 12, 3, 9, 1, 3, 4, 3, 
76 
7, 4, 1, 1, 5, 5, 14, 6, 
77 
1, 7, 1, 8, 1, 1, 1, 1, 
78 
10, 1, 1, 5, 9, 17, 25, 24, 
79 
29, 33, 32, 41, 2, 23, 28, 31, 
80 
3, 22, 30, 4, 27, 40, 8, 26, 
81 
6, 39, 7, 38, 16, 37, 15, 10, 
82 
11, 12, 13, 14, 1, 21, 20, 18, 
83 
19, 2, 1, 34, 35, 36 
84 
}; 
85  
86 
/**

87 
* Return the 4 bit value that specifies the given aspect ratio.

88 
* This may be one of the standard aspect ratios or it specifies

89 
* that the aspect will be stored explicitly later.

90 
*/

91 
av_const int ff_h263_aspect_to_info(AVRational aspect){

92 
int i;

93  
94 
if(aspect.num==0) aspect= (AVRational){1,1}; 
95  
96 
for(i=1; i<6; i++){ 
97 
if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){ 
98 
return i;

99 
} 
100 
} 
101  
102 
return FF_ASPECT_EXTENDED;

103 
} 
104  
105 
void h263_encode_picture_header(MpegEncContext * s, int picture_number) 
106 
{ 
107 
int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;

108 
int best_clock_code=1; 
109 
int best_divisor=60; 
110 
int best_error= INT_MAX;

111  
112 
if(s>h263_plus){

113 
for(i=0; i<2; i++){ 
114 
int div, error;

115 
div= (s>avctx>time_base.num*1800000LL + 500LL*s>avctx>time_base.den) / ((1000LL+i)*s>avctx>time_base.den); 
116 
div= av_clip(div, 1, 127); 
117 
error= FFABS(s>avctx>time_base.num*1800000LL  (1000LL+i)*s>avctx>time_base.den*div); 
118 
if(error < best_error){

119 
best_error= error; 
120 
best_divisor= div; 
121 
best_clock_code= i; 
122 
} 
123 
} 
124 
} 
125 
s>custom_pcf= best_clock_code!=1  best_divisor!=60; 
126 
coded_frame_rate= 1800000;

127 
coded_frame_rate_base= (1000+best_clock_code)*best_divisor;

128  
129 
align_put_bits(&s>pb); 
130  
131 
/* Update the pointer to last GOB */

132 
s>ptr_lastgob = put_bits_ptr(&s>pb); 
133 
put_bits(&s>pb, 22, 0x20); /* PSC */ 
134 
temp_ref= s>picture_number * (int64_t)coded_frame_rate * s>avctx>time_base.num / //FIXME use timestamp

135 
(coded_frame_rate_base * (int64_t)s>avctx>time_base.den); 
136 
put_sbits(&s>pb, 8, temp_ref); /* TemporalReference */ 
137  
138 
put_bits(&s>pb, 1, 1); /* marker */ 
139 
put_bits(&s>pb, 1, 0); /* h263 id */ 
140 
put_bits(&s>pb, 1, 0); /* split screen off */ 
141 
put_bits(&s>pb, 1, 0); /* camera off */ 
142 
put_bits(&s>pb, 1, 0); /* freeze picture release off */ 
143  
144 
format = ff_match_2uint16(h263_format, FF_ARRAY_ELEMS(h263_format), s>width, s>height); 
145 
if (!s>h263_plus) {

146 
/* H.263v1 */

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

148 
put_bits(&s>pb, 1, (s>pict_type == FF_P_TYPE));

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

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

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

152 
put_bits(&s>pb, 1, 0); /* Unrestricted Motion Vector: off */ 
153 
put_bits(&s>pb, 1, 0); /* SAC: off */ 
154 
put_bits(&s>pb, 1, s>obmc); /* Advanced Prediction */ 
155 
put_bits(&s>pb, 1, 0); /* only I/P frames, no PB frame */ 
156 
put_bits(&s>pb, 5, s>qscale);

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

159 
int ufep=1; 
160 
/* H.263v2 */

161 
/* H.263 Plus PTYPE */

162  
163 
put_bits(&s>pb, 3, 7); 
164 
put_bits(&s>pb,3,ufep); /* Update Full Extended PTYPE */ 
165 
if (format == 8) 
166 
put_bits(&s>pb,3,6); /* Custom Source Format */ 
167 
else

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

169  
170 
put_bits(&s>pb,1, s>custom_pcf);

171 
put_bits(&s>pb,1, s>umvplus); /* Unrestricted Motion Vector */ 
172 
put_bits(&s>pb,1,0); /* SAC: off */ 
173 
put_bits(&s>pb,1,s>obmc); /* Advanced Prediction Mode */ 
174 
put_bits(&s>pb,1,s>h263_aic); /* Advanced Intra Coding */ 
175 
put_bits(&s>pb,1,s>loop_filter); /* Deblocking Filter */ 
176 
put_bits(&s>pb,1,s>h263_slice_structured); /* Slice Structured */ 
177 
put_bits(&s>pb,1,0); /* Reference Picture Selection: off */ 
178 
put_bits(&s>pb,1,0); /* Independent Segment Decoding: off */ 
179 
put_bits(&s>pb,1,s>alt_inter_vlc); /* Alternative Inter VLC */ 
180 
put_bits(&s>pb,1,s>modified_quant); /* Modified Quantization: */ 
181 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
182 
put_bits(&s>pb,3,0); /* Reserved */ 
183  
184 
put_bits(&s>pb, 3, s>pict_type == FF_P_TYPE);

185  
186 
put_bits(&s>pb,1,0); /* Reference Picture Resampling: off */ 
187 
put_bits(&s>pb,1,0); /* ReducedResolution Update: off */ 
188 
put_bits(&s>pb,1,s>no_rounding); /* Rounding Type */ 
189 
put_bits(&s>pb,2,0); /* Reserved */ 
190 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
191  
192 
/* This should be here if PLUSPTYPE */

193 
put_bits(&s>pb, 1, 0); /* Continuous Presence Multipoint mode: off */ 
194  
195 
if (format == 8) { 
196 
/* Custom Picture Format (CPFMT) */

197 
s>aspect_ratio_info= ff_h263_aspect_to_info(s>avctx>sample_aspect_ratio); 
198  
199 
put_bits(&s>pb,4,s>aspect_ratio_info);

200 
put_bits(&s>pb,9,(s>width >> 2)  1); 
201 
put_bits(&s>pb,1,1); /* "1" to prevent start code emulation */ 
202 
put_bits(&s>pb,9,(s>height >> 2)); 
203 
if (s>aspect_ratio_info == FF_ASPECT_EXTENDED){

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

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

206 
} 
207 
} 
208 
if(s>custom_pcf){

209 
if(ufep){

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

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

212 
} 
213 
put_sbits(&s>pb, 2, temp_ref>>8); 
214 
} 
215  
216 
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

217 
if (s>umvplus)

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

219 
//FIXME check actual requested range

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

222 
put_bits(&s>pb,2,0); /* no weird submodes */ 
223  
224 
put_bits(&s>pb, 5, s>qscale);

225 
} 
226  
227 
put_bits(&s>pb, 1, 0); /* no PEI */ 
228  
229 
if(s>h263_slice_structured){

230 
put_bits(&s>pb, 1, 1); 
231  
232 
assert(s>mb_x == 0 && s>mb_y == 0); 
233 
ff_h263_encode_mba(s); 
234  
235 
put_bits(&s>pb, 1, 1); 
236 
} 
237  
238 
if(s>h263_aic){

239 
s>y_dc_scale_table= 
240 
s>c_dc_scale_table= ff_aic_dc_scale_table; 
241 
}else{

242 
s>y_dc_scale_table= 
243 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
244 
} 
245 
} 
246  
247 
/**

248 
* Encode a group of blocks header.

249 
*/

250 
void h263_encode_gob_header(MpegEncContext * s, int mb_line) 
251 
{ 
252 
put_bits(&s>pb, 17, 1); /* GBSC */ 
253  
254 
if(s>h263_slice_structured){

255 
put_bits(&s>pb, 1, 1); 
256  
257 
ff_h263_encode_mba(s); 
258  
259 
if(s>mb_num > 1583) 
260 
put_bits(&s>pb, 1, 1); 
261 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
262 
put_bits(&s>pb, 1, 1); 
263 
put_bits(&s>pb, 2, s>pict_type == FF_I_TYPE); /* GFID */ 
264 
}else{

265 
int gob_number= mb_line / s>gob_index;

266  
267 
put_bits(&s>pb, 5, gob_number); /* GN */ 
268 
put_bits(&s>pb, 2, s>pict_type == FF_I_TYPE); /* GFID */ 
269 
put_bits(&s>pb, 5, s>qscale); /* GQUANT */ 
270 
} 
271 
} 
272  
273 
/**

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

275 
*/

276 
void ff_clean_h263_qscales(MpegEncContext *s){

277 
int i;

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

279  
280 
ff_init_qscale_tab(s); 
281  
282 
for(i=1; i<s>mb_num; i++){ 
283 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i1] ] >2) 
284 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i1] ]+2; 
285 
} 
286 
for(i=s>mb_num2; i>=0; i){ 
287 
if(qscale_table[ s>mb_index2xy[i] ]  qscale_table[ s>mb_index2xy[i+1] ] >2) 
288 
qscale_table[ s>mb_index2xy[i] ]= qscale_table[ s>mb_index2xy[i+1] ]+2; 
289 
} 
290  
291 
if(s>codec_id != CODEC_ID_H263P){

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

294  
295 
if(qscale_table[mb_xy] != qscale_table[s>mb_index2xy[i1]] && (s>mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ 
296 
s>mb_type[mb_xy]= CANDIDATE_MB_TYPE_INTER; 
297 
} 
298 
} 
299 
} 
300 
} 
301  
302 
static const int dquant_code[5]= {1,0,9,2,3}; 
303  
304 
/**

305 
* encodes a 8x8 block.

306 
* @param block the 8x8 block

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

308 
*/

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

312 
RLTable *rl; 
313  
314 
rl = &ff_h263_rl_inter; 
315 
if (s>mb_intra && !s>h263_aic) {

316 
/* DC coef */

317 
level = block[0];

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

319 
if (level > 254) { 
320 
level = 254;

321 
block[0] = 254; 
322 
} 
323 
/* 0 cannot be represented also */

324 
else if (level < 1) { 
325 
level = 1;

326 
block[0] = 1; 
327 
} 
328 
if (level == 128) //FIXME check rv10 
329 
put_bits(&s>pb, 8, 0xff); 
330 
else

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

332 
i = 1;

333 
} else {

334 
i = 0;

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

336 
rl = &rl_intra_aic; 
337  
338 
if(s>alt_inter_vlc && !s>mb_intra){

339 
int aic_vlc_bits=0; 
340 
int inter_vlc_bits=0; 
341 
int wrong_pos=1; 
342 
int aic_code;

343  
344 
last_index = s>block_last_index[n]; 
345 
last_non_zero = i  1;

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

347 
j = s>intra_scantable.permutated[i]; 
348 
level = block[j]; 
349 
if (level) {

350 
run = i  last_non_zero  1;

351 
last = (i == last_index); 
352  
353 
if(level<0) level= level; 
354  
355 
code = get_rl_index(rl, last, run, level); 
356 
aic_code = get_rl_index(&rl_intra_aic, last, run, level); 
357 
inter_vlc_bits += rl>table_vlc[code][1]+1; 
358 
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; 
359  
360 
if (code == rl>n) {

361 
inter_vlc_bits += 1+6+81; 
362 
} 
363 
if (aic_code == rl_intra_aic.n) {

364 
aic_vlc_bits += 1+6+81; 
365 
wrong_pos += run + 1;

366 
}else

367 
wrong_pos += wrong_run[aic_code]; 
368 
last_non_zero = i; 
369 
} 
370 
} 
371 
i = 0;

372 
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) 
373 
rl = &rl_intra_aic; 
374 
} 
375 
} 
376  
377 
/* AC coefs */

378 
last_index = s>block_last_index[n]; 
379 
last_non_zero = i  1;

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

381 
j = s>intra_scantable.permutated[i]; 
382 
level = block[j]; 
383 
if (level) {

384 
run = i  last_non_zero  1;

385 
last = (i == last_index); 
386 
sign = 0;

387 
slevel = level; 
388 
if (level < 0) { 
389 
sign = 1;

390 
level = level; 
391 
} 
392 
code = get_rl_index(rl, last, run, level); 
393 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
394 
if (code == rl>n) {

395 
if(!CONFIG_FLV_ENCODER  s>h263_flv <= 1){ 
396 
put_bits(&s>pb, 1, last);

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

398  
399 
assert(slevel != 0);

400  
401 
if(level < 128) 
402 
put_sbits(&s>pb, 8, slevel);

403 
else{

404 
put_bits(&s>pb, 8, 128); 
405 
put_sbits(&s>pb, 5, slevel);

406 
put_sbits(&s>pb, 6, slevel>>5); 
407 
} 
408 
}else{

409 
ff_flv2_encode_ac_esc(&s>pb, slevel, level, run, last); 
410 
} 
411 
} else {

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

413 
} 
414 
last_non_zero = i; 
415 
} 
416 
} 
417 
} 
418  
419 
/* Encode MV differences on H.263+ with Unrestricted MV mode */

420 
static void h263p_encode_umotion(MpegEncContext * s, int val) 
421 
{ 
422 
short sval = 0; 
423 
short i = 0; 
424 
short n_bits = 0; 
425 
short temp_val;

426 
int code = 0; 
427 
int tcode;

428  
429 
if ( val == 0) 
430 
put_bits(&s>pb, 1, 1); 
431 
else if (val == 1) 
432 
put_bits(&s>pb, 3, 0); 
433 
else if (val == 1) 
434 
put_bits(&s>pb, 3, 2); 
435 
else {

436  
437 
sval = ((val < 0) ? (short)(val):(short)val); 
438 
temp_val = sval; 
439  
440 
while (temp_val != 0) { 
441 
temp_val = temp_val >> 1;

442 
n_bits++; 
443 
} 
444  
445 
i = n_bits  1;

446 
while (i > 0) { 
447 
tcode = (sval & (1 << (i1))) >> (i1); 
448 
tcode = (tcode << 1)  1; 
449 
code = (code << 2)  tcode;

450 
i; 
451 
} 
452 
code = ((code << 1)  (val < 0)) << 1; 
453 
put_bits(&s>pb, (2*n_bits)+1, code); 
454 
} 
455 
} 
456  
457 
void h263_encode_mb(MpegEncContext * s,

458 
DCTELEM block[6][64], 
459 
int motion_x, int motion_y) 
460 
{ 
461 
int cbpc, cbpy, i, cbp, pred_x, pred_y;

462 
int16_t pred_dc; 
463 
int16_t rec_intradc[6];

464 
int16_t *dc_ptr[6];

465 
const int interleaved_stats= (s>flags&CODEC_FLAG_PASS1); 
466  
467 
if (!s>mb_intra) {

468 
/* compute cbp */

469 
cbp= get_p_cbp(s, block, motion_x, motion_y); 
470  
471 
if ((cbp  motion_x  motion_y  s>dquant  (s>mv_type  MV_TYPE_16X16)) == 0) { 
472 
/* skip macroblock */

473 
put_bits(&s>pb, 1, 1); 
474 
if(interleaved_stats){

475 
s>misc_bits++; 
476 
s>last_bits++; 
477 
} 
478 
s>skip_count++; 
479  
480 
return;

481 
} 
482 
put_bits(&s>pb, 1, 0); /* mb coded */ 
483  
484 
cbpc = cbp & 3;

485 
cbpy = cbp >> 2;

486 
if(s>alt_inter_vlc==0  cbpc!=3) 
487 
cbpy ^= 0xF;

488 
if(s>dquant) cbpc+= 8; 
489 
if(s>mv_type==MV_TYPE_16X16){

490 
put_bits(&s>pb, 
491 
ff_h263_inter_MCBPC_bits[cbpc], 
492 
ff_h263_inter_MCBPC_code[cbpc]); 
493  
494 
put_bits(&s>pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); 
495 
if(s>dquant)

496 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
497  
498 
if(interleaved_stats){

499 
s>misc_bits+= get_bits_diff(s); 
500 
} 
501  
502 
/* motion vectors: 16x16 mode */

503 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
504  
505 
if (!s>umvplus) {

506 
ff_h263_encode_motion_vector(s, motion_x  pred_x, 
507 
motion_y  pred_y, 1);

508 
} 
509 
else {

510 
h263p_encode_umotion(s, motion_x  pred_x); 
511 
h263p_encode_umotion(s, motion_y  pred_y); 
512 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
513 
/* To prevent Start Code emulation */

514 
put_bits(&s>pb,1,1); 
515 
} 
516 
}else{

517 
put_bits(&s>pb, 
518 
ff_h263_inter_MCBPC_bits[cbpc+16],

519 
ff_h263_inter_MCBPC_code[cbpc+16]);

520 
put_bits(&s>pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); 
521 
if(s>dquant)

522 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
523  
524 
if(interleaved_stats){

525 
s>misc_bits+= get_bits_diff(s); 
526 
} 
527  
528 
for(i=0; i<4; i++){ 
529 
/* motion vectors: 8x8 mode*/

530 
h263_pred_motion(s, i, 0, &pred_x, &pred_y);

531  
532 
motion_x= s>current_picture.motion_val[0][ s>block_index[i] ][0]; 
533 
motion_y= s>current_picture.motion_val[0][ s>block_index[i] ][1]; 
534 
if (!s>umvplus) {

535 
ff_h263_encode_motion_vector(s, motion_x  pred_x, 
536 
motion_y  pred_y, 1);

537 
} 
538 
else {

539 
h263p_encode_umotion(s, motion_x  pred_x); 
540 
h263p_encode_umotion(s, motion_y  pred_y); 
541 
if (((motion_x  pred_x) == 1) && ((motion_y  pred_y) == 1)) 
542 
/* To prevent Start Code emulation */

543 
put_bits(&s>pb,1,1); 
544 
} 
545 
} 
546 
} 
547  
548 
if(interleaved_stats){

549 
s>mv_bits+= get_bits_diff(s); 
550 
} 
551 
} else {

552 
assert(s>mb_intra); 
553  
554 
cbp = 0;

555 
if (s>h263_aic) {

556 
/* Predict DC */

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

559 
int scale;

560  
561 
if(i<4) scale= s>y_dc_scale; 
562 
else scale= s>c_dc_scale;

563  
564 
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); 
565 
level = pred_dc; 
566 
/* Quant */

567 
if (level >= 0) 
568 
level = (level + (scale>>1))/scale;

569 
else

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

571  
572 
/* AIC can change CBP */

573 
if (level == 0 && s>block_last_index[i] == 0) 
574 
s>block_last_index[i] = 1;

575  
576 
if(!s>modified_quant){

577 
if (level < 127) 
578 
level = 127;

579 
else if (level > 127) 
580 
level = 127;

581 
} 
582  
583 
block[i][0] = level;

584 
/* Reconstruction */

585 
rec_intradc[i] = scale*level + pred_dc; 
586 
/* Oddify */

587 
rec_intradc[i] = 1;

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

589 
// rec_intradc[i]++;

590 
/* Clipping */

591 
if (rec_intradc[i] < 0) 
592 
rec_intradc[i] = 0;

593 
else if (rec_intradc[i] > 2047) 
594 
rec_intradc[i] = 2047;

595  
596 
/* Update AC/DC tables */

597 
*dc_ptr[i] = rec_intradc[i]; 
598 
if (s>block_last_index[i] >= 0) 
599 
cbp = 1 << (5  i); 
600 
} 
601 
}else{

602 
for(i=0; i<6; i++) { 
603 
/* compute cbp */

604 
if (s>block_last_index[i] >= 1) 
605 
cbp = 1 << (5  i); 
606 
} 
607 
} 
608  
609 
cbpc = cbp & 3;

610 
if (s>pict_type == FF_I_TYPE) {

611 
if(s>dquant) cbpc+=4; 
612 
put_bits(&s>pb, 
613 
ff_h263_intra_MCBPC_bits[cbpc], 
614 
ff_h263_intra_MCBPC_code[cbpc]); 
615 
} else {

616 
if(s>dquant) cbpc+=8; 
617 
put_bits(&s>pb, 1, 0); /* mb coded */ 
618 
put_bits(&s>pb, 
619 
ff_h263_inter_MCBPC_bits[cbpc + 4],

620 
ff_h263_inter_MCBPC_code[cbpc + 4]);

621 
} 
622 
if (s>h263_aic) {

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

624 
put_bits(&s>pb, 1, 0); /* no AC prediction */ 
625 
} 
626 
cbpy = cbp >> 2;

627 
put_bits(&s>pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); 
628 
if(s>dquant)

629 
put_bits(&s>pb, 2, dquant_code[s>dquant+2]); 
630  
631 
if(interleaved_stats){

632 
s>misc_bits+= get_bits_diff(s); 
633 
} 
634 
} 
635  
636 
for(i=0; i<6; i++) { 
637 
/* encode each block */

638 
h263_encode_block(s, block[i], i); 
639  
640 
/* Update INTRADC for decoding */

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

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

643  
644 
} 
645 
} 
646  
647 
if(interleaved_stats){

648 
if (!s>mb_intra) {

649 
s>p_tex_bits+= get_bits_diff(s); 
650 
s>f_count++; 
651 
}else{

652 
s>i_tex_bits+= get_bits_diff(s); 
653 
s>i_count++; 
654 
} 
655 
} 
656 
} 
657  
658 
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) 
659 
{ 
660 
int range, l, bit_size, sign, code, bits;

661  
662 
if (val == 0) { 
663 
/* zero vector */

664 
code = 0;

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

667 
bit_size = f_code  1;

668 
range = 1 << bit_size;

669 
/* modulo encoding */

670 
l= INT_BIT  6  bit_size;

671 
val = (val<<l)>>l; 
672 
sign = val>>31;

673 
val= (val^sign)sign; 
674 
sign&=1;

675  
676 
val; 
677 
code = (val >> bit_size) + 1;

678 
bits = val & (range  1);

679  
680 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
681 
if (bit_size > 0) { 
682 
put_bits(&s>pb, bit_size, bits); 
683 
} 
684 
} 
685 
} 
686  
687 
static void init_mv_penalty_and_fcode(MpegEncContext *s) 
688 
{ 
689 
int f_code;

690 
int mv;

691  
692 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
693 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

694 
int len;

695  
696 
if(mv==0) len= mvtab[0][1]; 
697 
else{

698 
int val, bit_size, code;

699  
700 
bit_size = f_code  1;

701  
702 
val=mv; 
703 
if (val < 0) 
704 
val = val; 
705 
val; 
706 
code = (val >> bit_size) + 1;

707 
if(code<33){ 
708 
len= mvtab[code][1] + 1 + bit_size; 
709 
}else{

710 
len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; 
711 
} 
712 
} 
713  
714 
mv_penalty[f_code][mv+MAX_MV]= len; 
715 
} 
716 
} 
717  
718 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
719 
for(mv=(16<<f_code); mv<(16<<f_code); mv++){ 
720 
fcode_tab[mv+MAX_MV]= f_code; 
721 
} 
722 
} 
723  
724 
for(mv=0; mv<MAX_MV*2+1; mv++){ 
725 
umv_fcode_tab[mv]= 1;

726 
} 
727 
} 
728  
729 
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ 
730 
int slevel, run, last;

731  
732 
assert(MAX_LEVEL >= 64);

733 
assert(MAX_RUN >= 63);

734  
735 
for(slevel=64; slevel<64; slevel++){ 
736 
if(slevel==0) continue; 
737 
for(run=0; run<64; run++){ 
738 
for(last=0; last<=1; last++){ 
739 
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); 
740 
int level= slevel < 0 ? slevel : slevel; 
741 
int sign= slevel < 0 ? 1 : 0; 
742 
int bits, len, code;

743  
744 
len_tab[index]= 100;

745  
746 
/* ESC0 */

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

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

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

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

753 
if(bits_tab) bits_tab[index]= bits;

754 
len_tab [index]= len; 
755 
} 
756 
/* ESC */

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

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

759 
bits=bits*2+last; len++;

760 
bits=bits*64+run; len+=6; 
761 
bits=bits*256+(level&0xff); len+=8; 
762  
763 
if(len < len_tab[index]){

764 
if(bits_tab) bits_tab[index]= bits;

765 
len_tab [index]= len; 
766 
} 
767 
} 
768 
} 
769 
} 
770 
} 
771  
772 
void h263_encode_init(MpegEncContext *s)

773 
{ 
774 
static int done = 0; 
775  
776 
if (!done) {

777 
done = 1;

778  
779 
init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);

780 
init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);

781  
782 
init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);

783 
init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);

784  
785 
init_mv_penalty_and_fcode(s); 
786 
} 
787 
s>me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p

788  
789 
s>intra_ac_vlc_length =s>inter_ac_vlc_length = uni_h263_inter_rl_len; 
790 
s>intra_ac_vlc_last_length=s>inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; 
791 
if(s>h263_aic){

792 
s>intra_ac_vlc_length = uni_h263_intra_aic_rl_len; 
793 
s>intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; 
794 
} 
795 
s>ac_esc_length= 7+1+6+8; 
796  
797 
// use fcodes >1 only for mpeg4 & h263 & h263p FIXME

798 
switch(s>codec_id){

799 
case CODEC_ID_MPEG4:

800 
s>fcode_tab= fcode_tab; 
801 
break;

802 
case CODEC_ID_H263P:

803 
if(s>umvplus)

804 
s>fcode_tab= umv_fcode_tab; 
805 
if(s>modified_quant){

806 
s>min_qcoeff= 2047;

807 
s>max_qcoeff= 2047;

808 
}else{

809 
s>min_qcoeff= 127;

810 
s>max_qcoeff= 127;

811 
} 
812 
break;

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

814 
case CODEC_ID_FLV1:

815 
if (s>h263_flv > 1) { 
816 
s>min_qcoeff= 1023;

817 
s>max_qcoeff= 1023;

818 
} else {

819 
s>min_qcoeff= 127;

820 
s>max_qcoeff= 127;

821 
} 
822 
s>y_dc_scale_table= 
823 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
824 
break;

825 
default: //nothing needed  default table already set in mpegvideo.c 
826 
s>min_qcoeff= 127;

827 
s>max_qcoeff= 127;

828 
s>y_dc_scale_table= 
829 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
830 
} 
831 
} 
832  
833 
void ff_h263_encode_mba(MpegEncContext *s)

834 
{ 
835 
int i, mb_pos;

836  
837 
for(i=0; i<6; i++){ 
838 
if(s>mb_num1 <= ff_mba_max[i]) break; 
839 
} 
840 
mb_pos= s>mb_x + s>mb_width*s>mb_y; 
841 
put_bits(&s>pb, ff_mba_length[i], mb_pos); 
842 
} 