2 * ITU H263 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 FFmpeg.
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.
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.
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
27 * h263 bitstream encoder.
35 #include "mpegvideo.h"
40 #include "mpeg4video.h"
47 * Table of number of bits a motion vector component needs.
49 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
52 * Minimal fcode that a motion vector component would need.
54 static uint8_t fcode_tab[MAX_MV*2+1];
57 * Minimal fcode that a motion vector component would need in umv.
58 * All entries in this table are 1.
60 static uint8_t umv_fcode_tab[MAX_MV*2+1];
62 //unified encoding tables for run length encoding of coefficients
63 //unified in the sense that the specification specifies the encoding in several steps.
64 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
65 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
66 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
67 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
68 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
70 static const uint8_t wrong_run[102] = {
71 1, 2, 3, 5, 4, 10, 9, 8,
72 11, 15, 17, 16, 23, 22, 21, 20,
73 19, 18, 25, 24, 27, 26, 11, 7,
74 6, 1, 2, 13, 2, 2, 2, 2,
75 6, 12, 3, 9, 1, 3, 4, 3,
76 7, 4, 1, 1, 5, 5, 14, 6,
77 1, 7, 1, 8, 1, 1, 1, 1,
78 10, 1, 1, 5, 9, 17, 25, 24,
79 29, 33, 32, 41, 2, 23, 28, 31,
80 3, 22, 30, 4, 27, 40, 8, 26,
81 6, 39, 7, 38, 16, 37, 15, 10,
82 11, 12, 13, 14, 1, 21, 20, 18,
87 * Return the 4 bit value that specifies the given aspect ratio.
88 * This may be one of the standard aspect ratios or it specifies
89 * that the aspect will be stored explicitly later.
91 av_const int ff_h263_aspect_to_info(AVRational aspect){
94 if(aspect.num==0) aspect= (AVRational){1,1};
97 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
102 return FF_ASPECT_EXTENDED;
105 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
107 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
108 int best_clock_code=1;
110 int best_error= INT_MAX;
115 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
116 div= av_clip(div, 1, 127);
117 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
118 if(error < best_error){
125 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
126 coded_frame_rate= 1800000;
127 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
129 align_put_bits(&s->pb);
131 /* Update the pointer to last GOB */
132 s->ptr_lastgob = put_bits_ptr(&s->pb);
133 put_bits(&s->pb, 22, 0x20); /* PSC */
134 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
135 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
136 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
138 put_bits(&s->pb, 1, 1); /* marker */
139 put_bits(&s->pb, 1, 0); /* h263 id */
140 put_bits(&s->pb, 1, 0); /* split screen off */
141 put_bits(&s->pb, 1, 0); /* camera off */
142 put_bits(&s->pb, 1, 0); /* freeze picture release off */
144 format = ff_match_2uint16(h263_format, FF_ARRAY_ELEMS(h263_format), s->width, s->height);
147 put_bits(&s->pb, 3, format);
148 put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
149 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
150 of H.263v1 UMV implies to check the predicted MV after
151 calculation of the current MB to see if we're on the limits */
152 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
153 put_bits(&s->pb, 1, 0); /* SAC: off */
154 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
155 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
156 put_bits(&s->pb, 5, s->qscale);
157 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
161 /* H.263 Plus PTYPE */
163 put_bits(&s->pb, 3, 7);
164 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
166 put_bits(&s->pb,3,6); /* Custom Source Format */
168 put_bits(&s->pb, 3, format);
170 put_bits(&s->pb,1, s->custom_pcf);
171 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
172 put_bits(&s->pb,1,0); /* SAC: off */
173 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
174 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
175 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
176 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
177 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
178 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
179 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
180 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
181 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
182 put_bits(&s->pb,3,0); /* Reserved */
184 put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
186 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
187 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
188 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
189 put_bits(&s->pb,2,0); /* Reserved */
190 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
192 /* This should be here if PLUSPTYPE */
193 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
196 /* Custom Picture Format (CPFMT) */
197 s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
199 put_bits(&s->pb,4,s->aspect_ratio_info);
200 put_bits(&s->pb,9,(s->width >> 2) - 1);
201 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
202 put_bits(&s->pb,9,(s->height >> 2));
203 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
204 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
205 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
210 put_bits(&s->pb, 1, best_clock_code);
211 put_bits(&s->pb, 7, best_divisor);
213 put_sbits(&s->pb, 2, temp_ref>>8);
216 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
218 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
219 //FIXME check actual requested range
220 put_bits(&s->pb,2,1); /* unlimited */
221 if(s->h263_slice_structured)
222 put_bits(&s->pb,2,0); /* no weird submodes */
224 put_bits(&s->pb, 5, s->qscale);
227 put_bits(&s->pb, 1, 0); /* no PEI */
229 if(s->h263_slice_structured){
230 put_bits(&s->pb, 1, 1);
232 assert(s->mb_x == 0 && s->mb_y == 0);
233 ff_h263_encode_mba(s);
235 put_bits(&s->pb, 1, 1);
240 s->c_dc_scale_table= ff_aic_dc_scale_table;
243 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
248 * Encode a group of blocks header.
250 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
252 put_bits(&s->pb, 17, 1); /* GBSC */
254 if(s->h263_slice_structured){
255 put_bits(&s->pb, 1, 1);
257 ff_h263_encode_mba(s);
260 put_bits(&s->pb, 1, 1);
261 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
262 put_bits(&s->pb, 1, 1);
263 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
265 int gob_number= mb_line / s->gob_index;
267 put_bits(&s->pb, 5, gob_number); /* GN */
268 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
269 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
274 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
276 void ff_clean_h263_qscales(MpegEncContext *s){
278 int8_t * const qscale_table = s->current_picture.f.qscale_table;
280 ff_init_qscale_tab(s);
282 for(i=1; i<s->mb_num; 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;
286 for(i=s->mb_num-2; i>=0; i--){
287 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
288 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
291 if(s->codec_id != CODEC_ID_H263P){
292 for(i=1; i<s->mb_num; i++){
293 int mb_xy= s->mb_index2xy[i];
295 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
296 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
302 static const int dquant_code[5]= {1,0,9,2,3};
305 * encodes a 8x8 block.
306 * @param block the 8x8 block
307 * @param n block index (0-3 are luma, 4-5 are chroma)
309 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
311 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
314 rl = &ff_h263_rl_inter;
315 if (s->mb_intra && !s->h263_aic) {
318 /* 255 cannot be represented, so we clamp */
323 /* 0 cannot be represented also */
324 else if (level < 1) {
328 if (level == 128) //FIXME check rv10
329 put_bits(&s->pb, 8, 0xff);
331 put_bits(&s->pb, 8, level);
335 if (s->h263_aic && s->mb_intra)
338 if(s->alt_inter_vlc && !s->mb_intra){
340 int inter_vlc_bits=0;
344 last_index = s->block_last_index[n];
345 last_non_zero = i - 1;
346 for (; i <= last_index; i++) {
347 j = s->intra_scantable.permutated[i];
350 run = i - last_non_zero - 1;
351 last = (i == last_index);
353 if(level<0) level= -level;
355 code = get_rl_index(rl, last, run, level);
356 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
357 inter_vlc_bits += rl->table_vlc[code][1]+1;
358 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
361 inter_vlc_bits += 1+6+8-1;
363 if (aic_code == rl_intra_aic.n) {
364 aic_vlc_bits += 1+6+8-1;
365 wrong_pos += run + 1;
367 wrong_pos += wrong_run[aic_code];
372 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
378 last_index = s->block_last_index[n];
379 last_non_zero = i - 1;
380 for (; i <= last_index; i++) {
381 j = s->intra_scantable.permutated[i];
384 run = i - last_non_zero - 1;
385 last = (i == last_index);
392 code = get_rl_index(rl, last, run, level);
393 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
395 if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
396 put_bits(&s->pb, 1, last);
397 put_bits(&s->pb, 6, run);
402 put_sbits(&s->pb, 8, slevel);
404 put_bits(&s->pb, 8, 128);
405 put_sbits(&s->pb, 5, slevel);
406 put_sbits(&s->pb, 6, slevel>>5);
409 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
412 put_bits(&s->pb, 1, sign);
419 /* Encode MV differences on H.263+ with Unrestricted MV mode */
420 static void h263p_encode_umotion(MpegEncContext * s, int val)
430 put_bits(&s->pb, 1, 1);
432 put_bits(&s->pb, 3, 0);
434 put_bits(&s->pb, 3, 2);
437 sval = ((val < 0) ? (short)(-val):(short)val);
440 while (temp_val != 0) {
441 temp_val = temp_val >> 1;
447 tcode = (sval & (1 << (i-1))) >> (i-1);
448 tcode = (tcode << 1) | 1;
449 code = (code << 2) | tcode;
452 code = ((code << 1) | (val < 0)) << 1;
453 put_bits(&s->pb, (2*n_bits)+1, code);
457 void h263_encode_mb(MpegEncContext * s,
458 DCTELEM block[6][64],
459 int motion_x, int motion_y)
461 int cbpc, cbpy, i, cbp, pred_x, pred_y;
463 int16_t rec_intradc[6];
465 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
469 cbp= get_p_cbp(s, block, motion_x, motion_y);
471 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
472 /* skip macroblock */
473 put_bits(&s->pb, 1, 1);
474 if(interleaved_stats){
482 put_bits(&s->pb, 1, 0); /* mb coded */
486 if(s->alt_inter_vlc==0 || cbpc!=3)
488 if(s->dquant) cbpc+= 8;
489 if(s->mv_type==MV_TYPE_16X16){
491 ff_h263_inter_MCBPC_bits[cbpc],
492 ff_h263_inter_MCBPC_code[cbpc]);
494 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
496 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
498 if(interleaved_stats){
499 s->misc_bits+= get_bits_diff(s);
502 /* motion vectors: 16x16 mode */
503 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
506 ff_h263_encode_motion_vector(s, motion_x - pred_x,
507 motion_y - pred_y, 1);
510 h263p_encode_umotion(s, motion_x - pred_x);
511 h263p_encode_umotion(s, motion_y - pred_y);
512 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
513 /* To prevent Start Code emulation */
514 put_bits(&s->pb,1,1);
518 ff_h263_inter_MCBPC_bits[cbpc+16],
519 ff_h263_inter_MCBPC_code[cbpc+16]);
520 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
522 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
524 if(interleaved_stats){
525 s->misc_bits+= get_bits_diff(s);
529 /* motion vectors: 8x8 mode*/
530 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
532 motion_x = s->current_picture.f.motion_val[0][s->block_index[i]][0];
533 motion_y = s->current_picture.f.motion_val[0][s->block_index[i]][1];
535 ff_h263_encode_motion_vector(s, motion_x - pred_x,
536 motion_y - pred_y, 1);
539 h263p_encode_umotion(s, motion_x - pred_x);
540 h263p_encode_umotion(s, motion_y - pred_y);
541 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
542 /* To prevent Start Code emulation */
543 put_bits(&s->pb,1,1);
548 if(interleaved_stats){
549 s->mv_bits+= get_bits_diff(s);
558 int16_t level = block[i][0];
561 if(i<4) scale= s->y_dc_scale;
562 else scale= s->c_dc_scale;
564 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
568 level = (level + (scale>>1))/scale;
570 level = (level - (scale>>1))/scale;
572 /* AIC can change CBP */
573 if (level == 0 && s->block_last_index[i] == 0)
574 s->block_last_index[i] = -1;
576 if(!s->modified_quant){
579 else if (level > 127)
585 rec_intradc[i] = scale*level + pred_dc;
588 //if ((rec_intradc[i] % 2) == 0)
591 if (rec_intradc[i] < 0)
593 else if (rec_intradc[i] > 2047)
594 rec_intradc[i] = 2047;
596 /* Update AC/DC tables */
597 *dc_ptr[i] = rec_intradc[i];
598 if (s->block_last_index[i] >= 0)
604 if (s->block_last_index[i] >= 1)
610 if (s->pict_type == AV_PICTURE_TYPE_I) {
611 if(s->dquant) cbpc+=4;
613 ff_h263_intra_MCBPC_bits[cbpc],
614 ff_h263_intra_MCBPC_code[cbpc]);
616 if(s->dquant) cbpc+=8;
617 put_bits(&s->pb, 1, 0); /* mb coded */
619 ff_h263_inter_MCBPC_bits[cbpc + 4],
620 ff_h263_inter_MCBPC_code[cbpc + 4]);
623 /* XXX: currently, we do not try to use ac prediction */
624 put_bits(&s->pb, 1, 0); /* no AC prediction */
627 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
629 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
631 if(interleaved_stats){
632 s->misc_bits+= get_bits_diff(s);
637 /* encode each block */
638 h263_encode_block(s, block[i], i);
640 /* Update INTRADC for decoding */
641 if (s->h263_aic && s->mb_intra) {
642 block[i][0] = rec_intradc[i];
647 if(interleaved_stats){
649 s->p_tex_bits+= get_bits_diff(s);
652 s->i_tex_bits+= get_bits_diff(s);
658 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
660 int range, l, bit_size, sign, code, bits;
665 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
667 bit_size = f_code - 1;
668 range = 1 << bit_size;
669 /* modulo encoding */
670 l= INT_BIT - 6 - bit_size;
673 val= (val^sign)-sign;
677 code = (val >> bit_size) + 1;
678 bits = val & (range - 1);
680 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
682 put_bits(&s->pb, bit_size, bits);
687 static void init_mv_penalty_and_fcode(MpegEncContext *s)
692 for(f_code=1; f_code<=MAX_FCODE; f_code++){
693 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
696 if(mv==0) len= mvtab[0][1];
698 int val, bit_size, code;
700 bit_size = f_code - 1;
706 code = (val >> bit_size) + 1;
708 len= mvtab[code][1] + 1 + bit_size;
710 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
714 mv_penalty[f_code][mv+MAX_MV]= len;
718 for(f_code=MAX_FCODE; f_code>0; f_code--){
719 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
720 fcode_tab[mv+MAX_MV]= f_code;
724 for(mv=0; mv<MAX_MV*2+1; mv++){
725 umv_fcode_tab[mv]= 1;
729 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
730 int slevel, run, last;
732 assert(MAX_LEVEL >= 64);
733 assert(MAX_RUN >= 63);
735 for(slevel=-64; slevel<64; slevel++){
736 if(slevel==0) continue;
737 for(run=0; run<64; run++){
738 for(last=0; last<=1; last++){
739 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
740 int level= slevel < 0 ? -slevel : slevel;
741 int sign= slevel < 0 ? 1 : 0;
747 code= get_rl_index(rl, last, run, level);
748 bits= rl->table_vlc[code][0];
749 len= rl->table_vlc[code][1];
750 bits=bits*2+sign; len++;
752 if(code!=rl->n && len < len_tab[index]){
753 if(bits_tab) bits_tab[index]= bits;
754 len_tab [index]= len;
757 bits= rl->table_vlc[rl->n][0];
758 len = rl->table_vlc[rl->n][1];
759 bits=bits*2+last; len++;
760 bits=bits*64+run; len+=6;
761 bits=bits*256+(level&0xff); len+=8;
763 if(len < len_tab[index]){
764 if(bits_tab) bits_tab[index]= bits;
765 len_tab [index]= len;
772 void h263_encode_init(MpegEncContext *s)
779 init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]);
780 init_rl(&rl_intra_aic, ff_h263_static_rl_table_store[1]);
782 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
783 init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len);
785 init_mv_penalty_and_fcode(s);
787 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
789 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
790 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
792 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
793 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
795 s->ac_esc_length= 7+1+6+8;
797 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
800 s->fcode_tab= fcode_tab;
804 s->fcode_tab= umv_fcode_tab;
805 if(s->modified_quant){
806 s->min_qcoeff= -2047;
813 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
815 if (s->h263_flv > 1) {
816 s->min_qcoeff= -1023;
823 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
825 default: //nothing needed - default table already set in mpegvideo.c
829 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
833 void ff_h263_encode_mba(MpegEncContext *s)
838 if(s->mb_num-1 <= ff_mba_max[i]) break;
840 mb_pos= s->mb_x + s->mb_width*s->mb_y;
841 put_bits(&s->pb, ff_mba_length[i], mb_pos);