Mercurial > libavcodec.hg
annotate ratecontrol.c @ 409:2b9ded215201 libavcodec
* restored previous behaviour for this moment
users are supposed to supply proper SCR_PATH however
author | kabi |
---|---|
date | Tue, 21 May 2002 22:18:12 +0000 |
parents | fce0a2520551 |
children | dd4f4c3d7171 |
rev | line source |
---|---|
329 | 1 /* |
2 Copyright (C) 2002 Michael Niedermayer <michaelni@gmx.at> | |
3 | |
4 This program is free software; you can redistribute it and/or modify | |
5 it under the terms of the GNU General Public License as published by | |
6 the Free Software Foundation; either version 2 of the License, or | |
7 (at your option) any later version. | |
8 | |
9 This program is distributed in the hope that it will be useful, | |
10 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 GNU General Public License for more details. | |
13 | |
14 You should have received a copy of the GNU General Public License | |
15 along with this program; if not, write to the Free Software | |
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
17 */ | |
18 | |
19 #include <inttypes.h> | |
20 #include <stdio.h> | |
21 | |
22 #include "common.h" //needed for mpegvideo.h to compile | |
23 #include "dsputil.h" //needed for mpegvideo.h to compile | |
24 #include "avcodec.h" | |
25 #include "mpegvideo.h" | |
26 | |
27 #define STATS_FILE "lavc_stats.txt" | |
28 | |
29 static int init_pass2(MpegEncContext *s); | |
30 | |
31 void ff_write_pass1_stats(MpegEncContext *s){ | |
32 RateControlContext *rcc= &s->rc_context; | |
33 // 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\") | |
34 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", | |
35 s->picture_number, s->input_picture_number - s->max_b_frames, s->pict_type, | |
36 s->qscale, s->i_tex_bits, s->p_tex_bits, s->mv_bits, s->misc_bits, s->f_code, s->b_code); | |
37 } | |
38 | |
39 int ff_rate_control_init(MpegEncContext *s) | |
40 { | |
41 RateControlContext *rcc= &s->rc_context; | |
42 emms_c(); | |
43 | |
44 if(s->flags&CODEC_FLAG_PASS1){ | |
45 rcc->stats_file= fopen(STATS_FILE, "w"); | |
46 if(!rcc->stats_file){ | |
47 fprintf(stderr, "failed to open " STATS_FILE "\n"); | |
48 return -1; | |
49 } | |
50 } else if(s->flags&CODEC_FLAG_PASS2){ | |
51 int size; | |
52 int i; | |
53 | |
54 rcc->stats_file= fopen(STATS_FILE, "r"); | |
55 if(!rcc->stats_file){ | |
56 fprintf(stderr, "failed to open " STATS_FILE "\n"); | |
57 return -1; | |
58 } | |
59 | |
60 /* find number of pics without reading the file twice :) */ | |
61 fseek(rcc->stats_file, 0, SEEK_END); | |
62 size= ftell(rcc->stats_file); | |
63 fseek(rcc->stats_file, 0, SEEK_SET); | |
64 | |
65 size/= 64; // we need at least 64 byte to store a line ... | |
66 rcc->entry = (RateControlEntry*)av_mallocz(size*sizeof(RateControlEntry)); | |
67 | |
68 for(i=0; !feof(rcc->stats_file); i++){ | |
69 RateControlEntry *rce; | |
70 int picture_number; | |
71 int e; | |
72 | |
73 e= fscanf(rcc->stats_file, "in:%d ", &picture_number); | |
74 rce= &rcc->entry[picture_number]; | |
75 e+=fscanf(rcc->stats_file, "out:%*d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d fcode:%*d bcode:%*d\n", | |
76 &rce->pict_type, &rce->qscale, &rce->i_tex_bits, &rce->p_tex_bits, &rce->mv_bits, &rce->misc_bits); | |
77 if(e!=7){ | |
78 fprintf(stderr, STATS_FILE " is damaged\n"); | |
79 return -1; | |
80 } | |
81 } | |
82 rcc->num_entries= i; | |
83 | |
84 if(init_pass2(s) < 0) return -1; | |
85 } | |
86 | |
87 /* no 2pass stuff, just normal 1-pass */ | |
88 //initial values, they dont really matter as they will be totally different within a few frames | |
89 s->i_pred.coeff= s->p_pred.coeff= 7.0; | |
90 s->i_pred.count= s->p_pred.count= 1.0; | |
91 | |
92 s->i_pred.decay= s->p_pred.decay= 0.4; | |
93 | |
94 // use more bits at the beginning, otherwise high motion at the begin will look like shit | |
95 s->qsum=100 * s->qmin; | |
96 s->qcount=100; | |
97 | |
98 s->short_term_qsum=0.001; | |
99 s->short_term_qcount=0.001; | |
100 | |
101 return 0; | |
102 } | |
103 | |
104 void ff_rate_control_uninit(MpegEncContext *s) | |
105 { | |
106 RateControlContext *rcc= &s->rc_context; | |
107 emms_c(); | |
108 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
109 if(rcc->stats_file) |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
110 fclose(rcc->stats_file); |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
111 rcc->stats_file = NULL; |
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
388
diff
changeset
|
112 av_freep(&rcc->entry); |
329 | 113 } |
114 | |
115 //---------------------------------- | |
116 // 1 Pass Code | |
117 | |
118 static double predict(Predictor *p, double q, double var) | |
119 { | |
120 return p->coeff*var / (q*p->count); | |
121 } | |
122 | |
123 static void update_predictor(Predictor *p, double q, double var, double size) | |
124 { | |
125 double new_coeff= size*q / (var + 1); | |
126 if(var<1000) return; | |
127 | |
128 p->count*= p->decay; | |
129 p->coeff*= p->decay; | |
130 p->count++; | |
131 p->coeff+= new_coeff; | |
132 } | |
133 | |
134 int ff_rate_estimate_qscale(MpegEncContext *s) | |
135 { | |
136 int qmin= s->qmin; | |
137 int qmax= s->qmax; | |
138 int rate_q=5; | |
139 float q; | |
140 int qscale; | |
141 float br_compensation; | |
142 double diff; | |
143 double short_term_q; | |
144 double long_term_q; | |
145 double fps; | |
146 int picture_number= s->input_picture_number - s->max_b_frames; | |
147 int64_t wanted_bits; | |
148 emms_c(); | |
149 | |
150 fps= (double)s->frame_rate / FRAME_RATE_BASE; | |
151 wanted_bits= (uint64_t)(s->bit_rate*(double)picture_number/fps); | |
152 // printf("%d %d %d\n", picture_number, (int)wanted_bits, (int)s->total_bits); | |
153 | |
154 if(s->pict_type==B_TYPE){ | |
155 qmin= (int)(qmin*s->b_quant_factor+0.5); | |
156 qmax= (int)(qmax*s->b_quant_factor+0.5); | |
157 } | |
388 | 158 if(qmin<1) qmin=1; |
329 | 159 if(qmax>31) qmax=31; |
160 if(qmax<=qmin) qmax= qmin; | |
161 | |
162 /* update predictors */ | |
163 if(picture_number>2){ | |
164 if(s->pict_type!=B_TYPE && s->last_non_b_pict_type == P_TYPE){ | |
165 //printf("%d %d %d %f\n", s->qscale, s->last_mc_mb_var, s->frame_bits, s->p_pred.coeff); | |
166 update_predictor(&s->p_pred, s->last_non_b_qscale, s->last_non_b_mc_mb_var, s->pb_frame_bits); | |
167 } | |
168 } | |
169 | |
170 if(s->pict_type == I_TYPE){ | |
171 short_term_q= s->short_term_qsum/s->short_term_qcount; | |
172 | |
173 long_term_q= s->qsum/s->qcount*(s->total_bits+1)/(wanted_bits+1); //+1 to avoid nan & 0 | |
174 | |
175 q= 1/((1/long_term_q - 1/short_term_q)*s->qcompress + 1/short_term_q); | |
176 }else if(s->pict_type==B_TYPE){ | |
177 q= (int)(s->last_non_b_qscale*s->b_quant_factor+0.5); | |
178 }else{ //P Frame | |
179 int i; | |
180 int diff, best_diff=1000000000; | |
181 for(i=1; i<=31; i++){ | |
182 diff= predict(&s->p_pred, i, s->mc_mb_var) - (double)s->bit_rate/fps; | |
183 if(diff<0) diff= -diff; | |
184 if(diff<best_diff){ | |
185 best_diff= diff; | |
186 rate_q= i; | |
187 } | |
188 } | |
189 s->short_term_qsum*=s->qblur; | |
190 s->short_term_qcount*=s->qblur; | |
191 | |
192 s->short_term_qsum+= rate_q; | |
193 s->short_term_qcount++; | |
194 short_term_q= s->short_term_qsum/s->short_term_qcount; | |
195 | |
196 long_term_q= s->qsum/s->qcount*(s->total_bits+1)/(wanted_bits+1); //+1 to avoid nan & 0 | |
197 | |
198 // q= (long_term_q - short_term_q)*s->qcompress + short_term_q; | |
199 q= 1/((1/long_term_q - 1/short_term_q)*s->qcompress + 1/short_term_q); | |
200 } | |
201 | |
202 diff= s->total_bits - wanted_bits; | |
203 br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance; | |
204 if(br_compensation<=0.0) br_compensation=0.001; | |
205 q/=br_compensation; | |
206 //printf("%f %f %f\n", q, br_compensation, short_term_q); | |
207 qscale= (int)(q + 0.5); | |
208 if (qscale<qmin) qscale=qmin; | |
209 else if(qscale>qmax) qscale=qmax; | |
210 | |
211 if(s->pict_type!=B_TYPE){ | |
212 s->qsum+= qscale; | |
213 s->qcount++; | |
214 if (qscale<s->last_non_b_qscale-s->max_qdiff) qscale=s->last_non_b_qscale-s->max_qdiff; | |
215 else if(qscale>s->last_non_b_qscale+s->max_qdiff) qscale=s->last_non_b_qscale+s->max_qdiff; | |
216 } | |
217 //printf("q:%d diff:%d comp:%f rate_q:%d st_q:%f fvar:%d last_size:%d\n", qscale, (int)diff, br_compensation, | |
218 // rate_q, short_term_q, s->mc_mb_var, s->frame_bits); | |
219 //printf("%d %d\n", s->bit_rate, (int)fps); | |
220 return qscale; | |
221 } | |
222 | |
223 //---------------------------------------------- | |
224 // 2-Pass code | |
225 | |
226 static int init_pass2(MpegEncContext *s) | |
227 { | |
228 RateControlContext *rcc= &s->rc_context; | |
229 int i; | |
230 double fps= (double)s->frame_rate / FRAME_RATE_BASE; | |
231 double complexity[5]={0,0,0,0,0}; // aproximate bits at quant=1 | |
232 double avg_quantizer[5]; | |
233 uint64_t const_bits[5]={0,0,0,0,0}; // quantizer idependant bits | |
234 uint64_t available_bits[5]; | |
235 uint64_t all_const_bits; | |
236 uint64_t all_available_bits= (uint64_t)(s->bit_rate*(double)rcc->num_entries/fps); | |
237 int num_frames[5]={0,0,0,0,0}; | |
238 double rate_factor=0; | |
239 double step; | |
240 int last_i_frame=-10000000; | |
241 | |
242 /* find complexity & const_bits & decide the pict_types */ | |
243 for(i=0; i<rcc->num_entries; i++){ | |
244 RateControlEntry *rce= &rcc->entry[i]; | |
245 | |
246 if(s->b_frame_strategy==0 || s->max_b_frames==0){ | |
247 rce->new_pict_type= rce->pict_type; | |
248 }else{ | |
249 int j; | |
250 int next_non_b_type=P_TYPE; | |
251 | |
252 switch(rce->pict_type){ | |
253 case I_TYPE: | |
254 if(i-last_i_frame>s->gop_size/2){ //FIXME this is not optimal | |
255 rce->new_pict_type= I_TYPE; | |
256 last_i_frame= i; | |
257 }else{ | |
258 rce->new_pict_type= P_TYPE; // will be caught by the scene detection anyway | |
259 } | |
260 break; | |
261 case P_TYPE: | |
262 rce->new_pict_type= P_TYPE; | |
263 break; | |
264 case B_TYPE: | |
265 for(j=i+1; j<i+s->max_b_frames+2 && j<rcc->num_entries; j++){ | |
266 if(rcc->entry[j].pict_type != B_TYPE){ | |
267 next_non_b_type= rcc->entry[j].pict_type; | |
268 break; | |
269 } | |
270 } | |
271 if(next_non_b_type==I_TYPE) | |
272 rce->new_pict_type= P_TYPE; | |
273 else | |
274 rce->new_pict_type= B_TYPE; | |
275 break; | |
276 } | |
277 } | |
278 | |
279 complexity[rce->new_pict_type]+= (rce->i_tex_bits+ rce->p_tex_bits)*(double)rce->qscale; | |
280 const_bits[rce->new_pict_type]+= rce->mv_bits + rce->misc_bits; | |
281 num_frames[rce->new_pict_type]++; | |
282 } | |
283 all_const_bits= const_bits[I_TYPE] + const_bits[P_TYPE] + const_bits[B_TYPE]; | |
284 | |
285 if(all_available_bits < all_const_bits){ | |
286 fprintf(stderr, "requested bitrate is to low\n"); | |
287 return -1; | |
288 } | |
289 | |
290 // avg_complexity= complexity/rcc->num_entries; | |
291 avg_quantizer[P_TYPE]= | |
292 avg_quantizer[I_TYPE]= (complexity[I_TYPE]+complexity[P_TYPE] + complexity[B_TYPE]/s->b_quant_factor) | |
293 / (all_available_bits - all_const_bits); | |
294 avg_quantizer[B_TYPE]= avg_quantizer[P_TYPE]*s->b_quant_factor; | |
295 //printf("avg quantizer: %f %f\n", avg_quantizer[P_TYPE], avg_quantizer[B_TYPE]); | |
296 | |
297 for(i=0; i<5; i++){ | |
298 available_bits[i]= const_bits[i] + complexity[i]/avg_quantizer[i]; | |
299 } | |
300 //printf("%lld %lld %lld %lld\n", available_bits[I_TYPE], available_bits[P_TYPE], available_bits[B_TYPE], all_available_bits); | |
301 | |
302 for(step=256*256; step>0.0000001; step*=0.5){ | |
303 uint64_t expected_bits=0; | |
304 rate_factor+= step; | |
305 /* find qscale */ | |
306 for(i=0; i<rcc->num_entries; i++){ | |
307 RateControlEntry *rce= &rcc->entry[i]; | |
308 double short_term_q, q, bits_left; | |
309 const int pict_type= rce->new_pict_type; | |
310 int qmin= s->qmin; | |
311 int qmax= s->qmax; | |
312 | |
313 if(pict_type==B_TYPE){ | |
314 qmin= (int)(qmin*s->b_quant_factor+0.5); | |
315 qmax= (int)(qmax*s->b_quant_factor+0.5); | |
316 } | |
388 | 317 if(qmin<1) qmin=1; |
329 | 318 if(qmax>31) qmax=31; |
319 if(qmax<=qmin) qmax= qmin; | |
320 | |
321 switch(s->rc_strategy){ | |
322 case 0: | |
323 bits_left= available_bits[pict_type]/num_frames[pict_type]*rate_factor - rce->misc_bits - rce->mv_bits; | |
324 if(bits_left<1.0) bits_left=1.0; | |
325 short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits)/bits_left; | |
326 break; | |
327 case 1: | |
328 bits_left= (available_bits[pict_type] - const_bits[pict_type])/num_frames[pict_type]*rate_factor; | |
329 if(bits_left<1.0) bits_left=1.0; | |
330 short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits)/bits_left; | |
331 break; | |
332 case 2: | |
333 bits_left= available_bits[pict_type]/num_frames[pict_type]*rate_factor; | |
334 if(bits_left<1.0) bits_left=1.0; | |
335 short_term_q= rce->qscale*(rce->i_tex_bits + rce->p_tex_bits + rce->misc_bits + rce->mv_bits)/bits_left; | |
336 break; | |
337 default: | |
338 fprintf(stderr, "unknown strategy\n"); | |
339 short_term_q=3; //gcc warning fix | |
340 } | |
341 | |
342 if(short_term_q>31.0) short_term_q=31.0; | |
343 else if (short_term_q<1.0) short_term_q=1.0; | |
344 | |
345 q= 1/((1/avg_quantizer[pict_type] - 1/short_term_q)*s->qcompress + 1/short_term_q); | |
346 if (q<qmin) q=qmin; | |
347 else if(q>qmax) q=qmax; | |
348 //printf("lq:%f, sq:%f t:%f q:%f\n", avg_quantizer[rce->pict_type], short_term_q, bits_left, q); | |
349 rce->new_qscale= q; | |
350 } | |
351 | |
352 /* smooth curve */ | |
353 | |
354 /* find expected bits */ | |
355 for(i=0; i<rcc->num_entries; i++){ | |
356 RateControlEntry *rce= &rcc->entry[i]; | |
357 double factor= rce->qscale / rce->new_qscale; | |
358 | |
359 rce->expected_bits= expected_bits; | |
360 expected_bits += (int)(rce->misc_bits + rce->mv_bits + (rce->i_tex_bits + rce->p_tex_bits)*factor + 0.5); | |
361 } | |
362 | |
363 // printf("%d %d %f\n", (int)expected_bits, (int)all_available_bits, rate_factor); | |
364 if(expected_bits > all_available_bits) rate_factor-= step; | |
365 } | |
366 | |
367 return 0; | |
368 } | |
369 | |
370 int ff_rate_estimate_qscale_pass2(MpegEncContext *s) | |
371 { | |
372 int qmin= s->qmin; | |
373 int qmax= s->qmax; | |
374 float q; | |
375 int qscale; | |
376 float br_compensation; | |
377 double diff; | |
378 int picture_number= s->picture_number; | |
379 RateControlEntry *rce= &s->rc_context.entry[picture_number]; | |
380 int64_t wanted_bits= rce->expected_bits; | |
381 emms_c(); | |
382 | |
383 // printf("%d %d %d\n", picture_number, (int)wanted_bits, (int)s->total_bits); | |
384 | |
385 if(s->pict_type==B_TYPE){ | |
386 qmin= (int)(qmin*s->b_quant_factor+0.5); | |
387 qmax= (int)(qmax*s->b_quant_factor+0.5); | |
388 } | |
388 | 389 if(qmin<1) qmin=1; |
329 | 390 if(qmax>31) qmax=31; |
391 if(qmax<=qmin) qmax= qmin; | |
392 | |
393 q= rce->new_qscale; | |
394 | |
395 diff= s->total_bits - wanted_bits; | |
396 br_compensation= (s->bit_rate_tolerance - diff)/s->bit_rate_tolerance; | |
397 if(br_compensation<=0.0) br_compensation=0.001; | |
398 q/=br_compensation; | |
399 | |
400 qscale= (int)(q + 0.5); | |
401 if (qscale<qmin) qscale=qmin; | |
402 else if(qscale>qmax) qscale=qmax; | |
403 // printf("%d %d %d %d type:%d\n", qmin, qscale, qmax, picture_number, s->pict_type); fflush(stdout); | |
404 return qscale; | |
405 } |