virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

fixed ratecontrol & b-frames

Browse Source 
2pass ratecontrol
fixed hq with 2pass
inceased build num (a few more vars for the rc stuff)
hopefully no new bugs

Originally committed as revision 408 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michael Niedermayer 2002-04-21 21:18:17 +00:00
parent 2c029cd19d
commit 8b4c7dbc55
5 changed files with 515 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libavcodec/Makefile
View File

@ -6,7 +6,8 @@ LDFLAGS= -g
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

15
libavcodec/avcodec.h
View File

@ -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 @@ static const int Motion_Est_QTab[] = { 1, 4, 3, 6, 5, 2 };
#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 @@ typedef struct AVCodecContext {
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;

213
libavcodec/mpegvideo.c
View File

@ -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 @@ int MPV_encode_init(AVCodecContext *avctx)
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 @@ int MPV_encode_init(AVCodecContext *avctx)
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 @@ int MPV_encode_end(AVCodecContext *avctx)
#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 @@ void MPV_frame_start(MpegEncContext *s)
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 @@ void MPV_frame_end(MpegEncContext *s)
}
}
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 @@ int MPV_encode_picture(AVCodecContext *avctx,
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;
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
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 {
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 @@ int MPV_encode_picture(AVCodecContext *avctx,
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 @@ static void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int
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 @@ static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int
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 @@ static void encode_picture(MpegEncContext *s, int picture_number)
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 @@ static void encode_picture(MpegEncContext *s, int picture_number)
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 @@ static void encode_picture(MpegEncContext *s, int picture_number)
// 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 @@ static void encode_picture(MpegEncContext *s, int picture_number)
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 @@ static void encode_picture(MpegEncContext *s, int picture_number)
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 @@ static void dct_unquantize_h263_c(MpegEncContext *s,
}
}
/* 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,

47
libavcodec/mpegvideo.h
View File

@ -44,6 +44,24 @@ typedef struct Predictor{
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 @@ typedef struct MpegEncContext {
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 @@ typedef struct MpegEncContext {
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 @@ typedef struct MpegEncContext {
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 @@ typedef struct MpegEncContext {
/* 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 @@ void mjpeg_encode_mb(MpegEncContext *s,
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);

405
libavcodec/ratecontrol.c Normal file
View File

@ -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;
}