2 * ITU H.263 bitstream encoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
5 * Copyright (c) 2001 Juan J. Sierralta P
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of Libav.
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.
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.
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 02110-1301 USA
27 * H.263 bitstream encoder.
32 #include "libavutil/attributes.h"
34 #include "mpegvideo.h"
35 #include "mpegvideodata.h"
39 #include "mpegutils.h"
41 #include "mpeg4video.h"
45 * Table of number of bits a motion vector component needs.
47 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
50 * Minimal fcode that a motion vector component would need.
52 static uint8_t fcode_tab[MAX_MV*2+1];
55 * Minimal fcode that a motion vector component would need in umv.
56 * All entries in this table are 1.
58 static uint8_t umv_fcode_tab[MAX_MV*2+1];
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))
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,
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.
89 av_const int ff_h263_aspect_to_info(AVRational aspect){
92 if(aspect.num==0) aspect= (AVRational){1,1};
95 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
100 return FF_ASPECT_EXTENDED;
103 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
105 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
106 int best_clock_code=1;
108 int best_error= INT_MAX;
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){
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;
127 avpriv_align_put_bits(&s->pb);
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 */
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 */
142 format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);
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 */
159 /* H.263 Plus PTYPE */
161 put_bits(&s->pb, 3, 7);
162 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
164 put_bits(&s->pb,3,6); /* Custom Source Format */
166 put_bits(&s->pb, 3, format);
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 */
182 put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
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 */
190 /* This should be here if PLUSPTYPE */
191 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
194 /* Custom Picture Format (CPFMT) */
195 s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
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);
208 put_bits(&s->pb, 1, best_clock_code);
209 put_bits(&s->pb, 7, best_divisor);
211 put_sbits(&s->pb, 2, temp_ref>>8);
214 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
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 */
222 put_bits(&s->pb, 5, s->qscale);
225 put_bits(&s->pb, 1, 0); /* no PEI */
227 if(s->h263_slice_structured){
228 put_bits(&s->pb, 1, 1);
230 assert(s->mb_x == 0 && s->mb_y == 0);
231 ff_h263_encode_mba(s);
233 put_bits(&s->pb, 1, 1);
238 s->c_dc_scale_table= ff_aic_dc_scale_table;
241 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
246 * Encode a group of blocks header.
248 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
250 put_bits(&s->pb, 17, 1); /* GBSC */
252 if(s->h263_slice_structured){
253 put_bits(&s->pb, 1, 1);
255 ff_h263_encode_mba(s);
258 put_bits(&s->pb, 1, 1);
259 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
260 put_bits(&s->pb, 1, 1);
261 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
263 int gob_number= mb_line / s->gob_index;
265 put_bits(&s->pb, 5, gob_number); /* GN */
266 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
267 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
272 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
274 void ff_clean_h263_qscales(MpegEncContext *s){
276 int8_t * const qscale_table = s->current_picture.qscale_table;
278 ff_init_qscale_tab(s);
280 for(i=1; i<s->mb_num; i++){
281 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
282 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
284 for(i=s->mb_num-2; i>=0; i--){
285 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
286 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
289 if(s->codec_id != AV_CODEC_ID_H263P){
290 for(i=1; i<s->mb_num; i++){
291 int mb_xy= s->mb_index2xy[i];
293 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
294 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
300 static const int dquant_code[5]= {1,0,9,2,3};
303 * Encode an 8x8 block.
304 * @param block the 8x8 block
305 * @param n block index (0-3 are luma, 4-5 are chroma)
307 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
309 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
312 rl = &ff_h263_rl_inter;
313 if (s->mb_intra && !s->h263_aic) {
316 /* 255 cannot be represented, so we clamp */
321 /* 0 cannot be represented also */
322 else if (level < 1) {
326 if (level == 128) //FIXME check rv10
327 put_bits(&s->pb, 8, 0xff);
329 put_bits(&s->pb, 8, level);
333 if (s->h263_aic && s->mb_intra)
334 rl = &ff_rl_intra_aic;
336 if(s->alt_inter_vlc && !s->mb_intra){
338 int inter_vlc_bits=0;
342 last_index = s->block_last_index[n];
343 last_non_zero = i - 1;
344 for (; i <= last_index; i++) {
345 j = s->intra_scantable.permutated[i];
348 run = i - last_non_zero - 1;
349 last = (i == last_index);
351 if(level<0) level= -level;
353 code = get_rl_index(rl, last, run, level);
354 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
355 inter_vlc_bits += rl->table_vlc[code][1]+1;
356 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
359 inter_vlc_bits += 1+6+8-1;
361 if (aic_code == ff_rl_intra_aic.n) {
362 aic_vlc_bits += 1+6+8-1;
363 wrong_pos += run + 1;
365 wrong_pos += wrong_run[aic_code];
370 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
371 rl = &ff_rl_intra_aic;
376 last_index = s->block_last_index[n];
377 last_non_zero = i - 1;
378 for (; i <= last_index; i++) {
379 j = s->intra_scantable.permutated[i];
382 run = i - last_non_zero - 1;
383 last = (i == last_index);
390 code = get_rl_index(rl, last, run, level);
391 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
393 if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
394 put_bits(&s->pb, 1, last);
395 put_bits(&s->pb, 6, run);
400 put_sbits(&s->pb, 8, slevel);
402 put_bits(&s->pb, 8, 128);
403 put_sbits(&s->pb, 5, slevel);
404 put_sbits(&s->pb, 6, slevel>>5);
407 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
410 put_bits(&s->pb, 1, sign);
417 /* Encode MV differences on H.263+ with Unrestricted MV mode */
418 static void h263p_encode_umotion(MpegEncContext * s, int val)
428 put_bits(&s->pb, 1, 1);
430 put_bits(&s->pb, 3, 0);
432 put_bits(&s->pb, 3, 2);
435 sval = ((val < 0) ? (short)(-val):(short)val);
438 while (temp_val != 0) {
439 temp_val = temp_val >> 1;
445 tcode = (sval & (1 << (i-1))) >> (i-1);
446 tcode = (tcode << 1) | 1;
447 code = (code << 2) | tcode;
450 code = ((code << 1) | (val < 0)) << 1;
451 put_bits(&s->pb, (2*n_bits)+1, code);
455 void ff_h263_encode_mb(MpegEncContext * s,
456 int16_t block[6][64],
457 int motion_x, int motion_y)
459 int cbpc, cbpy, i, cbp, pred_x, pred_y;
461 int16_t rec_intradc[6];
463 const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;
467 cbp= get_p_cbp(s, block, motion_x, motion_y);
469 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
470 /* skip macroblock */
471 put_bits(&s->pb, 1, 1);
472 if(interleaved_stats){
480 put_bits(&s->pb, 1, 0); /* mb coded */
484 if(s->alt_inter_vlc==0 || cbpc!=3)
486 if(s->dquant) cbpc+= 8;
487 if(s->mv_type==MV_TYPE_16X16){
489 ff_h263_inter_MCBPC_bits[cbpc],
490 ff_h263_inter_MCBPC_code[cbpc]);
492 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
494 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
496 if(interleaved_stats){
497 s->misc_bits+= get_bits_diff(s);
500 /* motion vectors: 16x16 mode */
501 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
504 ff_h263_encode_motion_vector(s, motion_x - pred_x,
505 motion_y - pred_y, 1);
508 h263p_encode_umotion(s, motion_x - pred_x);
509 h263p_encode_umotion(s, motion_y - pred_y);
510 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
511 /* To prevent Start Code emulation */
512 put_bits(&s->pb,1,1);
516 ff_h263_inter_MCBPC_bits[cbpc+16],
517 ff_h263_inter_MCBPC_code[cbpc+16]);
518 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
520 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
522 if(interleaved_stats){
523 s->misc_bits+= get_bits_diff(s);
527 /* motion vectors: 8x8 mode*/
528 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
530 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
531 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
533 ff_h263_encode_motion_vector(s, motion_x - pred_x,
534 motion_y - pred_y, 1);
537 h263p_encode_umotion(s, motion_x - pred_x);
538 h263p_encode_umotion(s, motion_y - pred_y);
539 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
540 /* To prevent Start Code emulation */
541 put_bits(&s->pb,1,1);
546 if(interleaved_stats){
547 s->mv_bits+= get_bits_diff(s);
556 int16_t level = block[i][0];
559 if(i<4) scale= s->y_dc_scale;
560 else scale= s->c_dc_scale;
562 pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
566 level = (level + (scale>>1))/scale;
568 level = (level - (scale>>1))/scale;
570 if(!s->modified_quant){
573 else if (level > 127)
579 rec_intradc[i] = scale*level + pred_dc;
582 //if ((rec_intradc[i] % 2) == 0)
585 if (rec_intradc[i] < 0)
587 else if (rec_intradc[i] > 2047)
588 rec_intradc[i] = 2047;
590 /* Update AC/DC tables */
591 *dc_ptr[i] = rec_intradc[i];
592 /* AIC can change CBP */
593 if (s->block_last_index[i] > 0 ||
594 (s->block_last_index[i] == 0 && level !=0))
600 if (s->block_last_index[i] >= 1)
606 if (s->pict_type == AV_PICTURE_TYPE_I) {
607 if(s->dquant) cbpc+=4;
609 ff_h263_intra_MCBPC_bits[cbpc],
610 ff_h263_intra_MCBPC_code[cbpc]);
612 if(s->dquant) cbpc+=8;
613 put_bits(&s->pb, 1, 0); /* mb coded */
615 ff_h263_inter_MCBPC_bits[cbpc + 4],
616 ff_h263_inter_MCBPC_code[cbpc + 4]);
619 /* XXX: currently, we do not try to use ac prediction */
620 put_bits(&s->pb, 1, 0); /* no AC prediction */
623 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
625 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
627 if(interleaved_stats){
628 s->misc_bits+= get_bits_diff(s);
633 /* encode each block */
634 h263_encode_block(s, block[i], i);
636 /* Update INTRADC for decoding */
637 if (s->h263_aic && s->mb_intra) {
638 block[i][0] = rec_intradc[i];
643 if(interleaved_stats){
645 s->p_tex_bits+= get_bits_diff(s);
648 s->i_tex_bits+= get_bits_diff(s);
654 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
656 int range, bit_size, sign, code, bits;
661 put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
663 bit_size = f_code - 1;
664 range = 1 << bit_size;
665 /* modulo encoding */
666 val = sign_extend(val, 6 + bit_size);
668 val= (val^sign)-sign;
672 code = (val >> bit_size) + 1;
673 bits = val & (range - 1);
675 put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
677 put_bits(&s->pb, bit_size, bits);
682 static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
687 for(f_code=1; f_code<=MAX_FCODE; f_code++){
688 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
691 if(mv==0) len= ff_mvtab[0][1];
693 int val, bit_size, code;
695 bit_size = f_code - 1;
701 code = (val >> bit_size) + 1;
703 len= ff_mvtab[code][1] + 1 + bit_size;
705 len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
709 mv_penalty[f_code][mv+MAX_MV]= len;
713 for(f_code=MAX_FCODE; f_code>0; f_code--){
714 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
715 fcode_tab[mv+MAX_MV]= f_code;
719 for(mv=0; mv<MAX_MV*2+1; mv++){
720 umv_fcode_tab[mv]= 1;
724 static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
727 int slevel, run, last;
729 assert(MAX_LEVEL >= 64);
730 assert(MAX_RUN >= 63);
732 for(slevel=-64; slevel<64; slevel++){
733 if(slevel==0) continue;
734 for(run=0; run<64; run++){
735 for(last=0; last<=1; last++){
736 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
737 int level= slevel < 0 ? -slevel : slevel;
738 int sign= slevel < 0 ? 1 : 0;
744 code= get_rl_index(rl, last, run, level);
745 bits= rl->table_vlc[code][0];
746 len= rl->table_vlc[code][1];
747 bits=bits*2+sign; len++;
749 if(code!=rl->n && len < len_tab[index]){
750 if(bits_tab) bits_tab[index]= bits;
751 len_tab [index]= len;
754 bits= rl->table_vlc[rl->n][0];
755 len = rl->table_vlc[rl->n][1];
756 bits=bits*2+last; len++;
757 bits=bits*64+run; len+=6;
758 bits=bits*256+(level&0xff); len+=8;
760 if(len < len_tab[index]){
761 if(bits_tab) bits_tab[index]= bits;
762 len_tab [index]= len;
769 av_cold void ff_h263_encode_init(MpegEncContext *s)
776 ff_rl_init(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
777 ff_rl_init(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]);
779 init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
780 init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);
782 init_mv_penalty_and_fcode(s);
784 s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
786 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
787 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
789 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
790 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
792 s->ac_esc_length= 7+1+6+8;
794 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
796 case AV_CODEC_ID_MPEG4:
797 s->fcode_tab= fcode_tab;
799 case AV_CODEC_ID_H263P:
801 s->fcode_tab= umv_fcode_tab;
802 if(s->modified_quant){
803 s->min_qcoeff= -2047;
810 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
811 case AV_CODEC_ID_FLV1:
812 if (s->h263_flv > 1) {
813 s->min_qcoeff= -1023;
820 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
822 default: //nothing needed - default table already set in mpegvideo.c
826 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
830 void ff_h263_encode_mba(MpegEncContext *s)
835 if(s->mb_num-1 <= ff_mba_max[i]) break;
837 mb_pos= s->mb_x + s->mb_width*s->mb_y;
838 put_bits(&s->pb, ff_mba_length[i], mb_pos);