summaryrefslogtreecommitdiff
path: root/libavcodec/ituh263enc.c (plain)
blob: ee09f2974c207c09bda062c9d15f3c5fa2e4456b
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 */
47static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
48
49/**
50 * Minimal fcode that a motion vector component would need.
51 */
52static 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 */
58static 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.
62static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
63static 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
68static const uint8_t wrong_run[102] = {
69 1, 2, 3, 5, 4, 10, 9, 8,
7011, 15, 17, 16, 23, 22, 21, 20,
7119, 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,
7610, 1, 1, 5, 9, 17, 25, 24,
7729, 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,
8011, 12, 13, 14, 1, 21, 20, 18,
8119, 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 */
89av_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
103void 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 avpriv_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 */
240void 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 */
266void 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
292static 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 */
299static 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 */
410static 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
447void 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
646void 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
674static 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
716static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
717 uint8_t *len_tab)
718{
719 int slevel, run, last;
720
721 av_assert0(MAX_LEVEL >= 64);
722 av_assert0(MAX_RUN >= 63);
723
724 for(slevel=-64; slevel<64; slevel++){
725 if(slevel==0) continue;
726 for(run=0; run<64; run++){
727 for(last=0; last<=1; last++){
728 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
729 int level= slevel < 0 ? -slevel : slevel;
730 int sign= slevel < 0 ? 1 : 0;
731 int bits, len, code;
732
733 len_tab[index]= 100;
734
735 /* ESC0 */
736 code= get_rl_index(rl, last, run, level);
737 bits= rl->table_vlc[code][0];
738 len= rl->table_vlc[code][1];
739 bits=bits*2+sign; len++;
740
741 if(code!=rl->n && len < len_tab[index]){
742 if(bits_tab) bits_tab[index]= bits;
743 len_tab [index]= len;
744 }
745 /* ESC */
746 bits= rl->table_vlc[rl->n][0];
747 len = rl->table_vlc[rl->n][1];
748 bits=bits*2+last; len++;
749 bits=bits*64+run; len+=6;
750 bits=bits*256+(level&0xff); len+=8;
751
752 if(len < len_tab[index]){
753 if(bits_tab) bits_tab[index]= bits;
754 len_tab [index]= len;
755 }
756 }
757 }
758 }
759}
760
761av_cold void ff_h263_encode_init(MpegEncContext *s)
762{
763 static int done = 0;
764
765 if (!done) {
766 done = 1;
767
768 ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
769 ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
770
771 init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
772 init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);
773
774 init_mv_penalty_and_fcode(s);
775 }
776 s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
777
778 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
779 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
780 if(s->h263_aic){
781 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
782 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
783 }
784 s->ac_esc_length= 7+1+6+8;
785
786 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
787 switch(s->codec_id){
788 case AV_CODEC_ID_MPEG4:
789 s->fcode_tab= fcode_tab;
790 break;
791 case AV_CODEC_ID_H263P:
792 if(s->umvplus)
793 s->fcode_tab= umv_fcode_tab;
794 if(s->modified_quant){
795 s->min_qcoeff= -2047;
796 s->max_qcoeff= 2047;
797 }else{
798 s->min_qcoeff= -127;
799 s->max_qcoeff= 127;
800 }
801 break;
802 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
803 case AV_CODEC_ID_FLV1:
804 if (s->h263_flv > 1) {
805 s->min_qcoeff= -1023;
806 s->max_qcoeff= 1023;
807 } else {
808 s->min_qcoeff= -127;
809 s->max_qcoeff= 127;
810 }
811 break;
812 default: //nothing needed - default table already set in mpegvideo.c
813 s->min_qcoeff= -127;
814 s->max_qcoeff= 127;
815 }
816 if(s->h263_aic){
817 s->y_dc_scale_table=
818 s->c_dc_scale_table= ff_aic_dc_scale_table;
819 }else{
820 s->y_dc_scale_table=
821 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
822 }
823}
824
825void ff_h263_encode_mba(MpegEncContext *s)
826{
827 int i, mb_pos;
828
829 for(i=0; i<6; i++){
830 if(s->mb_num-1 <= ff_mba_max[i]) break;
831 }
832 mb_pos= s->mb_x + s->mb_width*s->mb_y;
833 put_bits(&s->pb, ff_mba_length[i], mb_pos);
834}
835
generated by cgit at 2024-05-17 04:46:34 (GMT)