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
* Returns 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 == FF_P_TYPE));
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 == FF_P_TYPE);
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
* Encodes 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 == FF_I_TYPE); /* 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 == FF_I_TYPE); /* 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.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.motion_val[0][ s->block_index[i] ][0];
533
motion_y= s->current_picture.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 == FF_I_TYPE) {
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);