1 /*
2 * ITU H.263 bitstream encoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * H.263+ support.
5 * Copyright (c) 2001 Juan J. Sierralta P
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
26 * @file
27 * H.263 bitstream encoder.
28 */
29
30 #include <limits.h>
31
32 #include "libavutil/attributes.h"
33 #include "avcodec.h"
34 #include "mpegvideo.h"
35 #include "mpegvideodata.h"
36 #include "h263.h"
37 #include "h263data.h"
38 #include "mathops.h"
39 #include "mpegutils.h"
40 #include "flv.h"
41 #include "mpeg4video.h"
42 #include "internal.h"
43
44 /**
45 * Table of number of bits a motion vector component needs.
46 */
47 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
48
49 /**
50 * Minimal fcode that a motion vector component would need.
51 */
52 static uint8_t fcode_tab[MAX_MV*2+1];
53
54 /**
55 * Minimal fcode that a motion vector component would need in umv.
56 * All entries in this table are 1.
57 */
58 static uint8_t umv_fcode_tab[MAX_MV*2+1];
59
60 //unified encoding tables for run length encoding of coefficients
61 //unified in the sense that the specification specifies the encoding in several steps.
62 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
63 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
64 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
65 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
66 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
67
68 static const uint8_t wrong_run[102] = {
69 1, 2, 3, 5, 4, 10, 9, 8,
70 11, 15, 17, 16, 23, 22, 21, 20,
71 19, 18, 25, 24, 27, 26, 11, 7,
72 6, 1, 2, 13, 2, 2, 2, 2,
73 6, 12, 3, 9, 1, 3, 4, 3,
74 7, 4, 1, 1, 5, 5, 14, 6,
75 1, 7, 1, 8, 1, 1, 1, 1,
76 10, 1, 1, 5, 9, 17, 25, 24,
77 29, 33, 32, 41, 2, 23, 28, 31,
78 3, 22, 30, 4, 27, 40, 8, 26,
79 6, 39, 7, 38, 16, 37, 15, 10,
80 11, 12, 13, 14, 1, 21, 20, 18,
81 19, 2, 1, 34, 35, 36
82 };
83
84 /**
85 * Return the 4 bit value that specifies the given aspect ratio.
86 * This may be one of the standard aspect ratios or it specifies
87 * that the aspect will be stored explicitly later.
88 */
ff_h263_aspect_to_info(AVRational aspect)89 av_const int ff_h263_aspect_to_info(AVRational aspect){
90 int i;
91
92 if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};
93
94 for(i=1; i<6; i++){
95 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
96 return i;
97 }
98 }
99
100 return FF_ASPECT_EXTENDED;
101 }
102
ff_h263_encode_picture_header(MpegEncContext * s,int picture_number)103 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
104 {
105 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
106 int best_clock_code=1;
107 int best_divisor=60;
108 int best_error= INT_MAX;
109
110 if(s->h263_plus){
111 for(i=0; i<2; i++){
112 int div, error;
113 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
114 div= av_clip(div, 1, 127);
115 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
116 if(error < best_error){
117 best_error= error;
118 best_divisor= div;
119 best_clock_code= i;
120 }
121 }
122 }
123 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
124 coded_frame_rate= 1800000;
125 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
126
127 align_put_bits(&s->pb);
128
129 /* Update the pointer to last GOB */
130 s->ptr_lastgob = put_bits_ptr(&s->pb);
131 put_bits(&s->pb, 22, 0x20); /* PSC */
132 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
133 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
134 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
135
136 put_bits(&s->pb, 1, 1); /* marker */
137 put_bits(&s->pb, 1, 0); /* H.263 id */
138 put_bits(&s->pb, 1, 0); /* split screen off */
139 put_bits(&s->pb, 1, 0); /* camera off */
140 put_bits(&s->pb, 1, 0); /* freeze picture release off */
141
142 format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
143 if (!s->h263_plus) {
144 /* H.263v1 */
145 put_bits(&s->pb, 3, format);
146 put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
147 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
148 of H.263v1 UMV implies to check the predicted MV after
149 calculation of the current MB to see if we're on the limits */
150 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
151 put_bits(&s->pb, 1, 0); /* SAC: off */
152 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
153 put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */
154 put_bits(&s->pb, 5, s->qscale);
155 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
156 } else {
157 int ufep=1;
158 /* H.263v2 */
159 /* H.263 Plus PTYPE */
160
161 put_bits(&s->pb, 3, 7);
162 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
163 if (format == 8)
164 put_bits(&s->pb,3,6); /* Custom Source Format */
165 else
166 put_bits(&s->pb, 3, format);
167
168 put_bits(&s->pb,1, s->custom_pcf);
169 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
170 put_bits(&s->pb,1,0); /* SAC: off */
171 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
172 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
173 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
174 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
175 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
176 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
177 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
178 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
179 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
180 put_bits(&s->pb,3,0); /* Reserved */
181
182 put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
183
184 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
185 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
186 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
187 put_bits(&s->pb,2,0); /* Reserved */
188 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
189
190 /* This should be here if PLUSPTYPE */
191 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
192
193 if (format == 8) {
194 /* Custom Picture Format (CPFMT) */
195 s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
196
197 put_bits(&s->pb,4,s->aspect_ratio_info);
198 put_bits(&s->pb,9,(s->width >> 2) - 1);
199 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
200 put_bits(&s->pb,9,(s->height >> 2));
201 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
202 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
203 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
204 }
205 }
206 if(s->custom_pcf){
207 if(ufep){
208 put_bits(&s->pb, 1, best_clock_code);
209 put_bits(&s->pb, 7, best_divisor);
210 }
211 put_sbits(&s->pb, 2, temp_ref>>8);
212 }
213
214 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
215 if (s->umvplus)
216 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
217 //FIXME check actual requested range
218 put_bits(&s->pb,2,1); /* unlimited */
219 if(s->h263_slice_structured)
220 put_bits(&s->pb,2,0); /* no weird submodes */
221
222 put_bits(&s->pb, 5, s->qscale);
223 }
224
225 put_bits(&s->pb, 1, 0); /* no PEI */
226
227 if(s->h263_slice_structured){
228 put_bits(&s->pb, 1, 1);
229
230 av_assert1(s->mb_x == 0 && s->mb_y == 0);
231 ff_h263_encode_mba(s);
232
233 put_bits(&s->pb, 1, 1);
234 }
235 }
236
237 /**
238 * Encode a group of blocks header.
239 */
ff_h263_encode_gob_header(MpegEncContext * s,int mb_line)240 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
241 {
242 put_bits(&s->pb, 17, 1); /* GBSC */
243
244 if(s->h263_slice_structured){
245 put_bits(&s->pb, 1, 1);
246
247 ff_h263_encode_mba(s);
248
249 if(s->mb_num > 1583)
250 put_bits(&s->pb, 1, 1);
251 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
252 put_bits(&s->pb, 1, 1);
253 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
254 }else{
255 int gob_number= mb_line / s->gob_index;
256
257 put_bits(&s->pb, 5, gob_number); /* GN */
258 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
259 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
260 }
261 }
262
263 /**
264 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
265 */
ff_clean_h263_qscales(MpegEncContext * s)266 void ff_clean_h263_qscales(MpegEncContext *s){
267 int i;
268 int8_t * const qscale_table = s->current_picture.qscale_table;
269
270 ff_init_qscale_tab(s);
271
272 for(i=1; i<s->mb_num; i++){
273 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
274 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
275 }
276 for(i=s->mb_num-2; i>=0; i--){
277 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
278 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
279 }
280
281 if(s->codec_id != AV_CODEC_ID_H263P){
282 for(i=1; i<s->mb_num; i++){
283 int mb_xy= s->mb_index2xy[i];
284
285 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
286 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
287 }
288 }
289 }
290 }
291
292 static const int dquant_code[5]= {1,0,9,2,3};
293
294 /**
295 * Encode an 8x8 block.
296 * @param block the 8x8 block
297 * @param n block index (0-3 are luma, 4-5 are chroma)
298 */
h263_encode_block(MpegEncContext * s,int16_t * block,int n)299 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
300 {
301 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
302 RLTable *rl;
303
304 rl = &ff_h263_rl_inter;
305 if (s->mb_intra && !s->h263_aic) {
306 /* DC coef */
307 level = block[0];
308 /* 255 cannot be represented, so we clamp */
309 if (level > 254) {
310 level = 254;
311 block[0] = 254;
312 }
313 /* 0 cannot be represented also */
314 else if (level < 1) {
315 level = 1;
316 block[0] = 1;
317 }
318 if (level == 128) //FIXME check rv10
319 put_bits(&s->pb, 8, 0xff);
320 else
321 put_bits(&s->pb, 8, level);
322 i = 1;
323 } else {
324 i = 0;
325 if (s->h263_aic && s->mb_intra)
326 rl = &ff_rl_intra_aic;
327
328 if(s->alt_inter_vlc && !s->mb_intra){
329 int aic_vlc_bits=0;
330 int inter_vlc_bits=0;
331 int wrong_pos=-1;
332 int aic_code;
333
334 last_index = s->block_last_index[n];
335 last_non_zero = i - 1;
336 for (; i <= last_index; i++) {
337 j = s->intra_scantable.permutated[i];
338 level = block[j];
339 if (level) {
340 run = i - last_non_zero - 1;
341 last = (i == last_index);
342
343 if(level<0) level= -level;
344
345 code = get_rl_index(rl, last, run, level);
346 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
347 inter_vlc_bits += rl->table_vlc[code][1]+1;
348 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
349
350 if (code == rl->n) {
351 inter_vlc_bits += 1+6+8-1;
352 }
353 if (aic_code == ff_rl_intra_aic.n) {
354 aic_vlc_bits += 1+6+8-1;
355 wrong_pos += run + 1;
356 }else
357 wrong_pos += wrong_run[aic_code];
358 last_non_zero = i;
359 }
360 }
361 i = 0;
362 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
363 rl = &ff_rl_intra_aic;
364 }
365 }
366
367 /* AC coefs */
368 last_index = s->block_last_index[n];
369 last_non_zero = i - 1;
370 for (; i <= last_index; i++) {
371 j = s->intra_scantable.permutated[i];
372 level = block[j];
373 if (level) {
374 run = i - last_non_zero - 1;
375 last = (i == last_index);
376 sign = 0;
377 slevel = level;
378 if (level < 0) {
379 sign = 1;
380 level = -level;
381 }
382 code = get_rl_index(rl, last, run, level);
383 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
384 if (code == rl->n) {
385 if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
386 put_bits(&s->pb, 1, last);
387 put_bits(&s->pb, 6, run);
388
389 av_assert2(slevel != 0);
390
391 if(level < 128)
392 put_sbits(&s->pb, 8, slevel);
393 else{
394 put_bits(&s->pb, 8, 128);
395 put_sbits(&s->pb, 5, slevel);
396 put_sbits(&s->pb, 6, slevel>>5);
397 }
398 }else{
399 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
400 }
401 } else {
402 put_bits(&s->pb, 1, sign);
403 }
404 last_non_zero = i;
405 }
406 }
407 }
408
409 /* Encode MV differences on H.263+ with Unrestricted MV mode */
h263p_encode_umotion(PutBitContext * pb,int val)410 static void h263p_encode_umotion(PutBitContext *pb, int val)
411 {
412 short sval = 0;
413 short i = 0;
414 short n_bits = 0;
415 short temp_val;
416 int code = 0;
417 int tcode;
418
419 if ( val == 0)
420 put_bits(pb, 1, 1);
421 else if (val == 1)
422 put_bits(pb, 3, 0);
423 else if (val == -1)
424 put_bits(pb, 3, 2);
425 else {
426
427 sval = ((val < 0) ? (short)(-val):(short)val);
428 temp_val = sval;
429
430 while (temp_val != 0) {
431 temp_val = temp_val >> 1;
432 n_bits++;
433 }
434
435 i = n_bits - 1;
436 while (i > 0) {
437 tcode = (sval & (1 << (i-1))) >> (i-1);
438 tcode = (tcode << 1) | 1;
439 code = (code << 2) | tcode;
440 i--;
441 }
442 code = ((code << 1) | (val < 0)) << 1;
443 put_bits(pb, (2*n_bits)+1, code);
444 }
445 }
446
ff_h263_encode_mb(MpegEncContext * s,int16_t block[6][64],int motion_x,int motion_y)447 void ff_h263_encode_mb(MpegEncContext * s,
448 int16_t block[6][64],
449 int motion_x, int motion_y)
450 {
451 int cbpc, cbpy, i, cbp, pred_x, pred_y;
452 int16_t pred_dc;
453 int16_t rec_intradc[6];
454 int16_t *dc_ptr[6];
455 const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;
456
457 if (!s->mb_intra) {
458 /* compute cbp */
459 cbp= get_p_cbp(s, block, motion_x, motion_y);
460
461 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
462 /* skip macroblock */
463 put_bits(&s->pb, 1, 1);
464 if(interleaved_stats){
465 s->misc_bits++;
466 s->last_bits++;
467 }
468 s->skip_count++;
469
470 return;
471 }
472 put_bits(&s->pb, 1, 0); /* mb coded */
473
474 cbpc = cbp & 3;
475 cbpy = cbp >> 2;
476 if(s->alt_inter_vlc==0 || cbpc!=3)
477 cbpy ^= 0xF;
478 if(s->dquant) cbpc+= 8;
479 if(s->mv_type==MV_TYPE_16X16){
480 put_bits(&s->pb,
481 ff_h263_inter_MCBPC_bits[cbpc],
482 ff_h263_inter_MCBPC_code[cbpc]);
483
484 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
485 if(s->dquant)
486 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
487
488 if(interleaved_stats){
489 s->misc_bits+= get_bits_diff(s);
490 }
491
492 /* motion vectors: 16x16 mode */
493 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
494
495 if (!s->umvplus) {
496 ff_h263_encode_motion_vector(s, motion_x - pred_x,
497 motion_y - pred_y, 1);
498 }
499 else {
500 h263p_encode_umotion(&s->pb, motion_x - pred_x);
501 h263p_encode_umotion(&s->pb, motion_y - pred_y);
502 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
503 /* To prevent Start Code emulation */
504 put_bits(&s->pb,1,1);
505 }
506 }else{
507 put_bits(&s->pb,
508 ff_h263_inter_MCBPC_bits[cbpc+16],
509 ff_h263_inter_MCBPC_code[cbpc+16]);
510 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
511 if(s->dquant)
512 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
513
514 if(interleaved_stats){
515 s->misc_bits+= get_bits_diff(s);
516 }
517
518 for(i=0; i<4; i++){
519 /* motion vectors: 8x8 mode*/
520 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
521
522 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
523 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
524 if (!s->umvplus) {
525 ff_h263_encode_motion_vector(s, motion_x - pred_x,
526 motion_y - pred_y, 1);
527 }
528 else {
529 h263p_encode_umotion(&s->pb, motion_x - pred_x);
530 h263p_encode_umotion(&s->pb, motion_y - pred_y);
531 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
532 /* To prevent Start Code emulation */
533 put_bits(&s->pb,1,1);
534 }
535 }
536 }
537
538 if(interleaved_stats){
539 s->mv_bits+= get_bits_diff(s);
540 }
541 } else {
542 av_assert2(s->mb_intra);
543
544 cbp = 0;
545 if (s->h263_aic) {
546 /* Predict DC */
547 for(i=0; i<6; i++) {
548 int16_t level = block[i][0];
549 int scale;
550
551 if(i<4) scale= s->y_dc_scale;
552 else scale= s->c_dc_scale;
553
554 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
555 level -= pred_dc;
556 /* Quant */
557 if (level >= 0)
558 level = (level + (scale>>1))/scale;
559 else
560 level = (level - (scale>>1))/scale;
561
562 if(!s->modified_quant){
563 if (level < -127)
564 level = -127;
565 else if (level > 127)
566 level = 127;
567 }
568
569 block[i][0] = level;
570 /* Reconstruction */
571 rec_intradc[i] = scale*level + pred_dc;
572 /* Oddify */
573 rec_intradc[i] |= 1;
574 //if ((rec_intradc[i] % 2) == 0)
575 // rec_intradc[i]++;
576 /* Clipping */
577 if (rec_intradc[i] < 0)
578 rec_intradc[i] = 0;
579 else if (rec_intradc[i] > 2047)
580 rec_intradc[i] = 2047;
581
582 /* Update AC/DC tables */
583 *dc_ptr[i] = rec_intradc[i];
584 /* AIC can change CBP */
585 if (s->block_last_index[i] > 0 ||
586 (s->block_last_index[i] == 0 && level !=0))
587 cbp |= 1 << (5 - i);
588 }
589 }else{
590 for(i=0; i<6; i++) {
591 /* compute cbp */
592 if (s->block_last_index[i] >= 1)
593 cbp |= 1 << (5 - i);
594 }
595 }
596
597 cbpc = cbp & 3;
598 if (s->pict_type == AV_PICTURE_TYPE_I) {
599 if(s->dquant) cbpc+=4;
600 put_bits(&s->pb,
601 ff_h263_intra_MCBPC_bits[cbpc],
602 ff_h263_intra_MCBPC_code[cbpc]);
603 } else {
604 if(s->dquant) cbpc+=8;
605 put_bits(&s->pb, 1, 0); /* mb coded */
606 put_bits(&s->pb,
607 ff_h263_inter_MCBPC_bits[cbpc + 4],
608 ff_h263_inter_MCBPC_code[cbpc + 4]);
609 }
610 if (s->h263_aic) {
611 /* XXX: currently, we do not try to use ac prediction */
612 put_bits(&s->pb, 1, 0); /* no AC prediction */
613 }
614 cbpy = cbp >> 2;
615 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
616 if(s->dquant)
617 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
618
619 if(interleaved_stats){
620 s->misc_bits+= get_bits_diff(s);
621 }
622 }
623
624 for(i=0; i<6; i++) {
625 /* encode each block */
626 h263_encode_block(s, block[i], i);
627
628 /* Update INTRADC for decoding */
629 if (s->h263_aic && s->mb_intra) {
630 block[i][0] = rec_intradc[i];
631
632 }
633 }
634
635 if(interleaved_stats){
636 if (!s->mb_intra) {
637 s->p_tex_bits+= get_bits_diff(s);
638 s->f_count++;
639 }else{
640 s->i_tex_bits+= get_bits_diff(s);
641 s->i_count++;
642 }
643 }
644 }
645
ff_h263_encode_motion(PutBitContext * pb,int val,int f_code)646 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
647 {
648 int range, bit_size, sign, code, bits;
649
650 if (val == 0) {
651 /* zero vector */
652 code = 0;
653 put_bits(pb, ff_mvtab[code][1], ff_mvtab[code][0]);
654 } else {
655 bit_size = f_code - 1;
656 range = 1 << bit_size;
657 /* modulo encoding */
658 val = sign_extend(val, 6 + bit_size);
659 sign = val>>31;
660 val= (val^sign)-sign;
661 sign&=1;
662
663 val--;
664 code = (val >> bit_size) + 1;
665 bits = val & (range - 1);
666
667 put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
668 if (bit_size > 0) {
669 put_bits(pb, bit_size, bits);
670 }
671 }
672 }
673
init_mv_penalty_and_fcode(MpegEncContext * s)674 static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
675 {
676 int f_code;
677 int mv;
678
679 for(f_code=1; f_code<=MAX_FCODE; f_code++){
680 for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){
681 int len;
682
683 if(mv==0) len= ff_mvtab[0][1];
684 else{
685 int val, bit_size, code;
686
687 bit_size = f_code - 1;
688
689 val=mv;
690 if (val < 0)
691 val = -val;
692 val--;
693 code = (val >> bit_size) + 1;
694 if(code<33){
695 len= ff_mvtab[code][1] + 1 + bit_size;
696 }else{
697 len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
698 }
699 }
700
701 mv_penalty[f_code][mv+MAX_DMV]= len;
702 }
703 }
704
705 for(f_code=MAX_FCODE; f_code>0; f_code--){
706 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
707 fcode_tab[mv+MAX_MV]= f_code;
708 }
709 }
710
711 for(mv=0; mv<MAX_MV*2+1; mv++){
712 umv_fcode_tab[mv]= 1;
713 }
714 }
715
init_uni_h263_rl_tab(const RLTable * rl,uint8_t * len_tab)716 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
717 {
718 int slevel, run, last;
719
720 av_assert0(MAX_LEVEL >= 64);
721 av_assert0(MAX_RUN >= 63);
722
723 for(slevel=-64; slevel<64; slevel++){
724 if(slevel==0) continue;
725 for(run=0; run<64; run++){
726 for(last=0; last<=1; last++){
727 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
728 int level= slevel < 0 ? -slevel : slevel;
729 int sign= slevel < 0 ? 1 : 0;
730 int bits, len, code;
731
732 len_tab[index]= 100;
733
734 /* ESC0 */
735 code= get_rl_index(rl, last, run, level);
736 bits= rl->table_vlc[code][0];
737 len= rl->table_vlc[code][1];
738 bits=bits*2+sign; len++;
739
740 if (code != rl->n && len < len_tab[index])
741 len_tab [index]= len;
742
743 /* ESC */
744 bits= rl->table_vlc[rl->n][0];
745 len = rl->table_vlc[rl->n][1];
746 bits=bits*2+last; len++;
747 bits=bits*64+run; len+=6;
748 bits=bits*256+(level&0xff); len+=8;
749
750 if (len < len_tab[index])
751 len_tab [index]= len;
752 }
753 }
754 }
755 }
756
ff_h263_encode_init(MpegEncContext * s)757 av_cold void ff_h263_encode_init(MpegEncContext *s)
758 {
759 static int done = 0;
760
761 if (!done) {
762 static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
763 done = 1;
764
765 ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
766 ff_h263_init_rl_inter();
767
768 init_uni_h263_rl_tab(&ff_rl_intra_aic, uni_h263_intra_aic_rl_len);
769 init_uni_h263_rl_tab(&ff_h263_rl_inter, uni_h263_inter_rl_len);
770
771 init_mv_penalty_and_fcode(s);
772 }
773 s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
774
775 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
776 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
777 if(s->h263_aic){
778 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
779 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
780 }
781 s->ac_esc_length= 7+1+6+8;
782
783 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
784 switch(s->codec_id){
785 case AV_CODEC_ID_MPEG4:
786 s->fcode_tab= fcode_tab;
787 break;
788 case AV_CODEC_ID_H263P:
789 if(s->umvplus)
790 s->fcode_tab= umv_fcode_tab;
791 if(s->modified_quant){
792 s->min_qcoeff= -2047;
793 s->max_qcoeff= 2047;
794 }else{
795 s->min_qcoeff= -127;
796 s->max_qcoeff= 127;
797 }
798 break;
799 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
800 case AV_CODEC_ID_FLV1:
801 if (s->h263_flv > 1) {
802 s->min_qcoeff= -1023;
803 s->max_qcoeff= 1023;
804 } else {
805 s->min_qcoeff= -127;
806 s->max_qcoeff= 127;
807 }
808 break;
809 default: //nothing needed - default table already set in mpegvideo.c
810 s->min_qcoeff= -127;
811 s->max_qcoeff= 127;
812 }
813 if(s->h263_aic){
814 s->y_dc_scale_table=
815 s->c_dc_scale_table= ff_aic_dc_scale_table;
816 }else{
817 s->y_dc_scale_table=
818 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
819 }
820 }
821
ff_h263_encode_mba(MpegEncContext * s)822 void ff_h263_encode_mba(MpegEncContext *s)
823 {
824 int i, mb_pos;
825
826 for(i=0; i<6; i++){
827 if(s->mb_num-1 <= ff_mba_max[i]) break;
828 }
829 mb_pos= s->mb_x + s->mb_width*s->mb_y;
830 put_bits(&s->pb, ff_mba_length[i], mb_pos);
831 }
832