Mercurial > libavcodec.hg
changeset 329:5cc47d0ba53e libavcodec
fixed ratecontrol & b-frames
2pass ratecontrol
fixed hq with 2pass
inceased build num (a few more vars for the rc stuff)
hopefully no new bugs
| author | michaelni |
|---|---|
| date | Sun, 21 Apr 2002 21:18:17 +0000 |
| parents | 025825084364 |
| children | 54d86f074a4b |
| files | Makefile avcodec.h mpegvideo.c mpegvideo.h ratecontrol.c |
| diffstat | 5 files changed, 515 insertions(+), 168 deletions(-) [+] |
line wrap: on
line diff
--- a/Makefile Sat Apr 20 21:17:26 2002 +0000 +++ b/Makefile Sun Apr 21 21:18:17 2002 +0000 @@ -6,7 +6,8 @@ OBJS= common.o utils.o mpegvideo.o h263.o jrevdct.o jfdctfst.o \ mpegaudio.o ac3enc.o mjpeg.o resample.o dsputil.o \ motion_est.o imgconvert.o imgresample.o msmpeg4.o \ - mpeg12.o h263dec.o rv10.o mpegaudiodec.o pcm.o simple_idct.o + mpeg12.o h263dec.o rv10.o mpegaudiodec.o pcm.o simple_idct.o \ + ratecontrol.o ASM_OBJS= # currently using libac3 for ac3 decoding
--- a/avcodec.h Sat Apr 20 21:17:26 2002 +0000 +++ b/avcodec.h Sun Apr 21 21:18:17 2002 +0000 @@ -5,8 +5,8 @@ #define LIBAVCODEC_VERSION_INT 0x000406 #define LIBAVCODEC_VERSION "0.4.6" -#define LIBAVCODEC_BUILD 4600 -#define LIBAVCODEC_BUILD_STR "4600" +#define LIBAVCODEC_BUILD 4601 +#define LIBAVCODEC_BUILD_STR "4601" enum CodecID { CODEC_ID_NONE, @@ -90,7 +90,9 @@ #define CODEC_FLAG_TYPE 0x0040 /* fixed I/P frame type, from avctx->key_frame */ /* parent program gurantees that the input for b-frame containing streams is not written to for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */ -#define CODEC_FLAG_INPUT_PRESERVED 0x0100 +#define CODEC_FLAG_INPUT_PRESERVED 0x0100 +#define CODEC_FLAG_PASS1 0x0200 /* use internal 2pass ratecontrol in first pass mode */ +#define CODEC_FLAG_PASS2 0x0400 /* use internal 2pass ratecontrol in second pass mode */ /* codec capabilities */ @@ -139,13 +141,18 @@ int key_frame; /* true if the previous compressed frame was a key frame (intra, or seekable) */ int quality; /* quality of the previous encoded frame - (between 1 (good) and 31 (bad)) */ + (between 1 (good) and 31 (bad)) + this is allso used to set the quality in vbr mode + and the per frame quality in CODEC_FLAG_TYPE (second pass mode) */ float qcompress; /* amount of qscale change between easy & hard scenes (0.0-1.0)*/ float qblur; /* amount of qscale smoothing over time (0.0-1.0) */ int qmin; /* min qscale */ int qmax; /* max qscale */ int max_qdiff; /* max qscale difference between frames */ int max_b_frames; /* maximum b frames, the output will be delayed by max_b_frames+1 relative to the input */ + float b_quant_factor;/* qscale factor between ips and b frames */ + int rc_strategy; + int b_frame_strategy; struct AVCodec *codec; void *priv_data;
--- a/mpegvideo.c Sat Apr 20 21:17:26 2002 +0000 +++ b/mpegvideo.c Sun Apr 21 21:18:17 2002 +0000 @@ -31,8 +31,6 @@ #endif static void encode_picture(MpegEncContext *s, int picture_number); -static void rate_control_init(MpegEncContext *s); -static int rate_estimate_qscale(MpegEncContext *s); static void dct_unquantize_mpeg1_c(MpegEncContext *s, DCTELEM *block, int n, int qscale); static void dct_unquantize_mpeg2_c(MpegEncContext *s, @@ -377,10 +375,13 @@ s->max_qdiff= avctx->max_qdiff; s->qcompress= avctx->qcompress; s->qblur= avctx->qblur; + s->b_quant_factor= avctx->b_quant_factor; s->avctx = avctx; s->aspect_ratio_info= avctx->aspect_ratio_info; s->flags= avctx->flags; s->max_b_frames= avctx->max_b_frames; + s->rc_strategy= avctx->rc_strategy; + s->b_frame_strategy= avctx->b_frame_strategy; if (s->gop_size <= 1) { s->intra_only = 1; @@ -510,8 +511,8 @@ s->non_intra_matrix[i] = default_non_intra_matrix[i]; } - /* rate control init */ - rate_control_init(s); + if(ff_rate_control_init(s) < 0) + return -1; s->picture_number = 0; s->picture_in_gop_number = 0; @@ -530,6 +531,9 @@ #ifdef STATS print_stats(); #endif + + ff_rate_control_uninit(s); + MPV_common_end(s); if (s->out_format == FMT_MJPEG) mjpeg_close(s); @@ -577,7 +581,6 @@ s->current_picture[i] = s->aux_picture[i]; } } else { - s->last_non_b_pict_type= s->pict_type; for(i=0;i<3;i++) { /* swap next and last */ tmp = s->last_picture[i]; @@ -605,6 +608,12 @@ } } emms_c(); + + if(s->pict_type!=B_TYPE){ + s->last_non_b_pict_type= s->pict_type; + s->last_non_b_qscale= s->qscale; + s->last_non_b_mc_mb_var= s->mc_mb_var; + } } /* reorder input for encoding */ @@ -695,25 +704,34 @@ init_put_bits(&s->pb, buf, buf_size, NULL, NULL); - s->force_input_type= (avctx->flags&CODEC_FLAG_TYPE) ? - (avctx->key_frame ? I_TYPE : P_TYPE) : 0; - if (!s->intra_only) { - /* first picture of GOP is intra */ - if (s->input_picture_in_gop_number % s->gop_size==0 || s->force_input_type==I_TYPE){ - s->input_picture_in_gop_number=0; + if(avctx->flags&CODEC_FLAG_TYPE){ + s->input_pict_type= + s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE; + }else if(s->flags&CODEC_FLAG_PASS2){ + s->input_pict_type= + s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type; + }else{ + s->force_input_type=0; + if (!s->intra_only) { + /* first picture of GOP is intra */ + if (s->input_picture_in_gop_number % s->gop_size==0){ + s->input_pict_type = I_TYPE; + }else if(s->max_b_frames==0){ + s->input_pict_type = P_TYPE; + }else{ + if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ + s->input_pict_type = B_TYPE; + else + s->input_pict_type = P_TYPE; + } + } else { s->input_pict_type = I_TYPE; - }else if(s->max_b_frames==0){ - s->input_pict_type = P_TYPE; - }else{ - if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ - s->input_pict_type = B_TYPE; - else - s->input_pict_type = P_TYPE; } - } else { - s->input_pict_type = I_TYPE; } + if(s->input_pict_type==I_TYPE) + s->input_picture_in_gop_number=0; + reorder_input(s, pict); /* output? */ @@ -745,14 +763,19 @@ mjpeg_picture_trailer(s); avctx->quality = s->qscale; + + if(s->flags&CODEC_FLAG_PASS1) + ff_write_pass1_stats(s); } s->input_picture_number++; s->input_picture_in_gop_number++; flush_put_bits(&s->pb); - s->last_frame_bits= s->frame_bits; s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8; + if(s->pict_type==B_TYPE) s->pb_frame_bits+= s->frame_bits; + else s->pb_frame_bits= s->frame_bits; + s->total_bits += s->frame_bits; avctx->frame_bits = s->frame_bits; //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n", @@ -1425,7 +1448,7 @@ d->p_count= s->p_count; d->skip_count= s->skip_count; d->misc_bits= s->misc_bits; - d->last_bits= s->last_bits; + d->last_bits= 0; d->mb_skiped= s->mb_skiped; } @@ -1449,7 +1472,6 @@ d->p_count= s->p_count; d->skip_count= s->skip_count; d->misc_bits= s->misc_bits; - d->last_bits= s->last_bits; d->mb_intra= s->mb_intra; d->mb_skiped= s->mb_skiped; @@ -1479,7 +1501,6 @@ s->block_wrap[4]= s->block_wrap[5]= s->mb_width + 2; - s->last_mc_mb_var = s->mc_mb_var; /* Reset the average MB variance */ s->avg_mb_var = 0; s->mc_mb_var = 0; @@ -1524,12 +1545,13 @@ memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height); } - if(s->avg_mb_var < s->mc_mb_var && s->pict_type != B_TYPE && (!s->force_type) && s->max_b_frames==0){ //FIXME subtract MV bits - // FIXME b-frames & scene change detection - s->input_pict_type= I_TYPE; + if(s->avg_mb_var < s->mc_mb_var && s->pict_type == P_TYPE){ //FIXME subtract MV bits s->pict_type= I_TYPE; - s->input_picture_in_gop_number=0; memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height); + if(s->max_b_frames==0){ + s->input_pict_type= I_TYPE; + s->input_picture_in_gop_number=0; + } //printf("Scene change detected, encoding as I Frame\n"); } @@ -1550,8 +1572,11 @@ // printf("%d %d\n", s->avg_mb_var, s->mc_mb_var); - if (!s->fixed_qscale) - s->qscale = rate_estimate_qscale(s); + if(s->flags&CODEC_FLAG_PASS2) + s->qscale = ff_rate_estimate_qscale_pass2(s); + else if (!s->fixed_qscale) + s->qscale = ff_rate_estimate_qscale(s); + /* precompute matrix */ if (s->out_format == FMT_MJPEG) { @@ -1667,6 +1692,7 @@ s->mv[0][0][1] = s->p_mv_table[xy][1]; init_put_bits(&s->pb, bit_buf[1], 3000, NULL, NULL); s->block= s->blocks[next_block]; + s->last_bits= 0; //done in copy_context_before_encode but we skip that here encode_mb(s, s->mv[0][0][0], s->mv[0][0][1]); d= get_bit_count(&s->pb); @@ -1810,6 +1836,7 @@ copy_context_after_encode(s, &best_s, -1); copy_bits(&pb, bit_buf[best], dmin); s->pb= pb; + s->last_bits= get_bit_count(&s->pb); } else { int motion_x, motion_y; s->mv_type=MV_TYPE_16X16; @@ -2190,132 +2217,6 @@ } } -/* rate control */ - -static void rate_control_init(MpegEncContext *s) -{ - emms_c(); - - //initial values, they dont really matter as they will be totally different within a few frames - s->i_pred.coeff= s->p_pred.coeff= 7.0; - s->i_pred.count= s->p_pred.count= 1.0; - - s->i_pred.decay= s->p_pred.decay= 0.4; - - // use more bits at the beginning, otherwise high motion at the begin will look like shit - s->qsum=100; - s->qcount=100; - - s->short_term_qsum=0.001; - s->short_term_qcount=0.001; -} - -static double predict(Predictor *p, double q, double var) -{ - return p->coeff*var / (q*p->count); -} - -static void update_predictor(Predictor *p, double q, double var, double size) -{ - double new_coeff= size*q / (var + 1); - if(var<1000) return; -/*{ -int pred= predict(p, q, var); -int error= abs(pred-size); -static double sum=0; -static int count=0; -if(count>5) sum+=error; -count++; -if(256*256*256*64%count==0){ - printf("%d %f %f\n", count, sum/count, p->coeff); -} -}*/ - p->count*= p->decay; - p->coeff*= p->decay; - p->count++; - p->coeff+= new_coeff; -} - -static int rate_estimate_qscale(MpegEncContext *s) -{ - int qmin= s->qmin; - int qmax= s->qmax; - int rate_q=5; - float q; - int qscale; - float br_compensation; - double diff; - double short_term_q; - double long_term_q; - int last_qscale= s->qscale; - double fps; - INT64 wanted_bits; - emms_c(); - - fps= (double)s->frame_rate / FRAME_RATE_BASE; - wanted_bits= s->bit_rate*(double)s->picture_number/fps; - - - if(s->picture_number>2){ - /* update predictors */ - if(s->last_pict_type == I_TYPE){ - //FIXME - }else{ //P Frame -//printf("%d %d %d %f\n", s->qscale, s->last_mc_mb_var, s->frame_bits, s->p_pred.coeff); - update_predictor(&s->p_pred, s->qscale, s->last_mc_mb_var, s->frame_bits); - } - } - - if(s->pict_type == I_TYPE){ - //FIXME - rate_q= s->qsum/s->qcount; - }else{ //P Frame - int i; - int diff, best_diff=1000000000; - for(i=1; i<=31; i++){ - diff= predict(&s->p_pred, i, s->mc_mb_var) - (double)s->bit_rate/fps; - if(diff<0) diff= -diff; - if(diff<best_diff){ - best_diff= diff; - rate_q= i; - } - } - } - - s->short_term_qsum*=s->qblur; - s->short_term_qcount*=s->qblur; - - s->short_term_qsum+= rate_q; - s->short_term_qcount++; - short_term_q= s->short_term_qsum/s->short_term_qcount; - - long_term_q= s->qsum/s->qcount*(s->total_bits+1)/(wanted_bits+1); //+1 to avoid nan & 0 - -// q= (long_term_q - short_term_q)*s->qcompress + short_term_q; - q= 1/((1/long_term_q - 1/short_term_q)*s->qcompress + 1/short_term_q); - - diff= s->total_bits - wanted_bits; - br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance; - if(br_compensation<=0.0) br_compensation=0.001; - q/=br_compensation; - - qscale= (int)(q + 0.5); - if (qscale<qmin) qscale=qmin; - else if(qscale>qmax) qscale=qmax; - - if (qscale<last_qscale-s->max_qdiff) qscale=last_qscale-s->max_qdiff; - else if(qscale>last_qscale+s->max_qdiff) qscale=last_qscale+s->max_qdiff; - - s->qsum+= qscale; - s->qcount++; - - s->last_pict_type= s->pict_type; -//printf("q:%d diff:%d comp:%f rate_q:%d st_q:%f fvar:%d last_size:%d\n", qscale, (int)diff, br_compensation, -// rate_q, short_term_q, s->mc_mb_var, s->frame_bits); -//printf("%d %d\n", s->bit_rate, (int)fps); - return qscale; -} - AVCodec mpeg1video_encoder = { "mpeg1video", CODEC_TYPE_VIDEO,
--- a/mpegvideo.h Sat Apr 20 21:17:26 2002 +0000 +++ b/mpegvideo.h Sun Apr 21 21:18:17 2002 +0000 @@ -44,6 +44,24 @@ double decay; } Predictor; +typedef struct RateControlEntry{ + int pict_type; + int qscale; + int mv_bits; + int i_tex_bits; + int p_tex_bits; + int misc_bits; + uint64_t expected_bits; + int new_pict_type; + float new_qscale; +}RateControlEntry; + +typedef struct RateControlContext{ + FILE *stats_file; + int num_entries; + RateControlEntry *entry; +}RateControlContext; + typedef struct ReorderBuffer{ UINT8 *picture[3]; int pict_type; @@ -78,6 +96,9 @@ int flags; /* AVCodecContext.flags (HQ, MV4, ...) */ int force_input_type;/* 0= no force, otherwise I_TYPE, P_TYPE, ... */ int max_b_frames; /* max number of b-frames for encoding */ + float b_quant_factor;/* qscale factor between ips and b frames */ + int rc_strategy; + int b_frame_strategy; /* the following fields are managed internally by the encoder */ /* bit output */ @@ -121,9 +142,9 @@ int input_pict_type; /* pict_type prior to reordering of frames */ int force_type; /* 0= no force, otherwise I_TYPE, P_TYPE, ... */ int qscale; /* QP */ + int last_non_b_qscale; /* QP of last non b frame used for b frame qscale*/ int pict_type; /* I_TYPE, P_TYPE, B_TYPE, ... */ - int last_non_b_pict_type; /* used for mpeg4 gmc b-frames */ - int last_pict_type; /* used for bit rate stuff (needs that to update the right predictor) */ + int last_non_b_pict_type; /* used for mpeg4 gmc b-frames & ratecontrol */ int frame_rate_index; /* motion compensation */ int unrestricted_mv; @@ -195,7 +216,7 @@ int q_intra_matrix[64]; int q_non_intra_matrix[64]; /* identical to the above but for MMX & these are not permutated */ - UINT16 __align8 q_intra_matrix16[64] ; + UINT16 __align8 q_intra_matrix16[64]; UINT16 __align8 q_non_intra_matrix16[64]; int block_last_index[6]; /* last non zero coefficient in block */ @@ -204,18 +225,19 @@ /* bit rate control */ int I_frame_bits; //FIXME used in mpeg12 ... int avg_mb_var; /* average MB variance for current frame */ - int mc_mb_var; /* motion compensated MB variance for current frame */ - int last_mc_mb_var; /* motion compensated MB variance for last frame */ + int mc_mb_var; /* motion compensated MB variance for current frame */ + int last_non_b_mc_mb_var;/* motion compensated MB variance for last non b frame */ INT64 wanted_bits; INT64 total_bits; - int frame_bits; /* bits used for the current frame */ - int last_frame_bits; /* bits used for the last frame */ + int frame_bits; /* bits used for the current frame */ + int pb_frame_bits; /* bits of the last b...bp group */ Predictor i_pred; Predictor p_pred; double qsum; /* sum of qscales */ double qcount; /* count of qscales */ double short_term_qsum; /* sum of recent qscales */ double short_term_qcount; /* count of recent qscales */ + RateControlContext rc_context; /* statistics, used for 2-pass encoding */ int mv_bits; @@ -459,3 +481,14 @@ DCTELEM block[6][64]); void mjpeg_picture_header(MpegEncContext *s); void mjpeg_picture_trailer(MpegEncContext *s); + +/* rate control */ +int ff_rate_control_init(MpegEncContext *s); +int ff_rate_estimate_qscale(MpegEncContext *s); +int ff_rate_estimate_qscale_pass2(MpegEncContext *s); +void ff_write_pass1_stats(MpegEncContext *s); +void ff_rate_control_uninit(MpegEncContext *s); + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ratecontrol.c Sun Apr 21 21:18:17 2002 +0000 @@ -0,0 +1,405 @@ +/* + Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include <inttypes.h> +#include <stdio.h> + +#include "common.h" //needed for mpegvideo.h to compile +#include "dsputil.h" //needed for mpegvideo.h to compile +#include "avcodec.h" +#include "mpegvideo.h" + +#define STATS_FILE "lavc_stats.txt" + +static int init_pass2(MpegEncContext *s); + +void ff_write_pass1_stats(MpegEncContext *s){ + RateControlContext *rcc= &s->rc_context; +// fprintf(c->stats_file, "type:%d q:%d icount:%d pcount:%d scount:%d itex:%d ptex%d mv:%d misc:%d fcode:%d bcode:%d\") + fprintf(rcc->stats_file, "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d fcode:%d bcode:%d\n", + s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type, + s->qscale, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, s->f_code, s->b_code); +} + +int ff_rate_control_init(MpegEncContext *s) +{ + RateControlContext *rcc= &s->rc_context; + emms_c(); + + if(s->flags&CODEC_FLAG_PASS1){ + rcc->stats_file= fopen(STATS_FILE, "w"); + if(!rcc->stats_file){ + fprintf(stderr, "failed to open " STATS_FILE "\n"); + return -1; + } + } else if(s->flags&CODEC_FLAG_PASS2){ + int size; + int i; + + rcc->stats_file= fopen(STATS_FILE, "r"); + if(!rcc->stats_file){ + fprintf(stderr, "failed to open " STATS_FILE "\n"); + return -1; + } + + /* find number of pics without reading the file twice :) */ + fseek(rcc->stats_file, 0, SEEK_END); + size= ftell(rcc->stats_file); + fseek(rcc->stats_file, 0, SEEK_SET); + + size/= 64; // we need at least 64 byte to store a line ... + rcc->entry = (RateControlEntry*)av_mallocz(size*sizeof(RateControlEntry)); + + for(i=0; !feof(rcc->stats_file); i++){ + RateControlEntry *rce; + int picture_number; + int e; + + e= fscanf(rcc->stats_file, "in:%d ", &picture_number); + rce= &rcc->entry[picture_number]; + e+=fscanf(rcc->stats_file, "out:%*d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d fcode:%*d bcode:%*d\n", + &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits); + if(e!=7){ + fprintf(stderr, STATS_FILE " is damaged\n"); + return -1; + } + } + rcc->num_entries= i; + + if(init_pass2(s) < 0) return -1; + } + + /* no 2pass stuff, just normal 1-pass */ + //initial values, they dont really matter as they will be totally different within a few frames + s->i_pred.coeff= s->p_pred.coeff= 7.0; + s->i_pred.count= s->p_pred.count= 1.0; + + s->i_pred.decay= s->p_pred.decay= 0.4; + + // use more bits at the beginning, otherwise high motion at the begin will look like shit + s->qsum=100 * s->qmin; + s->qcount=100; + + s->short_term_qsum=0.001; + s->short_term_qcount=0.001; + + return 0; +} + +void ff_rate_control_uninit(MpegEncContext *s) +{ + RateControlContext *rcc= &s->rc_context; + emms_c(); + + if(rcc->stats_file) fclose(rcc->stats_file); + if(rcc->entry) free(rcc->entry); + rcc->stats_file= NULL; + rcc->entry= NULL; +} + +//---------------------------------- +// 1 Pass Code + +static double predict(Predictor *p, double q, double var) +{ + return p->coeff*var / (q*p->count); +} + +static void update_predictor(Predictor *p, double q, double var, double size) +{ + double new_coeff= size*q / (var + 1); + if(var<1000) return; + + p->count*= p->decay; + p->coeff*= p->decay; + p->count++; + p->coeff+= new_coeff; +} + +int ff_rate_estimate_qscale(MpegEncContext *s) +{ + int qmin= s->qmin; + int qmax= s->qmax; + int rate_q=5; + float q; + int qscale; + float br_compensation; + double diff; + double short_term_q; + double long_term_q; + double fps; + int picture_number= s->input_picture_number - s->max_b_frames; + int64_t wanted_bits; + emms_c(); + + fps= (double)s->frame_rate / FRAME_RATE_BASE; + wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps); +// printf("%d %d %d\n", picture_number, (int)wanted_bits, (int)s->total_bits); + + if(s->pict_type==B_TYPE){ + qmin= (int)(qmin*s->b_quant_factor+0.5); + qmax= (int)(qmax*s->b_quant_factor+0.5); + } + if(qmin<2) qmin=2; + if(qmax>31) qmax=31; + if(qmax<=qmin) qmax= qmin; + + /* update predictors */ + if(picture_number>2){ + if(s->pict_type!=B_TYPE && s->last_non_b_pict_type == P_TYPE){ +//printf("%d %d %d %f\n", s->qscale, s->last_mc_mb_var, s->frame_bits, s->p_pred.coeff); + update_predictor(&s->p_pred, s->last_non_b_qscale, s->last_non_b_mc_mb_var, s->pb_frame_bits); + } + } + + if(s->pict_type == I_TYPE){ + short_term_q= s->short_term_qsum/s->short_term_qcount; + + long_term_q= s->qsum/s->qcount*(s->total_bits+1)/(wanted_bits+1); //+1 to avoid nan & 0 + + q= 1/((1/long_term_q - 1/short_term_q)*s->qcompress + 1/short_term_q); + }else if(s->pict_type==B_TYPE){ + q= (int)(s->last_non_b_qscale*s->b_quant_factor+0.5); + }else{ //P Frame + int i; + int diff, best_diff=1000000000; + for(i=1; i<=31; i++){ + diff= predict(&s->p_pred, i, s->mc_mb_var) - (double)s->bit_rate/fps; + if(diff<0) diff= -diff; + if(diff<best_diff){ + best_diff= diff; + rate_q= i; + } + } + s->short_term_qsum*=s->qblur; + s->short_term_qcount*=s->qblur; + + s->short_term_qsum+= rate_q; + s->short_term_qcount++; + short_term_q= s->short_term_qsum/s->short_term_qcount; + + long_term_q= s->qsum/s->qcount*(s->total_bits+1)/(wanted_bits+1); //+1 to avoid nan & 0 + +// q= (long_term_q - short_term_q)*s->qcompress + short_term_q; + q= 1/((1/long_term_q - 1/short_term_q)*s->qcompress + 1/short_term_q); + } + + diff= s->total_bits - wanted_bits; + br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance; + if(br_compensation<=0.0) br_compensation=0.001; + q/=br_compensation; +//printf("%f %f %f\n", q, br_compensation, short_term_q); + qscale= (int)(q + 0.5); + if (qscale<qmin) qscale=qmin; + else if(qscale>qmax) qscale=qmax; + + if(s->pict_type!=B_TYPE){ + s->qsum+= qscale; + s->qcount++; + if (qscale<s->last_non_b_qscale-s->max_qdiff) qscale=s->last_non_b_qscale-s->max_qdiff; + else if(qscale>s->last_non_b_qscale+s->max_qdiff) qscale=s->last_non_b_qscale+s->max_qdiff; + } +//printf("q:%d diff:%d comp:%f rate_q:%d st_q:%f fvar:%d last_size:%d\n", qscale, (int)diff, br_compensation, +// rate_q, short_term_q, s->mc_mb_var, s->frame_bits); +//printf("%d %d\n", s->bit_rate, (int)fps); + return qscale; +} + +//---------------------------------------------- +// 2-Pass code + +static int init_pass2(MpegEncContext *s) +{ + RateControlContext *rcc= &s->rc_context; + int i; + double fps= (double)s->frame_rate / FRAME_RATE_BASE; + double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1 + double avg_quantizer[5]; + uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits + uint64_t available_bits[5]; + uint64_t all_const_bits; + uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps); + int num_frames[5]={0,0,0,0,0}; + double rate_factor=0; + double step; + int last_i_frame=-10000000; + + /* find complexity & const_bits & decide the pict_types */ + for(i=0; i<rcc->num_entries; i++){ + RateControlEntry *rce= &rcc->entry[i]; + + if(s->b_frame_strategy==0 || s->max_b_frames==0){ + rce->new_pict_type= rce->pict_type; + }else{ + int j; + int next_non_b_type=P_TYPE; + + switch(rce->pict_type){ + case I_TYPE: + if(i-last_i_frame>s->gop_size/2){ //FIXME this is not optimal + rce->new_pict_type= I_TYPE; + last_i_frame= i; + }else{ + rce->new_pict_type= P_TYPE; // will be caught by the scene detection anyway + } + break; + case P_TYPE: + rce->new_pict_type= P_TYPE; + break; + case B_TYPE: + for(j=i+1; j<i+s->max_b_frames+2 && j<rcc->num_entries; j++){ + if(rcc->entry[j].pict_type != B_TYPE){ + next_non_b_type= rcc->entry[j].pict_type; + break; + } + } + if(next_non_b_type==I_TYPE) + rce->new_pict_type= P_TYPE; + else + rce->new_pict_type= B_TYPE; + break; + } + } + + complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale; + const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits; + num_frames[rce->new_pict_type]++; + } + all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE]; + + if(all_available_bits < all_const_bits){ + fprintf(stderr, "requested bitrate is to low\n"); + return -1; + } + +// avg_complexity= complexity/rcc->num_entries; + avg_quantizer[P_TYPE]= + avg_quantizer[I_TYPE]= (complexity[I_TYPE]+complexity[P_TYPE] + complexity[B_TYPE]/s->b_quant_factor) + / (all_available_bits - all_const_bits); + avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*s->b_quant_factor; +//printf("avg quantizer: %f %f\n", avg_quantizer[P_TYPE], avg_quantizer[B_TYPE]); + + for(i=0; i<5; i++){ + available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i]; + } +//printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits); + + for(step=256*256; step>0.0000001; step*=0.5){ + uint64_t expected_bits=0; + rate_factor+= step; + /* find qscale */ + for(i=0; i<rcc->num_entries; i++){ + RateControlEntry *rce= &rcc->entry[i]; + double short_term_q, q, bits_left; + const int pict_type= rce->new_pict_type; + int qmin= s->qmin; + int qmax= s->qmax; + + if(pict_type==B_TYPE){ + qmin= (int)(qmin*s->b_quant_factor+0.5); + qmax= (int)(qmax*s->b_quant_factor+0.5); + } + if(qmin<2) qmin=2; + if(qmax>31) qmax=31; + if(qmax<=qmin) qmax= qmin; + + switch(s->rc_strategy){ + case 0: + bits_left= available_bits[pict_type]/num_frames[pict_type]*rate_factor - rce->misc_bits - rce->mv_bits; + if(bits_left<1.0) bits_left=1.0; + short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits)/bits_left; + break; + case 1: + bits_left= (available_bits[pict_type] - const_bits[pict_type])/num_frames[pict_type]*rate_factor; + if(bits_left<1.0) bits_left=1.0; + short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits)/bits_left; + break; + case 2: + bits_left= available_bits[pict_type]/num_frames[pict_type]*rate_factor; + if(bits_left<1.0) bits_left=1.0; + short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits + rce->misc_bits + rce->mv_bits)/bits_left; + break; + default: + fprintf(stderr, "unknown strategy\n"); + short_term_q=3; //gcc warning fix + } + + if(short_term_q>31.0) short_term_q=31.0; + else if (short_term_q<1.0) short_term_q=1.0; + + q= 1/((1/avg_quantizer[pict_type] - 1/short_term_q)*s->qcompress + 1/short_term_q); + if (q<qmin) q=qmin; + else if(q>qmax) q=qmax; +//printf("lq:%f, sq:%f t:%f q:%f\n", avg_quantizer[rce->pict_type], short_term_q, bits_left, q); + rce->new_qscale= q; + } + + /* smooth curve */ + + /* find expected bits */ + for(i=0; i<rcc->num_entries; i++){ + RateControlEntry *rce= &rcc->entry[i]; + double factor= rce->qscale / rce->new_qscale; + + rce->expected_bits= expected_bits; + expected_bits += (int)(rce->misc_bits + rce->mv_bits + (rce->i_tex_bits + rce->p_tex_bits)*factor + 0.5); + } + +// printf("%d %d %f\n", (int)expected_bits, (int)all_available_bits, rate_factor); + if(expected_bits > all_available_bits) rate_factor-= step; + } + + return 0; +} + +int ff_rate_estimate_qscale_pass2(MpegEncContext *s) +{ + int qmin= s->qmin; + int qmax= s->qmax; + float q; + int qscale; + float br_compensation; + double diff; + int picture_number= s->picture_number; + RateControlEntry *rce= &s->rc_context.entry[picture_number]; + int64_t wanted_bits= rce->expected_bits; + emms_c(); + +// printf("%d %d %d\n", picture_number, (int)wanted_bits, (int)s->total_bits); + + if(s->pict_type==B_TYPE){ + qmin= (int)(qmin*s->b_quant_factor+0.5); + qmax= (int)(qmax*s->b_quant_factor+0.5); + } + if(qmin<2) qmin=2; + if(qmax>31) qmax=31; + if(qmax<=qmin) qmax= qmin; + + q= rce->new_qscale; + + diff= s->total_bits - wanted_bits; + br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance; + if(br_compensation<=0.0) br_compensation=0.001; + q/=br_compensation; + + qscale= (int)(q + 0.5); + if (qscale<qmin) qscale=qmin; + else if(qscale>qmax) qscale=qmax; +// printf("%d %d %d %d type:%d\n", qmin, qscale, qmax, picture_number, s->pict_type); fflush(stdout); + return qscale; +}