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