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