00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "libavutil/log.h"
00024 #include "libavutil/opt.h"
00025 #include "mpegvideo.h"
00026 #include "h263.h"
00027 #include "mpeg4video.h"
00028
00029
00030
00031
00032 static uint8_t uni_DCtab_lum_len[512];
00033 static uint8_t uni_DCtab_chrom_len[512];
00034 static uint16_t uni_DCtab_lum_bits[512];
00035 static uint16_t uni_DCtab_chrom_bits[512];
00036
00037
00038
00039 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
00040 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
00041 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
00042 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
00043
00044
00045 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00062 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
00063 int last=0;
00064 int j;
00065 int rate=0;
00066
00067 for(j=1; j<=block_last_index; j++){
00068 const int index= scantable[j];
00069 int level= block[index];
00070 if(level){
00071 level+= 64;
00072 if((level&(~127)) == 0){
00073 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
00074 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
00075 }else
00076 rate += s->ac_esc_length;
00077
00078 last= j;
00079 }
00080 }
00081
00082 return rate;
00083 }
00084
00085
00094 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], const int zigzag_last_index[6])
00095 {
00096 int i, n;
00097 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
00098
00099 for(n=0; n<6; n++){
00100 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00101
00102 st[n]= s->intra_scantable.permutated;
00103 if(dir[n]){
00104
00105 for(i=1; i<8; i++){
00106 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
00107 }
00108 }else{
00109
00110 for(i=1; i<8; i++){
00111 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
00112 }
00113 }
00114 }
00115 }
00116
00125 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00126 {
00127 int score= 0;
00128 int i, n;
00129 int8_t * const qscale_table = s->current_picture.f.qscale_table;
00130
00131 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
00132
00133 for(n=0; n<6; n++){
00134 int16_t *ac_val, *ac_val1;
00135
00136 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
00137
00138 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00139 ac_val1= ac_val;
00140 if(dir[n]){
00141 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00142
00143 ac_val-= s->block_wrap[n]*16;
00144 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00145
00146 for(i=1; i<8; i++){
00147 const int level= block[n][s->dsp.idct_permutation[i ]];
00148 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
00149 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
00150 ac_val1[i+8]= level;
00151 }
00152 }else{
00153
00154 for(i=1; i<8; i++){
00155 const int level= block[n][s->dsp.idct_permutation[i ]];
00156 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00157 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
00158 ac_val1[i+8]= level;
00159 }
00160 }
00161 st[n]= s->intra_h_scantable.permutated;
00162 }else{
00163 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00164
00165 ac_val-= 16;
00166 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00167
00168 for(i=1; i<8; i++){
00169 const int level= block[n][s->dsp.idct_permutation[i<<3]];
00170 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
00171 ac_val1[i ]= level;
00172 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
00173 }
00174 }else{
00175
00176 for(i=1; i<8; i++){
00177 const int level= block[n][s->dsp.idct_permutation[i<<3]];
00178 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00179 ac_val1[i ]= level;
00180 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
00181 }
00182 }
00183 st[n]= s->intra_v_scantable.permutated;
00184 }
00185
00186 for(i=63; i>0; i--)
00187 if(block[n][ st[n][i] ]) break;
00188 s->block_last_index[n]= i;
00189
00190 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
00191 }
00192
00193 if(score < 0){
00194 return 1;
00195 }else{
00196 restore_ac_coeffs(s, block, dir, st, zigzag_last_index);
00197 return 0;
00198 }
00199 }
00200
00204 void ff_clean_mpeg4_qscales(MpegEncContext *s){
00205 int i;
00206 int8_t * const qscale_table = s->current_picture.f.qscale_table;
00207
00208 ff_clean_h263_qscales(s);
00209
00210 if(s->pict_type== AV_PICTURE_TYPE_B){
00211 int odd=0;
00212
00213
00214 for(i=0; i<s->mb_num; i++){
00215 int mb_xy= s->mb_index2xy[i];
00216 odd += qscale_table[mb_xy]&1;
00217 }
00218
00219 if(2*odd > s->mb_num) odd=1;
00220 else odd=0;
00221
00222 for(i=0; i<s->mb_num; i++){
00223 int mb_xy= s->mb_index2xy[i];
00224 if((qscale_table[mb_xy]&1) != odd)
00225 qscale_table[mb_xy]++;
00226 if(qscale_table[mb_xy] > 31)
00227 qscale_table[mb_xy]= 31;
00228 }
00229
00230 for(i=1; i<s->mb_num; i++){
00231 int mb_xy= s->mb_index2xy[i];
00232 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
00233 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
00234 }
00235 }
00236 }
00237 }
00238
00239
00244 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
00245 {
00246 #if 1
00247
00248 level+=256;
00249 if (n < 4) {
00250
00251 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
00252 } else {
00253
00254 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
00255 }
00256 #else
00257 int size, v;
00258
00259 size = 0;
00260 v = abs(level);
00261 while (v) {
00262 v >>= 1;
00263 size++;
00264 }
00265
00266 if (n < 4) {
00267
00268 put_bits(&s->pb, ff_mpeg4_DCtab_lum[size][1], ff_mpeg4_DCtab_lum[size][0]);
00269 } else {
00270
00271 put_bits(&s->pb, ff_mpeg4_DCtab_chrom[size][1], ff_mpeg4_DCtab_chrom[size][0]);
00272 }
00273
00274
00275 if (size > 0) {
00276 if (level < 0)
00277 level = (-level) ^ ((1 << size) - 1);
00278 put_bits(&s->pb, size, level);
00279 if (size > 8)
00280 put_bits(&s->pb, 1, 1);
00281 }
00282 #endif
00283 }
00284
00285 static inline int mpeg4_get_dc_length(int level, int n){
00286 if (n < 4) {
00287 return uni_DCtab_lum_len[level + 256];
00288 } else {
00289 return uni_DCtab_chrom_len[level + 256];
00290 }
00291 }
00292
00297 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00298 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
00299 {
00300 int i, last_non_zero;
00301 uint32_t *bits_tab;
00302 uint8_t *len_tab;
00303 const int last_index = s->block_last_index[n];
00304
00305 if (s->mb_intra) {
00306
00307 mpeg4_encode_dc(dc_pb, intra_dc, n);
00308 if(last_index<1) return;
00309 i = 1;
00310 bits_tab= uni_mpeg4_intra_rl_bits;
00311 len_tab = uni_mpeg4_intra_rl_len;
00312 } else {
00313 if(last_index<0) return;
00314 i = 0;
00315 bits_tab= uni_mpeg4_inter_rl_bits;
00316 len_tab = uni_mpeg4_inter_rl_len;
00317 }
00318
00319
00320 last_non_zero = i - 1;
00321 for (; i < last_index; i++) {
00322 int level = block[ scan_table[i] ];
00323 if (level) {
00324 int run = i - last_non_zero - 1;
00325 level+=64;
00326 if((level&(~127)) == 0){
00327 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
00328 put_bits(ac_pb, len_tab[index], bits_tab[index]);
00329 }else{
00330 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
00331 }
00332 last_non_zero = i;
00333 }
00334 }
00335 {
00336 int level = block[ scan_table[i] ];
00337 int run = i - last_non_zero - 1;
00338 level+=64;
00339 if((level&(~127)) == 0){
00340 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
00341 put_bits(ac_pb, len_tab[index], bits_tab[index]);
00342 }else{
00343 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
00344 }
00345 }
00346 }
00347
00348 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00349 uint8_t *scan_table)
00350 {
00351 int i, last_non_zero;
00352 uint8_t *len_tab;
00353 const int last_index = s->block_last_index[n];
00354 int len=0;
00355
00356 if (s->mb_intra) {
00357
00358 len += mpeg4_get_dc_length(intra_dc, n);
00359 if(last_index<1) return len;
00360 i = 1;
00361 len_tab = uni_mpeg4_intra_rl_len;
00362 } else {
00363 if(last_index<0) return 0;
00364 i = 0;
00365 len_tab = uni_mpeg4_inter_rl_len;
00366 }
00367
00368
00369 last_non_zero = i - 1;
00370 for (; i < last_index; i++) {
00371 int level = block[ scan_table[i] ];
00372 if (level) {
00373 int run = i - last_non_zero - 1;
00374 level+=64;
00375 if((level&(~127)) == 0){
00376 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
00377 len += len_tab[index];
00378 }else{
00379 len += 7+2+1+6+1+12+1;
00380 }
00381 last_non_zero = i;
00382 }
00383 }
00384 {
00385 int level = block[ scan_table[i] ];
00386 int run = i - last_non_zero - 1;
00387 level+=64;
00388 if((level&(~127)) == 0){
00389 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
00390 len += len_tab[index];
00391 }else{
00392 len += 7+2+1+6+1+12+1;
00393 }
00394 }
00395
00396 return len;
00397 }
00398
00399 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
00400 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
00401 int i;
00402
00403 if(scan_table){
00404 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00405 for (i = 0; i < 6; i++) {
00406 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
00407 }
00408 }else{
00409
00410 for (i = 0; i < 6; i++) {
00411 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
00412 }
00413 }
00414 }else{
00415 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00416 for (i = 0; i < 6; i++) {
00417 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
00418 }
00419 }else{
00420
00421 for (i = 0; i < 6; i++) {
00422 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
00423 }
00424 }
00425 }
00426 }
00427
00428 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
00429 int motion_x, int motion_y, int mb_type)
00430 {
00431 int cbp = 0, i;
00432
00433 if (s->flags & CODEC_FLAG_CBP_RD) {
00434 int score = 0;
00435 const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00436
00437 for (i = 0; i < 6; i++)
00438 if (s->coded_score[i] < 0) {
00439 score += s->coded_score[i];
00440 cbp |= 1 << (5 - i);
00441 }
00442
00443 if (cbp) {
00444 int zero_score = -6;
00445 if ((motion_x | motion_y | s->dquant | mb_type) == 0)
00446 zero_score -= 4;
00447
00448 zero_score *= lambda;
00449 if (zero_score <= score)
00450 cbp = 0;
00451 }
00452
00453 for (i = 0; i < 6; i++) {
00454 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i)) & 1) == 0) {
00455 s->block_last_index[i] = -1;
00456 s->dsp.clear_block(s->block[i]);
00457 }
00458 }
00459 } else {
00460 for (i = 0; i < 6; i++) {
00461 if (s->block_last_index[i] >= 0)
00462 cbp |= 1 << (5 - i);
00463 }
00464 }
00465 return cbp;
00466 }
00467
00468
00469 static const int dquant_code[5]= {1,0,9,2,3};
00470
00471 void mpeg4_encode_mb(MpegEncContext * s,
00472 DCTELEM block[6][64],
00473 int motion_x, int motion_y)
00474 {
00475 int cbpc, cbpy, pred_x, pred_y;
00476 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
00477 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=AV_PICTURE_TYPE_B ? &s->tex_pb : &s->pb;
00478 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=AV_PICTURE_TYPE_I ? &s->pb2 : &s->pb;
00479 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
00480
00481 if (!s->mb_intra) {
00482 int i, cbp;
00483
00484 if(s->pict_type==AV_PICTURE_TYPE_B){
00485 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0};
00486 int mb_type= mb_type_table[s->mv_dir];
00487
00488 if(s->mb_x==0){
00489 for(i=0; i<2; i++){
00490 s->last_mv[i][0][0]=
00491 s->last_mv[i][0][1]=
00492 s->last_mv[i][1][0]=
00493 s->last_mv[i][1][1]= 0;
00494 }
00495 }
00496
00497 assert(s->dquant>=-2 && s->dquant<=2);
00498 assert((s->dquant&1)==0);
00499 assert(mb_type>=0);
00500
00501
00502 if (s->next_picture.f.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]) {
00503 s->skip_count++;
00504 s->mv[0][0][0]=
00505 s->mv[0][0][1]=
00506 s->mv[1][0][0]=
00507 s->mv[1][0][1]= 0;
00508 s->mv_dir= MV_DIR_FORWARD;
00509 s->qscale -= s->dquant;
00510
00511
00512 return;
00513 }
00514
00515 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
00516
00517 if ((cbp | motion_x | motion_y | mb_type) ==0) {
00518
00519 assert(s->dquant==0);
00520
00521 put_bits(&s->pb, 1, 1);
00522
00523 if(interleaved_stats){
00524 s->misc_bits++;
00525 s->last_bits++;
00526 }
00527 s->skip_count++;
00528 return;
00529 }
00530
00531 put_bits(&s->pb, 1, 0);
00532 put_bits(&s->pb, 1, cbp ? 0 : 1);
00533 put_bits(&s->pb, mb_type+1, 1);
00534 if(cbp) put_bits(&s->pb, 6, cbp);
00535
00536 if(cbp && mb_type){
00537 if(s->dquant)
00538 put_bits(&s->pb, 2, (s->dquant>>2)+3);
00539 else
00540 put_bits(&s->pb, 1, 0);
00541 }else
00542 s->qscale -= s->dquant;
00543
00544 if(!s->progressive_sequence){
00545 if(cbp)
00546 put_bits(&s->pb, 1, s->interlaced_dct);
00547 if(mb_type)
00548 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
00549 }
00550
00551 if(interleaved_stats){
00552 s->misc_bits+= get_bits_diff(s);
00553 }
00554
00555 if(mb_type == 0){
00556 assert(s->mv_dir & MV_DIRECT);
00557 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
00558 s->b_count++;
00559 s->f_count++;
00560 }else{
00561 assert(mb_type > 0 && mb_type < 4);
00562 if(s->mv_type != MV_TYPE_FIELD){
00563 if(s->mv_dir & MV_DIR_FORWARD){
00564 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
00565 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
00566 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
00567 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
00568 s->f_count++;
00569 }
00570 if(s->mv_dir & MV_DIR_BACKWARD){
00571 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
00572 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
00573 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
00574 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
00575 s->b_count++;
00576 }
00577 }else{
00578 if(s->mv_dir & MV_DIR_FORWARD){
00579 put_bits(&s->pb, 1, s->field_select[0][0]);
00580 put_bits(&s->pb, 1, s->field_select[0][1]);
00581 }
00582 if(s->mv_dir & MV_DIR_BACKWARD){
00583 put_bits(&s->pb, 1, s->field_select[1][0]);
00584 put_bits(&s->pb, 1, s->field_select[1][1]);
00585 }
00586 if(s->mv_dir & MV_DIR_FORWARD){
00587 for(i=0; i<2; i++){
00588 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
00589 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
00590 s->last_mv[0][i][0]= s->mv[0][i][0];
00591 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
00592 }
00593 s->f_count++;
00594 }
00595 if(s->mv_dir & MV_DIR_BACKWARD){
00596 for(i=0; i<2; i++){
00597 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
00598 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
00599 s->last_mv[1][i][0]= s->mv[1][i][0];
00600 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
00601 }
00602 s->b_count++;
00603 }
00604 }
00605 }
00606
00607 if(interleaved_stats){
00608 s->mv_bits+= get_bits_diff(s);
00609 }
00610
00611 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
00612
00613 if(interleaved_stats){
00614 s->p_tex_bits+= get_bits_diff(s);
00615 }
00616
00617 }else{
00618 cbp= get_p_cbp(s, block, motion_x, motion_y);
00619
00620 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
00621
00622
00623 if(s->max_b_frames>0){
00624 int i;
00625 int x,y, offset;
00626 uint8_t *p_pic;
00627
00628 x= s->mb_x*16;
00629 y= s->mb_y*16;
00630 if(x+16 > s->width) x= s->width-16;
00631 if(y+16 > s->height) y= s->height-16;
00632
00633 offset= x + y*s->linesize;
00634 p_pic = s->new_picture.f.data[0] + offset;
00635
00636 s->mb_skipped=1;
00637 for(i=0; i<s->max_b_frames; i++){
00638 uint8_t *b_pic;
00639 int diff;
00640 Picture *pic= s->reordered_input_picture[i+1];
00641
00642 if (pic == NULL || pic->f.pict_type != AV_PICTURE_TYPE_B)
00643 break;
00644
00645 b_pic = pic->f.data[0] + offset;
00646 if (pic->f.type != FF_BUFFER_TYPE_SHARED)
00647 b_pic+= INPLACE_OFFSET;
00648 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
00649 if(diff>s->qscale*70){
00650 s->mb_skipped=0;
00651 break;
00652 }
00653 }
00654 }else
00655 s->mb_skipped=1;
00656
00657 if(s->mb_skipped==1){
00658
00659 put_bits(&s->pb, 1, 1);
00660
00661 if(interleaved_stats){
00662 s->misc_bits++;
00663 s->last_bits++;
00664 }
00665 s->skip_count++;
00666
00667 return;
00668 }
00669 }
00670
00671 put_bits(&s->pb, 1, 0);
00672 cbpc = cbp & 3;
00673 cbpy = cbp >> 2;
00674 cbpy ^= 0xf;
00675 if(s->mv_type==MV_TYPE_16X16){
00676 if(s->dquant) cbpc+= 8;
00677 put_bits(&s->pb,
00678 ff_h263_inter_MCBPC_bits[cbpc],
00679 ff_h263_inter_MCBPC_code[cbpc]);
00680
00681 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00682 if(s->dquant)
00683 put_bits(pb2, 2, dquant_code[s->dquant+2]);
00684
00685 if(!s->progressive_sequence){
00686 if(cbp)
00687 put_bits(pb2, 1, s->interlaced_dct);
00688 put_bits(pb2, 1, 0);
00689 }
00690
00691 if(interleaved_stats){
00692 s->misc_bits+= get_bits_diff(s);
00693 }
00694
00695
00696 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00697
00698 ff_h263_encode_motion_vector(s, motion_x - pred_x,
00699 motion_y - pred_y, s->f_code);
00700 }else if(s->mv_type==MV_TYPE_FIELD){
00701 if(s->dquant) cbpc+= 8;
00702 put_bits(&s->pb,
00703 ff_h263_inter_MCBPC_bits[cbpc],
00704 ff_h263_inter_MCBPC_code[cbpc]);
00705
00706 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00707 if(s->dquant)
00708 put_bits(pb2, 2, dquant_code[s->dquant+2]);
00709
00710 assert(!s->progressive_sequence);
00711 if(cbp)
00712 put_bits(pb2, 1, s->interlaced_dct);
00713 put_bits(pb2, 1, 1);
00714
00715 if(interleaved_stats){
00716 s->misc_bits+= get_bits_diff(s);
00717 }
00718
00719
00720 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00721 pred_y /=2;
00722
00723 put_bits(&s->pb, 1, s->field_select[0][0]);
00724 put_bits(&s->pb, 1, s->field_select[0][1]);
00725
00726 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
00727 s->mv[0][0][1] - pred_y, s->f_code);
00728 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
00729 s->mv[0][1][1] - pred_y, s->f_code);
00730 }else{
00731 assert(s->mv_type==MV_TYPE_8X8);
00732 put_bits(&s->pb,
00733 ff_h263_inter_MCBPC_bits[cbpc+16],
00734 ff_h263_inter_MCBPC_code[cbpc+16]);
00735 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00736
00737 if(!s->progressive_sequence){
00738 if(cbp)
00739 put_bits(pb2, 1, s->interlaced_dct);
00740 }
00741
00742 if(interleaved_stats){
00743 s->misc_bits+= get_bits_diff(s);
00744 }
00745
00746 for(i=0; i<4; i++){
00747
00748 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
00749
00750 ff_h263_encode_motion_vector(s, s->current_picture.f.motion_val[0][ s->block_index[i] ][0] - pred_x,
00751 s->current_picture.f.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
00752 }
00753 }
00754
00755 if(interleaved_stats){
00756 s->mv_bits+= get_bits_diff(s);
00757 }
00758
00759 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
00760
00761 if(interleaved_stats){
00762 s->p_tex_bits+= get_bits_diff(s);
00763 }
00764 s->f_count++;
00765 }
00766 } else {
00767 int cbp;
00768 int dc_diff[6];
00769 int dir[6];
00770 int zigzag_last_index[6];
00771 uint8_t *scan_table[6];
00772 int i;
00773
00774 for(i=0; i<6; i++){
00775 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
00776 }
00777
00778 if(s->flags & CODEC_FLAG_AC_PRED){
00779 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
00780 }else{
00781 for(i=0; i<6; i++)
00782 scan_table[i]= s->intra_scantable.permutated;
00783 }
00784
00785
00786 cbp = 0;
00787 for (i = 0; i < 6; i++) {
00788 if (s->block_last_index[i] >= 1)
00789 cbp |= 1 << (5 - i);
00790 }
00791
00792 cbpc = cbp & 3;
00793 if (s->pict_type == AV_PICTURE_TYPE_I) {
00794 if(s->dquant) cbpc+=4;
00795 put_bits(&s->pb,
00796 ff_h263_intra_MCBPC_bits[cbpc],
00797 ff_h263_intra_MCBPC_code[cbpc]);
00798 } else {
00799 if(s->dquant) cbpc+=8;
00800 put_bits(&s->pb, 1, 0);
00801 put_bits(&s->pb,
00802 ff_h263_inter_MCBPC_bits[cbpc + 4],
00803 ff_h263_inter_MCBPC_code[cbpc + 4]);
00804 }
00805 put_bits(pb2, 1, s->ac_pred);
00806 cbpy = cbp >> 2;
00807 put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
00808 if(s->dquant)
00809 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
00810
00811 if(!s->progressive_sequence){
00812 put_bits(dc_pb, 1, s->interlaced_dct);
00813 }
00814
00815 if(interleaved_stats){
00816 s->misc_bits+= get_bits_diff(s);
00817 }
00818
00819 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
00820
00821 if(interleaved_stats){
00822 s->i_tex_bits+= get_bits_diff(s);
00823 }
00824 s->i_count++;
00825
00826
00827 if(s->ac_pred)
00828 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
00829 }
00830 }
00831
00835 void ff_mpeg4_stuffing(PutBitContext * pbc)
00836 {
00837 int length;
00838 put_bits(pbc, 1, 0);
00839 length= (-put_bits_count(pbc))&7;
00840 if(length) put_bits(pbc, length, (1<<length)-1);
00841 }
00842
00843
00844 void ff_set_mpeg4_time(MpegEncContext * s){
00845 if(s->pict_type==AV_PICTURE_TYPE_B){
00846 ff_mpeg4_init_direct_mv(s);
00847 }else{
00848 s->last_time_base= s->time_base;
00849 s->time_base= s->time/s->avctx->time_base.den;
00850 }
00851 }
00852
00853 static void mpeg4_encode_gop_header(MpegEncContext * s){
00854 int hours, minutes, seconds;
00855 int64_t time;
00856
00857 put_bits(&s->pb, 16, 0);
00858 put_bits(&s->pb, 16, GOP_STARTCODE);
00859
00860 time = s->current_picture_ptr->f.pts;
00861 if(s->reordered_input_picture[1])
00862 time = FFMIN(time, s->reordered_input_picture[1]->f.pts);
00863 time= time*s->avctx->time_base.num;
00864
00865 seconds= time/s->avctx->time_base.den;
00866 minutes= seconds/60; seconds %= 60;
00867 hours= minutes/60; minutes %= 60;
00868 hours%=24;
00869
00870 put_bits(&s->pb, 5, hours);
00871 put_bits(&s->pb, 6, minutes);
00872 put_bits(&s->pb, 1, 1);
00873 put_bits(&s->pb, 6, seconds);
00874
00875 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
00876 put_bits(&s->pb, 1, 0);
00877
00878 s->last_time_base= time / s->avctx->time_base.den;
00879
00880 ff_mpeg4_stuffing(&s->pb);
00881 }
00882
00883 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
00884 int profile_and_level_indication;
00885 int vo_ver_id;
00886
00887 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
00888 profile_and_level_indication = s->avctx->profile << 4;
00889 }else if(s->max_b_frames || s->quarter_sample){
00890 profile_and_level_indication= 0xF0;
00891 }else{
00892 profile_and_level_indication= 0x00;
00893 }
00894
00895 if(s->avctx->level != FF_LEVEL_UNKNOWN){
00896 profile_and_level_indication |= s->avctx->level;
00897 }else{
00898 profile_and_level_indication |= 1;
00899 }
00900
00901 if(profile_and_level_indication>>4 == 0xF){
00902 vo_ver_id= 5;
00903 }else{
00904 vo_ver_id= 1;
00905 }
00906
00907
00908
00909 put_bits(&s->pb, 16, 0);
00910 put_bits(&s->pb, 16, VOS_STARTCODE);
00911
00912 put_bits(&s->pb, 8, profile_and_level_indication);
00913
00914 put_bits(&s->pb, 16, 0);
00915 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
00916
00917 put_bits(&s->pb, 1, 1);
00918 put_bits(&s->pb, 4, vo_ver_id);
00919 put_bits(&s->pb, 3, 1);
00920
00921 put_bits(&s->pb, 4, 1);
00922
00923 put_bits(&s->pb, 1, 0);
00924
00925 ff_mpeg4_stuffing(&s->pb);
00926 }
00927
00928 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
00929 {
00930 int vo_ver_id;
00931
00932 if (!CONFIG_MPEG4_ENCODER) return;
00933
00934 if(s->max_b_frames || s->quarter_sample){
00935 vo_ver_id= 5;
00936 s->vo_type= ADV_SIMPLE_VO_TYPE;
00937 }else{
00938 vo_ver_id= 1;
00939 s->vo_type= SIMPLE_VO_TYPE;
00940 }
00941
00942 put_bits(&s->pb, 16, 0);
00943 put_bits(&s->pb, 16, 0x100 + vo_number);
00944 put_bits(&s->pb, 16, 0);
00945 put_bits(&s->pb, 16, 0x120 + vol_number);
00946
00947 put_bits(&s->pb, 1, 0);
00948 put_bits(&s->pb, 8, s->vo_type);
00949 if(s->workaround_bugs & FF_BUG_MS) {
00950 put_bits(&s->pb, 1, 0);
00951 } else {
00952 put_bits(&s->pb, 1, 1);
00953 put_bits(&s->pb, 4, vo_ver_id);
00954 put_bits(&s->pb, 3, 1);
00955 }
00956
00957 s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
00958
00959 put_bits(&s->pb, 4, s->aspect_ratio_info);
00960 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
00961 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
00962 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
00963 }
00964
00965 if(s->workaround_bugs & FF_BUG_MS) {
00966 put_bits(&s->pb, 1, 0);
00967 } else {
00968 put_bits(&s->pb, 1, 1);
00969 put_bits(&s->pb, 2, 1);
00970 put_bits(&s->pb, 1, s->low_delay);
00971 put_bits(&s->pb, 1, 0);
00972 }
00973
00974 put_bits(&s->pb, 2, RECT_SHAPE);
00975 put_bits(&s->pb, 1, 1);
00976
00977 put_bits(&s->pb, 16, s->avctx->time_base.den);
00978 if (s->time_increment_bits < 1)
00979 s->time_increment_bits = 1;
00980 put_bits(&s->pb, 1, 1);
00981 put_bits(&s->pb, 1, 0);
00982 put_bits(&s->pb, 1, 1);
00983 put_bits(&s->pb, 13, s->width);
00984 put_bits(&s->pb, 1, 1);
00985 put_bits(&s->pb, 13, s->height);
00986 put_bits(&s->pb, 1, 1);
00987 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
00988 put_bits(&s->pb, 1, 1);
00989 if (vo_ver_id == 1) {
00990 put_bits(&s->pb, 1, s->vol_sprite_usage);
00991 }else{
00992 put_bits(&s->pb, 2, s->vol_sprite_usage);
00993 }
00994
00995 put_bits(&s->pb, 1, 0);
00996 put_bits(&s->pb, 1, s->mpeg_quant);
00997
00998 if(s->mpeg_quant){
00999 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
01000 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
01001 }
01002
01003 if (vo_ver_id != 1)
01004 put_bits(&s->pb, 1, s->quarter_sample);
01005 put_bits(&s->pb, 1, 1);
01006 s->resync_marker= s->rtp_mode;
01007 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);
01008 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
01009 if(s->data_partitioning){
01010 put_bits(&s->pb, 1, 0);
01011 }
01012
01013 if (vo_ver_id != 1){
01014 put_bits(&s->pb, 1, 0);
01015 put_bits(&s->pb, 1, 0);
01016 }
01017 put_bits(&s->pb, 1, 0);
01018
01019 ff_mpeg4_stuffing(&s->pb);
01020
01021
01022 if(!(s->flags & CODEC_FLAG_BITEXACT)){
01023 put_bits(&s->pb, 16, 0);
01024 put_bits(&s->pb, 16, 0x1B2);
01025 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
01026 }
01027 }
01028
01029
01030 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
01031 {
01032 int time_incr;
01033 int time_div, time_mod;
01034
01035 if(s->pict_type==AV_PICTURE_TYPE_I){
01036 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
01037 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT)
01038 mpeg4_encode_visual_object_header(s);
01039 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0)
01040 mpeg4_encode_vol_header(s, 0, 0);
01041 }
01042 if(!(s->workaround_bugs & FF_BUG_MS))
01043 mpeg4_encode_gop_header(s);
01044 }
01045
01046 s->partitioned_frame= s->data_partitioning && s->pict_type!=AV_PICTURE_TYPE_B;
01047
01048 put_bits(&s->pb, 16, 0);
01049 put_bits(&s->pb, 16, VOP_STARTCODE);
01050 put_bits(&s->pb, 2, s->pict_type - 1);
01051
01052 assert(s->time>=0);
01053 time_div= s->time/s->avctx->time_base.den;
01054 time_mod= s->time%s->avctx->time_base.den;
01055 time_incr= time_div - s->last_time_base;
01056 assert(time_incr >= 0);
01057 while(time_incr--)
01058 put_bits(&s->pb, 1, 1);
01059
01060 put_bits(&s->pb, 1, 0);
01061
01062 put_bits(&s->pb, 1, 1);
01063 put_bits(&s->pb, s->time_increment_bits, time_mod);
01064 put_bits(&s->pb, 1, 1);
01065 put_bits(&s->pb, 1, 1);
01066 if ( s->pict_type == AV_PICTURE_TYPE_P
01067 || (s->pict_type == AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE)) {
01068 put_bits(&s->pb, 1, s->no_rounding);
01069 }
01070 put_bits(&s->pb, 3, 0);
01071 if(!s->progressive_sequence){
01072 put_bits(&s->pb, 1, s->current_picture_ptr->f.top_field_first);
01073 put_bits(&s->pb, 1, s->alternate_scan);
01074 }
01075
01076
01077 put_bits(&s->pb, 5, s->qscale);
01078
01079 if (s->pict_type != AV_PICTURE_TYPE_I)
01080 put_bits(&s->pb, 3, s->f_code);
01081 if (s->pict_type == AV_PICTURE_TYPE_B)
01082 put_bits(&s->pb, 3, s->b_code);
01083 }
01084
01085
01086 static void init_uni_dc_tab(void)
01087 {
01088 int level, uni_code, uni_len;
01089
01090 for(level=-256; level<256; level++){
01091 int size, v, l;
01092
01093 size = 0;
01094 v = abs(level);
01095 while (v) {
01096 v >>= 1;
01097 size++;
01098 }
01099
01100 if (level < 0)
01101 l= (-level) ^ ((1 << size) - 1);
01102 else
01103 l= level;
01104
01105
01106 uni_code= ff_mpeg4_DCtab_lum[size][0];
01107 uni_len = ff_mpeg4_DCtab_lum[size][1];
01108
01109 if (size > 0) {
01110 uni_code<<=size; uni_code|=l;
01111 uni_len+=size;
01112 if (size > 8){
01113 uni_code<<=1; uni_code|=1;
01114 uni_len++;
01115 }
01116 }
01117 uni_DCtab_lum_bits[level+256]= uni_code;
01118 uni_DCtab_lum_len [level+256]= uni_len;
01119
01120
01121 uni_code= ff_mpeg4_DCtab_chrom[size][0];
01122 uni_len = ff_mpeg4_DCtab_chrom[size][1];
01123
01124 if (size > 0) {
01125 uni_code<<=size; uni_code|=l;
01126 uni_len+=size;
01127 if (size > 8){
01128 uni_code<<=1; uni_code|=1;
01129 uni_len++;
01130 }
01131 }
01132 uni_DCtab_chrom_bits[level+256]= uni_code;
01133 uni_DCtab_chrom_len [level+256]= uni_len;
01134
01135 }
01136 }
01137
01138 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01139 int slevel, run, last;
01140
01141 assert(MAX_LEVEL >= 64);
01142 assert(MAX_RUN >= 63);
01143
01144 for(slevel=-64; slevel<64; slevel++){
01145 if(slevel==0) continue;
01146 for(run=0; run<64; run++){
01147 for(last=0; last<=1; last++){
01148 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01149 int level= slevel < 0 ? -slevel : slevel;
01150 int sign= slevel < 0 ? 1 : 0;
01151 int bits, len, code;
01152 int level1, run1;
01153
01154 len_tab[index]= 100;
01155
01156
01157 code= get_rl_index(rl, last, run, level);
01158 bits= rl->table_vlc[code][0];
01159 len= rl->table_vlc[code][1];
01160 bits=bits*2+sign; len++;
01161
01162 if(code!=rl->n && len < len_tab[index]){
01163 bits_tab[index]= bits;
01164 len_tab [index]= len;
01165 }
01166
01167 bits= rl->table_vlc[rl->n][0];
01168 len= rl->table_vlc[rl->n][1];
01169 bits=bits*2; len++;
01170 level1= level - rl->max_level[last][run];
01171 if(level1>0){
01172 code= get_rl_index(rl, last, run, level1);
01173 bits<<= rl->table_vlc[code][1];
01174 len += rl->table_vlc[code][1];
01175 bits += rl->table_vlc[code][0];
01176 bits=bits*2+sign; len++;
01177
01178 if(code!=rl->n && len < len_tab[index]){
01179 bits_tab[index]= bits;
01180 len_tab [index]= len;
01181 }
01182 }
01183
01184 bits= rl->table_vlc[rl->n][0];
01185 len= rl->table_vlc[rl->n][1];
01186 bits=bits*4+2; len+=2;
01187 run1 = run - rl->max_run[last][level] - 1;
01188 if(run1>=0){
01189 code= get_rl_index(rl, last, run1, level);
01190 bits<<= rl->table_vlc[code][1];
01191 len += rl->table_vlc[code][1];
01192 bits += rl->table_vlc[code][0];
01193 bits=bits*2+sign; len++;
01194
01195 if(code!=rl->n && len < len_tab[index]){
01196 bits_tab[index]= bits;
01197 len_tab [index]= len;
01198 }
01199 }
01200
01201 bits= rl->table_vlc[rl->n][0];
01202 len = rl->table_vlc[rl->n][1];
01203 bits=bits*4+3; len+=2;
01204 bits=bits*2+last; len++;
01205 bits=bits*64+run; len+=6;
01206 bits=bits*2+1; len++;
01207 bits=bits*4096+(slevel&0xfff); len+=12;
01208 bits=bits*2+1; len++;
01209
01210 if(len < len_tab[index]){
01211 bits_tab[index]= bits;
01212 len_tab [index]= len;
01213 }
01214 }
01215 }
01216 }
01217 }
01218
01219 static av_cold int encode_init(AVCodecContext *avctx)
01220 {
01221 MpegEncContext *s = avctx->priv_data;
01222 int ret;
01223 static int done = 0;
01224
01225 if((ret=MPV_encode_init(avctx)) < 0)
01226 return ret;
01227
01228 if (!done) {
01229 done = 1;
01230
01231 init_uni_dc_tab();
01232
01233 init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
01234
01235 init_uni_mpeg4_rl_tab(&ff_mpeg4_rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
01236 init_uni_mpeg4_rl_tab(&ff_h263_rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
01237 }
01238
01239 s->min_qcoeff= -2048;
01240 s->max_qcoeff= 2047;
01241 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
01242 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
01243 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
01244 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
01245 s->luma_dc_vlc_length= uni_DCtab_lum_len;
01246 s->ac_esc_length= 7+2+1+6+1+12+1;
01247 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
01248 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
01249
01250 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
01251
01252 s->avctx->extradata= av_malloc(1024);
01253 init_put_bits(&s->pb, s->avctx->extradata, 1024);
01254
01255 if(!(s->workaround_bugs & FF_BUG_MS))
01256 mpeg4_encode_visual_object_header(s);
01257 mpeg4_encode_vol_header(s, 0, 0);
01258
01259
01260 flush_put_bits(&s->pb);
01261 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
01262 }
01263 return 0;
01264 }
01265
01266 void ff_mpeg4_init_partitions(MpegEncContext *s)
01267 {
01268 uint8_t *start= put_bits_ptr(&s->pb);
01269 uint8_t *end= s->pb.buf_end;
01270 int size= end - start;
01271 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start;
01272 int tex_size= (size - 2*pb_size)&(~3);
01273
01274 set_put_bits_buffer_size(&s->pb, pb_size);
01275 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
01276 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
01277 }
01278
01279 void ff_mpeg4_merge_partitions(MpegEncContext *s)
01280 {
01281 const int pb2_len = put_bits_count(&s->pb2 );
01282 const int tex_pb_len= put_bits_count(&s->tex_pb);
01283 const int bits= put_bits_count(&s->pb);
01284
01285 if(s->pict_type==AV_PICTURE_TYPE_I){
01286 put_bits(&s->pb, 19, DC_MARKER);
01287 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
01288 s->i_tex_bits+= tex_pb_len;
01289 }else{
01290 put_bits(&s->pb, 17, MOTION_MARKER);
01291 s->misc_bits+=17 + pb2_len;
01292 s->mv_bits+= bits - s->last_bits;
01293 s->p_tex_bits+= tex_pb_len;
01294 }
01295
01296 flush_put_bits(&s->pb2);
01297 flush_put_bits(&s->tex_pb);
01298
01299 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
01300 avpriv_copy_bits(&s->pb, s->pb2.buf , pb2_len);
01301 avpriv_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
01302 s->last_bits= put_bits_count(&s->pb);
01303 }
01304
01305
01306 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
01307 {
01308 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
01309
01310 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
01311 put_bits(&s->pb, 1, 1);
01312
01313 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
01314 put_bits(&s->pb, s->quant_precision, s->qscale);
01315 put_bits(&s->pb, 1, 0);
01316 }
01317
01318 #define OFFSET(x) offsetof(MpegEncContext, x)
01319 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
01320 static const AVOption options[] = {
01321 { "data_partitioning", "Use data partitioning.", OFFSET(data_partitioning), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
01322 { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_INT, { 0 }, 0, 1, VE },
01323 { NULL },
01324 };
01325
01326 static const AVClass mpeg4enc_class = {
01327 .class_name = "MPEG4 encoder",
01328 .item_name = av_default_item_name,
01329 .option = options,
01330 .version = LIBAVUTIL_VERSION_INT,
01331 };
01332
01333 AVCodec ff_mpeg4_encoder = {
01334 .name = "mpeg4",
01335 .type = AVMEDIA_TYPE_VIDEO,
01336 .id = CODEC_ID_MPEG4,
01337 .priv_data_size = sizeof(MpegEncContext),
01338 .init = encode_init,
01339 .encode = MPV_encode_picture,
01340 .close = MPV_encode_end,
01341 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
01342 .capabilities= CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
01343 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
01344 .priv_class = &mpeg4enc_class,
01345 };