[svn] / branches / dev-api-4 / xvidcore / src / plugins / plugin_2pass2.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/src/plugins/plugin_2pass2.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1204 - (view) (download)

1 : suxen_drol 942 /******************************************************************************
2 :     *
3 : edgomez 1054 * XviD Bit Rate Controller Library
4 :     * - VBR 2 pass bitrate controller implementation -
5 : suxen_drol 942 *
6 : edgomez 1054 * Copyright (C) 2002 Foxer <email?>
7 :     * 2002 Dirk Knop <dknop@gwdg.de>
8 :     * 2002-2003 Edouard Gomez <ed.gomez@free.fr>
9 :     * 2003 Pete Ross <pross@xvid.org>
10 : suxen_drol 942 *
11 : edgomez 1054 * This curve treatment algorithm is the one originally implemented by Foxer
12 :     * and tuned by Dirk Knop for the XviD vfw frontend.
13 : suxen_drol 942 *
14 : edgomez 1054 * This program is free software; you can redistribute it and/or modify
15 :     * it under the terms of the GNU General Public License as published by
16 :     * the Free Software Foundation; either version 2 of the License, or
17 :     * (at your option) any later version.
18 : suxen_drol 942 *
19 : edgomez 1054 * This program is distributed in the hope that it will be useful,
20 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 :     * GNU General Public License for more details.
23 : suxen_drol 942 *
24 : edgomez 1054 * You should have received a copy of the GNU General Public License
25 :     * along with this program; if not, write to the Free Software
26 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 : suxen_drol 942 *
28 : edgomez 1204 * $Id: plugin_2pass2.c,v 1.1.2.25 2003-11-13 22:35:30 edgomez Exp $
29 : suxen_drol 942 *
30 :     *****************************************************************************/
31 :    
32 : edgomez 1202 #undef COMPENSATE_FORMULA
33 :    
34 : suxen_drol 942 #include <stdio.h>
35 :     #include <math.h>
36 : edgomez 1040 #include <limits.h>
37 : suxen_drol 942
38 : edgomez 1042 #include "../xvid.h"
39 :     #include "../image/image.h"
40 :    
41 :     /*****************************************************************************
42 :     * Some constants
43 :     ****************************************************************************/
44 :    
45 :     #define DEFAULT_KEYFRAME_BOOST 0
46 : edgomez 1202 #define DEFAULT_OVERFLOW_CONTROL_STRENGTH 10
47 : edgomez 1042 #define DEFAULT_CURVE_COMPRESSION_HIGH 0
48 :     #define DEFAULT_CURVE_COMPRESSION_LOW 0
49 :     #define DEFAULT_MAX_OVERFLOW_IMPROVEMENT 60
50 :     #define DEFAULT_MAX_OVERFLOW_DEGRADATION 60
51 : suxen_drol 942
52 : edgomez 1042 /* Keyframe settings */
53 :     #define DEFAULT_KFREDUCTION 20
54 :     #define DEFAULT_MIN_KEY_INTERVAL 1
55 :    
56 :     /*****************************************************************************
57 :     * Structures
58 :     ****************************************************************************/
59 :    
60 :     /* Statistics */
61 : suxen_drol 942 typedef struct {
62 : edgomez 1064 int type; /* first pass type */
63 :     int quant; /* first pass quant */
64 : edgomez 1202 int quant2; /* Second pass quant */
65 : suxen_drol 977 int blks[3]; /* k,m,y blks */
66 : edgomez 1064 int length; /* first pass length */
67 :     int scaled_length; /* scaled length */
68 : edgomez 1202 int desired_length; /* desired length; calculated during encoding */
69 :     int error;
70 : suxen_drol 1030
71 : edgomez 1064 int zone_mode; /* XVID_ZONE_xxx */
72 :     double weight;
73 : edgomez 1202 } twopass_stat_t;
74 : suxen_drol 942
75 : edgomez 1042 /* Context struct */
76 : suxen_drol 942 typedef struct
77 :     {
78 : edgomez 1064 xvid_plugin_2pass2_t param;
79 : suxen_drol 942
80 : edgomez 1202 /*----------------------------------
81 :     * constant statistical data
82 :     *--------------------------------*/
83 :    
84 :     /* Number of frames of the sequence */
85 : suxen_drol 977 int num_frames;
86 : edgomez 1202
87 :     /* Number of Intra frames of the sequence */
88 : edgomez 1048 int num_keyframes;
89 : suxen_drol 1030
90 : edgomez 1202 /* Target filesize to reach */
91 :     uint64_t target;
92 : suxen_drol 1030
93 : edgomez 1202 /* Count of each frame types */
94 :     int count[3];
95 : suxen_drol 1030
96 : edgomez 1202 /* Total length of each frame types (1st pass) */
97 :     uint64_t tot_length[3];
98 : suxen_drol 942
99 : edgomez 1202 /* Average length of each frame types (used first for 1st pass data and
100 :     * then for scaled averages */
101 :     double avg_length[3];
102 : suxen_drol 942
103 : edgomez 1202 /* Minimum frame length allowed for each frame type */
104 :     int min_length[3];
105 : suxen_drol 1030
106 : edgomez 1202 /* Total bytes per frame type once the curve has been scaled
107 :     * NB: advanced parameters do not change this value. This field
108 :     * represents the total scaled w/o any advanced settings */
109 :     uint64_t tot_scaled_length[3];
110 :    
111 :     /* Maximum observed frame size observed during the first pass, the RC
112 :     * will try tp force all frame sizes in the second pass to be under that
113 :     * limit */
114 :     int max_length;
115 :    
116 :     /*----------------------------------
117 :     * Zones statistical data
118 :     *
119 :     * ToDo: Fix zones, current
120 :     * implementation is buggy
121 :     *--------------------------------*/
122 :    
123 :     /* Average weight of the zones */
124 :     double avg_weight;
125 :    
126 :     /* Total length used by XVID_ZONE_QUANT zones */
127 :     int64_t tot_quant;
128 :    
129 :     /*----------------------------------
130 :     * Advanced settings helper ratios
131 :     *--------------------------------*/
132 :    
133 :     /* This the ratio that has to be applied to all p/b frames in order
134 :     * to reserve/retrieve bits for/from keyframe boosting and consecutive
135 :     * keyframe penalty */
136 :     double pb_iboost_tax_ratio;
137 :    
138 :     /* This the ratio to apply to all b/p frames in order to respect the
139 :     * assymetric curve compression while respecting a target filesize
140 :     * NB: The assymetric delta gain has to be computed before this ratio
141 :     * is applied, and then the delta is added to the scaled size */
142 :     double assymetric_tax_ratio;
143 :    
144 :     /*----------------------------------
145 :     * Data from the stats file kept
146 :     * into RAM for easy access
147 :     *--------------------------------*/
148 :    
149 :     /* Array of keyframe locations
150 :     * eg: rc->keyframe_locations[100] returns the frame number of the 100th
151 :     * keyframe */
152 :     int *keyframe_locations;
153 :    
154 :     /* Index of the last keyframe used in the keyframe_location */
155 :     int KF_idx;
156 :    
157 :     /* Array of all 1st pass data file -- see the twopass_stat_t structure
158 :     * definition for more details */
159 :     twopass_stat_t * stats;
160 :    
161 :     /*----------------------------------
162 :     * Histerysis helpers
163 :     *--------------------------------*/
164 :    
165 :     /* This field holds the int2float conversion errors of each quant per
166 :     * frame type, this allow the RC to keep track of rouding error and thus
167 :     * increase or decrease the chosen quant according to this residue */
168 : edgomez 1048 double quant_error[3][32];
169 : edgomez 1202
170 :     /* This fields stores the count of each quant usage per frame type
171 :     * No real role but for debugging */
172 :     int quant_count[3][32];
173 :    
174 :     /* Last valid quantizer used per frame type, it allows quantizer
175 :     * increament/decreament limitation in order to avoid big image quality
176 :     * "jumps" */
177 : edgomez 1048 int last_quant[3];
178 :    
179 : edgomez 1202 /*----------------------------------
180 :     * Overflow control
181 :     *--------------------------------*/
182 : edgomez 1048
183 : edgomez 1202 /* Current overflow that has to be distributed to p/b frames */
184 :     double overflow;
185 :    
186 :     /* Total overflow for keyframes -- not distributed directly */
187 :     double KFoverflow;
188 :    
189 :     /* Amount of keyframe overflow to introduce to the global p/b frame
190 :     * overflow counter at each encoded frame */
191 :     double KFoverflow_partial;
192 :    
193 :     /* Unknown ???
194 :     * ToDo: description */
195 : edgomez 1048 double fq_error;
196 : edgomez 1202
197 :     /*----------------------------------
198 :     * Debug
199 :     *--------------------------------*/
200 :     double desired_total;
201 :     double real_total;
202 : suxen_drol 942 } rc_2pass2_t;
203 :    
204 :    
205 : edgomez 1042 /*****************************************************************************
206 :     * Sub plugin functions prototypes
207 :     ****************************************************************************/
208 : suxen_drol 942
209 : edgomez 1042 static int rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t ** handle);
210 :     static int rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data);
211 :     static int rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data);
212 :     static int rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy);
213 : suxen_drol 942
214 : edgomez 1042 /*****************************************************************************
215 :     * Plugin definition
216 :     ****************************************************************************/
217 : suxen_drol 942
218 : edgomez 1042 int
219 :     xvid_plugin_2pass2(void * handle, int opt, void * param1, void * param2)
220 : suxen_drol 942 {
221 : edgomez 1064 switch(opt) {
222 :     case XVID_PLG_INFO :
223 :     return 0;
224 : suxen_drol 942
225 : edgomez 1064 case XVID_PLG_CREATE :
226 :     return rc_2pass2_create((xvid_plg_create_t*)param1, param2);
227 : suxen_drol 942
228 : edgomez 1064 case XVID_PLG_DESTROY :
229 :     return rc_2pass2_destroy((rc_2pass2_t*)handle, (xvid_plg_destroy_t*)param1);
230 : suxen_drol 942
231 : edgomez 1064 case XVID_PLG_BEFORE :
232 :     return rc_2pass2_before((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
233 : suxen_drol 942
234 : edgomez 1064 case XVID_PLG_AFTER :
235 :     return rc_2pass2_after((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
236 :     }
237 : edgomez 1037
238 : edgomez 1064 return XVID_ERR_FAIL;
239 : suxen_drol 977 }
240 :    
241 : edgomez 1042 /*****************************************************************************
242 :     * Sub plugin functions definitions
243 :     ****************************************************************************/
244 : suxen_drol 977
245 : edgomez 1042 /* First a few local helping function prototypes */
246 : edgomez 1202 static int statsfile_count_frames(rc_2pass2_t * rc, char * filename);
247 :     static int statsfile_load(rc_2pass2_t *rc, char * filename);
248 : edgomez 1042 static void zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create);
249 : edgomez 1202 static void first_pass_stats_prepare_data(rc_2pass2_t * rc);
250 :     static void first_pass_scale_curve_internal(rc_2pass2_t *rc);
251 :     static void scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc);
252 :     #if 0
253 :     static void stats_print(rc_2pass2_t * rc);
254 :     #endif
255 : suxen_drol 977
256 : edgomez 1042 /*----------------------------------------------------------------------------
257 :     *--------------------------------------------------------------------------*/
258 : suxen_drol 942
259 : edgomez 1042 static int
260 :     rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t **handle)
261 : suxen_drol 942 {
262 : edgomez 1064 xvid_plugin_2pass2_t * param = (xvid_plugin_2pass2_t *)create->param;
263 :     rc_2pass2_t * rc;
264 :     int i;
265 : suxen_drol 942
266 : edgomez 1064 rc = malloc(sizeof(rc_2pass2_t));
267 : edgomez 1161 if (rc == NULL)
268 : edgomez 1064 return XVID_ERR_MEMORY;
269 : suxen_drol 942
270 : edgomez 1064 rc->param = *param;
271 : suxen_drol 942
272 : edgomez 1202 /* Initialize all defaults */
273 : edgomez 1042 #define _INIT(a, b) if((a) <= 0) (a) = (b)
274 : edgomez 1064 /* Let's set our defaults if needed */
275 : edgomez 1042 _INIT(rc->param.keyframe_boost, DEFAULT_KEYFRAME_BOOST);
276 : edgomez 1202 _INIT(rc->param.overflow_control_strength, DEFAULT_OVERFLOW_CONTROL_STRENGTH);
277 : edgomez 1064 _INIT(rc->param.curve_compression_high, DEFAULT_CURVE_COMPRESSION_HIGH);
278 :     _INIT(rc->param.curve_compression_low, DEFAULT_CURVE_COMPRESSION_LOW);
279 :     _INIT(rc->param.max_overflow_improvement, DEFAULT_MAX_OVERFLOW_IMPROVEMENT);
280 :     _INIT(rc->param.max_overflow_degradation, DEFAULT_MAX_OVERFLOW_DEGRADATION);
281 : suxen_drol 942
282 : edgomez 1064 /* Keyframe settings */
283 :     _INIT(rc->param.kfreduction, DEFAULT_KFREDUCTION);
284 :     _INIT(rc->param.min_key_interval, DEFAULT_MIN_KEY_INTERVAL);
285 : edgomez 1042 #undef _INIT
286 : suxen_drol 942
287 : edgomez 1048 /* Initialize some stuff to zero */
288 :     for(i=0; i<3; i++) {
289 :     int j;
290 : edgomez 1202 for (j=0; j<32; j++) {
291 : edgomez 1048 rc->quant_error[i][j] = 0;
292 : edgomez 1202 rc->quant_count[i][j] = 0;
293 :     }
294 : edgomez 1048 }
295 :    
296 : edgomez 1202 for (i=0; i<3; i++) rc->last_quant[i] = 0;
297 : edgomez 1048
298 :     rc->fq_error = 0;
299 :    
300 : edgomez 1202 /* Count frames (and intra frames) in the stats file, store the result into
301 :     * the rc structure */
302 :     if (statsfile_count_frames(rc, param->filename) == -1) {
303 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
304 : edgomez 1048 free(rc);
305 : edgomez 1202 return(XVID_ERR_FAIL);
306 : edgomez 1048 }
307 : suxen_drol 942
308 : edgomez 1064 /* Allocate the stats' memory */
309 : edgomez 1202 if ((rc->stats = malloc(rc->num_frames * sizeof(twopass_stat_t))) == NULL) {
310 : edgomez 1064 free(rc);
311 : edgomez 1202 return(XVID_ERR_MEMORY);
312 : edgomez 1064 }
313 : suxen_drol 942
314 : edgomez 1202 /* Allocate keyframes location's memory
315 :     * PS: see comment in pre_process0 for the +1 location requirement */
316 : edgomez 1048 rc->keyframe_locations = malloc((rc->num_keyframes + 1) * sizeof(int));
317 :     if (rc->keyframe_locations == NULL) {
318 :     free(rc->stats);
319 :     free(rc);
320 : edgomez 1202 return(XVID_ERR_MEMORY);
321 : edgomez 1048 }
322 : suxen_drol 942
323 : edgomez 1202 /* Load the first pass stats */
324 :     if (statsfile_load(rc, param->filename) == -1) {
325 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
326 : edgomez 1048 free(rc->keyframe_locations);
327 :     free(rc->stats);
328 :     free(rc);
329 :     return XVID_ERR_FAIL;
330 :     }
331 : suxen_drol 942
332 : edgomez 1048 /* Compute the target filesize */
333 : edgomez 1064 if (rc->param.bitrate<0) {
334 :     /* if negative, bitrate equals the target (in kbytes) */
335 :     rc->target = (-rc->param.bitrate) * 1024;
336 :     } else if (rc->num_frames < create->fbase/create->fincr) {
337 : edgomez 1048 /* Source sequence is less than 1s long, we do as if it was 1s long */
338 :     rc->target = rc->param.bitrate / 8;
339 : edgomez 1042 } else {
340 : edgomez 1048 /* Target filesize = bitrate/8 * numframes / framerate */
341 : edgomez 1161 rc->target =
342 : edgomez 1048 ((uint64_t)rc->param.bitrate * (uint64_t)rc->num_frames * \
343 :     (uint64_t)create->fincr) / \
344 : edgomez 1040 ((uint64_t)create->fbase * 8);
345 : suxen_drol 977 }
346 : suxen_drol 1030
347 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Frame rate: %d/%d (%ffps)\n",
348 : edgomez 1048 create->fbase, create->fincr,
349 :     (double)create->fbase/(double)create->fincr);
350 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Number of frames: %d\n", rc->num_frames);
351 :     if(rc->param.bitrate>=0)
352 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target bitrate: %ld\n", rc->param.bitrate);
353 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target filesize: %lld\n", rc->target);
354 : suxen_drol 1032
355 : edgomez 1048 /* Compensate the average frame overhead caused by the container */
356 : edgomez 1041 rc->target -= rc->num_frames*rc->param.container_frame_overhead;
357 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Container Frame overhead: %d\n", rc->param.container_frame_overhead);
358 :     if(rc->param.container_frame_overhead)
359 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- New target filesize after container compensation: %lld\n", rc->target);
360 : suxen_drol 977
361 : edgomez 1202 /* Gathers some information about first pass stats:
362 : edgomez 1048 * - finds the minimum frame length for each frame type during 1st pass.
363 :     * rc->min_size[]
364 :     * - determines the maximum frame length observed (no frame type distinction).
365 :     * rc->max_size
366 :     * - count how many times each frame type has been used.
367 :     * rc->count[]
368 :     * - total bytes used per frame type
369 :     * rc->total[]
370 :     * - store keyframe location
371 :     * rc->keyframe_locations[]
372 :     */
373 : edgomez 1202 first_pass_stats_prepare_data(rc);
374 : edgomez 1036
375 : edgomez 1202 /* When bitrate is not given it means it has been scaled by an external
376 :     * application */
377 : suxen_drol 977 if (rc->param.bitrate) {
378 : edgomez 1048 /* Apply zone settings */
379 :     zone_process(rc, create);
380 : edgomez 1202 /* Perform internal curve scaling */
381 :     first_pass_scale_curve_internal(rc);
382 : edgomez 1048 } else {
383 :     /* External scaling -- zones are ignored */
384 :     for (i=0;i<rc->num_frames;i++) {
385 :     rc->stats[i].zone_mode = XVID_ZONE_WEIGHT;
386 :     rc->stats[i].weight = 1.0;
387 :     }
388 :     rc->avg_weight = 1.0;
389 :     rc->tot_quant = 0;
390 :     }
391 :    
392 : edgomez 1202 /* Apply advanced curve options, and compute some parameters in order to
393 :     * shape the curve in the BEFORE/AFTER pair of functions */
394 :     scaled_curve_apply_advanced_parameters(rc);
395 : suxen_drol 1030
396 : edgomez 1048 *handle = rc;
397 : suxen_drol 942 return(0);
398 :     }
399 :    
400 : edgomez 1042 /*----------------------------------------------------------------------------
401 :     *--------------------------------------------------------------------------*/
402 : suxen_drol 942
403 : edgomez 1042 static int
404 :     rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy)
405 : suxen_drol 942 {
406 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- target_total:%lld desired_total:%.2f (%.2f%%) actual_total:%.2f (%.2f%%)\n",
407 :     rc->target,
408 :     rc->desired_total,
409 :     100*rc->desired_total/(double)rc->target,
410 :     rc->real_total,
411 :     100*rc->real_total/(double)rc->target);
412 :    
413 : edgomez 1064 free(rc->keyframe_locations);
414 :     free(rc->stats);
415 : suxen_drol 942 free(rc);
416 :     return(0);
417 :     }
418 :    
419 : edgomez 1042 /*----------------------------------------------------------------------------
420 :     *--------------------------------------------------------------------------*/
421 : suxen_drol 942
422 : edgomez 1042 static int
423 :     rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data)
424 : suxen_drol 942 {
425 : edgomez 1202 twopass_stat_t * s = &rc->stats[data->frame_num];
426 : edgomez 1048 double dbytes;
427 :     double scaled_quant;
428 : edgomez 1202 double overflow;
429 : edgomez 1048 int capped_to_max_framesize = 0;
430 : suxen_drol 942
431 : edgomez 1202 /* This function is quite long but easy to understand. In order to simplify
432 :     * the code path (a bit), we treat 3 cases that can return immediatly. */
433 : suxen_drol 942
434 : edgomez 1037 /* First case: Another plugin has already set a quantizer */
435 : edgomez 1064 if (data->quant > 0)
436 : edgomez 1037 return(0);
437 : suxen_drol 942
438 : edgomez 1037 /* Second case: We are in a Quant zone */
439 :     if (s->zone_mode == XVID_ZONE_QUANT) {
440 :     rc->fq_error += s->weight;
441 :     data->quant = (int)rc->fq_error;
442 :     rc->fq_error -= data->quant;
443 : edgomez 1064
444 : edgomez 1037 s->desired_length = s->length;
445 : suxen_drol 1032
446 : edgomez 1037 return(0);
447 :     }
448 : suxen_drol 977
449 : edgomez 1037 /* Third case: insufficent stats data */
450 :     if (data->frame_num >= rc->num_frames)
451 : edgomez 1202 return(0);
452 : suxen_drol 942
453 : edgomez 1202 /*************************************************************************/
454 :     /*************************************************************************/
455 :     /*************************************************************************/
456 : suxen_drol 942
457 : edgomez 1202 /*-------------------------------------------------------------------------
458 :     * Frame bit allocation first part
459 :     *
460 :     * First steps apply user settings, just like it is done in the theoritical
461 :     * scaled_curve_apply_advanced_parameters
462 :     *-----------------------------------------------------------------------*/
463 : suxen_drol 942
464 : edgomez 1202 /* Set desired to what we are wanting to obtain for this frame */
465 :     dbytes = (double)s->scaled_length;
466 : suxen_drol 942
467 : edgomez 1202 /* IFrame user settings*/
468 :     if (s->type == XVID_TYPE_IVOP) {
469 : suxen_drol 942
470 : edgomez 1202 /* Keyframe boosting -- All keyframes benefit from it */
471 :     dbytes += dbytes*rc->param.keyframe_boost / 100;
472 : suxen_drol 942
473 : edgomez 1202 /* Applies keyframe penalties, but not the first frame */
474 :     if (rc->KF_idx) {
475 :     int penalty_distance;
476 : suxen_drol 942
477 : edgomez 1202 /* Minimum keyframe distance penalties */
478 :     penalty_distance = rc->param.min_key_interval;
479 :     penalty_distance -= rc->keyframe_locations[rc->KF_idx];
480 :     penalty_distance += rc->keyframe_locations[rc->KF_idx-1];
481 : suxen_drol 942
482 : edgomez 1202 /* Ah ah ! guilty keyframe, you're under arrest ! */
483 :     if (penalty_distance > 0)
484 :     dbytes -= dbytes*penalty_distance*rc->param.kfreduction/100;
485 :     }
486 :     } else {
487 : suxen_drol 942
488 : edgomez 1202 /* P/S/B frames must reserve some bits for iframe boosting */
489 :     dbytes *= rc->pb_iboost_tax_ratio;
490 : suxen_drol 942
491 : edgomez 1202 /* Apply assymetric curve compression */
492 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
493 :     double assymetric_delta;
494 : suxen_drol 942
495 : edgomez 1202 /* Compute the assymetric delta, this is computed before applying
496 :     * the tax, as done in the pre_process function */
497 :     if (dbytes > rc->avg_length[s->type-1])
498 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_high / 100.0;
499 :     else
500 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_low / 100.0;
501 : suxen_drol 942
502 : edgomez 1202 /* Now we must apply the assymetric tax, else our curve compression
503 :     * would not give a theoritical target size equal to what it is
504 :     * expected */
505 :     dbytes *= rc->assymetric_tax_ratio;
506 :    
507 :     /* Now we can add the assymetric delta */
508 :     dbytes += assymetric_delta;
509 : edgomez 1037 }
510 :     }
511 : suxen_drol 942
512 : edgomez 1202 /* That is what we would like to have -- Don't put that chunk after
513 :     * overflow control, otherwise, overflow is counted twice and you obtain
514 :     * half sized bitrate sequences */
515 :     s->desired_length = (int)dbytes;
516 :     rc->desired_total += dbytes;
517 : suxen_drol 942
518 : edgomez 1202 /*------------------------------------------------------------------------
519 :     * Frame bit allocation: overflow control part.
520 :     *
521 :     * Unlike the theoritical scaled_curve_apply_advanced_parameters, here
522 :     * it's real encoding and we need to make sure we don't go so far from
523 :     * what is our ideal scaled curve.
524 :     *-----------------------------------------------------------------------*/
525 : edgomez 1048
526 : edgomez 1202 /* Compute the overflow we should compensate */
527 :     if (s->type != XVID_TYPE_IVOP) {
528 :     double frametype_factor;
529 :     double framesize_factor;
530 : suxen_drol 942
531 : edgomez 1202 /* Take only the desired part of overflow */
532 :     overflow = rc->overflow;
533 : edgomez 1064
534 : edgomez 1202 /* Factor that will take care to decrease the overflow applied
535 :     * according to the importance of this frame type in term of
536 :     * overall size */
537 :     frametype_factor = rc->count[XVID_TYPE_IVOP-1]*rc->avg_length[XVID_TYPE_IVOP-1];
538 :     frametype_factor += rc->count[XVID_TYPE_PVOP-1]*rc->avg_length[XVID_TYPE_PVOP-1];
539 :     frametype_factor += rc->count[XVID_TYPE_BVOP-1]*rc->avg_length[XVID_TYPE_BVOP-1];
540 :     frametype_factor /= rc->count[s->type-1]*rc->avg_length[s->type-1];
541 :     frametype_factor = 1/frametype_factor;
542 : suxen_drol 942
543 : edgomez 1202 /* Factor that will take care not to compensate too much for this frame
544 :     * size */
545 :     framesize_factor = dbytes;
546 :     framesize_factor /= rc->avg_length[s->type-1];
547 : suxen_drol 942
548 : edgomez 1202 /* Treat only the overflow part concerned by this frame type and size */
549 :     overflow *= frametype_factor;
550 :     #if 0
551 :     /* Leave this one alone, as it impacts badly on quality */
552 :     overflow *= framesize_factor;
553 :     #endif
554 : suxen_drol 942
555 : edgomez 1202 /* Apply the overflow strength imposed by the user */
556 :     overflow *= (rc->param.overflow_control_strength/100.0f);
557 :     } else {
558 :     /* no overflow applied in IFrames because:
559 :     * - their role is important as they're references for P/BFrames.
560 :     * - there aren't much in typical sequences, so if an IFrame overflows too
561 :     * much, this overflow may impact the next IFrame too much and generate
562 :     * a sequence of poor quality frames */
563 :     overflow = 0;
564 : edgomez 1037 }
565 : suxen_drol 942
566 : edgomez 1202 /* Make sure we are not trying to compensate more overflow than we even have */
567 :     if (fabs(overflow) > fabs(rc->overflow))
568 : edgomez 1037 overflow = rc->overflow;
569 : suxen_drol 942
570 : edgomez 1202 /* Make sure the overflow doesn't make the frame size to get out of the range
571 :     * [-max_degradation..+max_improvment] */
572 :     if (overflow > dbytes*rc->param.max_overflow_improvement / 100) {
573 :     if(overflow <= dbytes)
574 :     dbytes += dbytes * rc->param.max_overflow_improvement / 100;
575 :     else
576 :     dbytes += overflow * rc->param.max_overflow_improvement / 100;
577 :     } else if (overflow < - dbytes * rc->param.max_overflow_degradation / 100) {
578 :     dbytes -= dbytes * rc->param.max_overflow_degradation / 100;
579 : edgomez 1037 } else {
580 : edgomez 1202 dbytes += overflow;
581 : edgomez 1037 }
582 : suxen_drol 942
583 : edgomez 1202 /*-------------------------------------------------------------------------
584 :     * Frame bit allocation last part:
585 :     *
586 :     * Cap frame length so we don't reach neither bigger frame sizes than first
587 :     * pass nor smaller than the allowed minimum.
588 :     *-----------------------------------------------------------------------*/
589 :    
590 :     if (dbytes > s->length) {
591 :     dbytes = s->length;
592 :     } else if (dbytes < rc->min_length[s->type-1]) {
593 :     dbytes = rc->min_length[s->type-1];
594 :     } else if (dbytes > rc->max_length) {
595 :     /* ToDo: this condition is always wrong as max_length == maximum frame
596 :     * length of first pass, so the first condition already caps the frame
597 :     * size... */
598 : edgomez 1037 capped_to_max_framesize = 1;
599 : edgomez 1202 dbytes = rc->max_length;
600 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- frame:%d Capped to maximum frame size\n",
601 : edgomez 1040 data->frame_num);
602 : edgomez 1037 }
603 : suxen_drol 942
604 : edgomez 1202 /*------------------------------------------------------------------------
605 :     * Desired frame length <-> quantizer mapping
606 :     *-----------------------------------------------------------------------*/
607 :    
608 :     /* For bframes we must retrieve the original quant used (sent to xvidcore)
609 :     * as core applies the bquant formula before writing the stat log entry */
610 :     if(s->type == XVID_TYPE_BVOP) {
611 :    
612 :     twopass_stat_t *b_ref = s;
613 :    
614 :     /* Find the reference frame */
615 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
616 :     b_ref--;
617 :    
618 :     /* Compute the original quant */
619 :     s->quant = 100*s->quant - data->bquant_offset;
620 :     s->quant += data->bquant_ratio - 1; /* to avoid rouding issues */
621 :     s->quant = s->quant/data->bquant_ratio - b_ref->quant;
622 : edgomez 1040 }
623 : suxen_drol 942
624 : edgomez 1202 /* Don't laugh at this very 'simple' quant<->filesize relationship, it
625 :     * proves to be acurate enough for our algorithm */
626 :     scaled_quant = (double)s->quant*(double)s->length/(double)dbytes;
627 : suxen_drol 942
628 : edgomez 1202 #ifdef COMPENSATE_FORMULA
629 :     /* We know xvidcore will apply the bframe formula again, so we compensate
630 :     * it right now to make sure we would not apply it twice */
631 :     if(s->type == XVID_TYPE_BVOP) {
632 :    
633 :     twopass_stat_t *b_ref = s;
634 :    
635 :     /* Find the reference frame */
636 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
637 :     b_ref--;
638 :    
639 :     /* Compute the quant it would be if the core did not apply the bframe
640 :     * formula */
641 :     scaled_quant = 100*scaled_quant - data->bquant_offset;
642 :     scaled_quant += data->bquant_ratio - 1; /* to avoid rouding issues */
643 :     scaled_quant /= data->bquant_ratio;
644 :     }
645 :     #endif
646 :    
647 :     /* Quantizer has been scaled using floating point operations/results, we
648 :     * must cast it to integer */
649 : edgomez 1048 data->quant = (int)scaled_quant;
650 :    
651 : edgomez 1037 /* Let's clip the computed quantizer, if needed */
652 :     if (data->quant < 1) {
653 :     data->quant = 1;
654 :     } else if (data->quant > 31) {
655 :     data->quant = 31;
656 : edgomez 1202 } else {
657 : suxen_drol 942
658 : edgomez 1202 /* The frame quantizer has not been clipped, this appears to be a good
659 : edgomez 1048 * computed quantizer, do not loose quantizer decimal part that we
660 : edgomez 1202 * accumulate for later reuse when its sum represents a complete
661 :     * unit. */
662 : edgomez 1048 rc->quant_error[s->type-1][data->quant] += scaled_quant - (double)data->quant;
663 : suxen_drol 942
664 : edgomez 1048 if (rc->quant_error[s->type-1][data->quant] >= 1.0) {
665 :     rc->quant_error[s->type-1][data->quant] -= 1.0;
666 :     data->quant++;
667 :     } else if (rc->quant_error[s->type-1][data->quant] <= -1.0) {
668 :     rc->quant_error[s->type-1][data->quant] += 1.0;
669 :     data->quant--;
670 :     }
671 : edgomez 1037 }
672 : suxen_drol 942
673 : edgomez 1202 /* Now we have a computed quant that is in the right quante range, with a
674 : edgomez 1037 * possible +1 correction due to cumulated error. We can now safely clip
675 :     * the quantizer again with user's quant ranges. "Safely" means the Rate
676 :     * Control could learn more about this quantizer, this knowledge is useful
677 :     * for future frames even if it this quantizer won't be really used atm,
678 : edgomez 1202 * that's why we don't perform this clipping earlier. */
679 : edgomez 1037 if (data->quant < data->min_quant[s->type-1]) {
680 :     data->quant = data->min_quant[s->type-1];
681 :     } else if (data->quant > data->max_quant[s->type-1]) {
682 :     data->quant = data->max_quant[s->type-1];
683 :     }
684 : suxen_drol 942
685 : edgomez 1202 /* To avoid big quality jumps from frame to frame, we apply a "security"
686 : edgomez 1037 * rule that makes |last_quant - new_quant| <= 2. This rule only applies
687 : edgomez 1202 * to predicted frames (P and B) */
688 : edgomez 1037 if (s->type != XVID_TYPE_IVOP && rc->last_quant[s->type-1] && capped_to_max_framesize == 0) {
689 : suxen_drol 942
690 : edgomez 1037 if (data->quant > rc->last_quant[s->type-1] + 2) {
691 :     data->quant = rc->last_quant[s->type-1] + 2;
692 : edgomez 1040 DPRINTF(XVID_DEBUG_RC,
693 : edgomez 1202 "[xvid rc] -- frame %d p/b-frame quantizer prevented from rising too steeply\n",
694 : edgomez 1040 data->frame_num);
695 : edgomez 1037 }
696 :     if (data->quant < rc->last_quant[s->type-1] - 2) {
697 :     data->quant = rc->last_quant[s->type-1] - 2;
698 : edgomez 1040 DPRINTF(XVID_DEBUG_RC,
699 : edgomez 1202 "[xvid rc] -- frame:%d p/b-frame quantizer prevented from falling too steeply\n",
700 : edgomez 1040 data->frame_num);
701 : edgomez 1037 }
702 :     }
703 : suxen_drol 1030
704 : edgomez 1202 /* We don't want to pollute the RC histerisis when our computed quant has
705 :     * been computed from a capped frame size */
706 : edgomez 1046 if (capped_to_max_framesize == 0)
707 : edgomez 1037 rc->last_quant[s->type-1] = data->quant;
708 : suxen_drol 1030
709 : edgomez 1202 /* Don't forget to force 1st pass frame type ;-) */
710 : edgomez 1050 data->type = s->type;
711 :    
712 : edgomez 1202 /* Store the quantizer into the statistics -- Used to compensate the double
713 :     * formula symptom */
714 :     s->quant2 = data->quant;
715 :    
716 : edgomez 1037 return 0;
717 : suxen_drol 942 }
718 :    
719 : edgomez 1042 /*----------------------------------------------------------------------------
720 :     *--------------------------------------------------------------------------*/
721 : suxen_drol 942
722 : edgomez 1042 static int
723 :     rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data)
724 : suxen_drol 942 {
725 : edgomez 1043 const char frame_type[4] = { 'i', 'p', 'b', 's'};
726 : edgomez 1202 twopass_stat_t * s = &rc->stats[data->frame_num];
727 : suxen_drol 942
728 : edgomez 1037 /* Insufficent stats data */
729 : edgomez 1064 if (data->frame_num >= rc->num_frames)
730 :     return 0;
731 : suxen_drol 942
732 : edgomez 1202 /* Update the quantizer counter */
733 :     rc->quant_count[s->type-1][data->quant]++;
734 : suxen_drol 942
735 : edgomez 1202 /* Update the frame type overflow */
736 : edgomez 1064 if (data->type == XVID_TYPE_IVOP) {
737 : edgomez 1202 int kfdiff = 0;
738 : suxen_drol 942
739 : edgomez 1202 if(rc->KF_idx != rc->num_frames -1) {
740 :     kfdiff = rc->keyframe_locations[rc->KF_idx+1];
741 :     kfdiff -= rc->keyframe_locations[rc->KF_idx];
742 :     }
743 :    
744 :     /* Flush Keyframe overflow accumulator */
745 : edgomez 1064 rc->overflow += rc->KFoverflow;
746 : edgomez 1202
747 :     /* Store the frame overflow to the keyframe accumulator */
748 : edgomez 1064 rc->KFoverflow = s->desired_length - data->length;
749 :    
750 : edgomez 1202 if (kfdiff > 1) {
751 :     /* Non-consecutive keyframes case:
752 :     * We can then divide this total keyframe overflow into equal parts
753 :     * that we will distribute into regular overflow at each frame
754 :     * between the sequence bounded by two IFrames */
755 : edgomez 1064 rc->KFoverflow_partial = rc->KFoverflow / (kfdiff - 1);
756 : edgomez 1202 } else {
757 :     /* Consecutive keyframes case:
758 :     * Flush immediatly the keyframe overflow and reset keyframe
759 :     * overflow */
760 : suxen_drol 942 rc->overflow += rc->KFoverflow;
761 :     rc->KFoverflow = 0;
762 :     rc->KFoverflow_partial = 0;
763 : edgomez 1064 }
764 :     rc->KF_idx++;
765 :     } else {
766 : edgomez 1202 /* Accumulate the frame overflow */
767 :     rc->overflow += s->desired_length - data->length;
768 :    
769 :     /* Distribute part of the keyframe overflow */
770 :     rc->overflow += rc->KFoverflow_partial;
771 :    
772 :     /* Don't forget to substract that same amount from the total keyframe
773 :     * overflow */
774 : edgomez 1064 rc->KFoverflow -= rc->KFoverflow_partial;
775 :     }
776 : suxen_drol 942
777 : edgomez 1202 rc->overflow += s->error = s->desired_length - data->length;
778 :     rc->real_total += data->length;
779 :    
780 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- frame:%d type:%c quant:%d stats:%d scaled:%d desired:%d actual:%d error:%d overflow:%.2f\n",
781 : edgomez 1042 data->frame_num,
782 : edgomez 1043 frame_type[data->type-1],
783 : edgomez 1042 data->quant,
784 :     s->length,
785 :     s->scaled_length,
786 : edgomez 1048 s->desired_length,
787 : edgomez 1202 s->desired_length - s->error,
788 :     -s->error,
789 : edgomez 1042 rc->overflow);
790 : suxen_drol 942
791 : edgomez 1064 return(0);
792 : suxen_drol 942 }
793 :    
794 : edgomez 1042 /*****************************************************************************
795 :     * Helper functions definition
796 :     ****************************************************************************/
797 : suxen_drol 942
798 : edgomez 1202 /* Default buffer size for reading lines */
799 : edgomez 1042 #define BUF_SZ 1024
800 : suxen_drol 942
801 : edgomez 1202 /* Helper functions for reading/parsing the stats file */
802 :     static char *skipspaces(char *string);
803 :     static int iscomment(char *string);
804 :     static char *readline(FILE *f);
805 :    
806 :     /* This function counts the number of frame entries in the stats file
807 :     * It also counts the number of I Frames */
808 : edgomez 1042 static int
809 : edgomez 1202 statsfile_count_frames(rc_2pass2_t * rc, char * filename)
810 : suxen_drol 942 {
811 : edgomez 1064 FILE * f;
812 : edgomez 1202 char *line;
813 :     int lines;
814 : edgomez 1042
815 : edgomez 1064 rc->num_frames = 0;
816 :     rc->num_keyframes = 0;
817 : edgomez 1042
818 : edgomez 1202 if ((f = fopen(filename, "rb")) == NULL)
819 :     return(-1);
820 : suxen_drol 942
821 : edgomez 1202 lines = 0;
822 :     while ((line = readline(f)) != NULL) {
823 :    
824 :     char *ptr;
825 :     char type;
826 : edgomez 1204 int fields;
827 : edgomez 1202
828 :     lines++;
829 :    
830 :     /* We skip spaces */
831 :     ptr = skipspaces(line);
832 :    
833 : edgomez 1204 /* Skip coment lines or empty lines */
834 :     if(iscomment(ptr) || *ptr == '\0') {
835 : edgomez 1202 free(line);
836 :     continue;
837 : edgomez 1064 }
838 : edgomez 1202
839 :     /* Read the stat line from buffer */
840 : edgomez 1204 fields = sscanf(ptr, "%c", &type);
841 : edgomez 1202
842 :     /* Valid stats files have at least 6 fields */
843 : edgomez 1204 if (fields == 1) {
844 : edgomez 1202 switch(type) {
845 :     case 'i':
846 :     case 'I':
847 :     rc->num_keyframes++;
848 :     case 'p':
849 :     case 'P':
850 :     case 'b':
851 :     case 'B':
852 :     case 's':
853 :     case 'S':
854 :     rc->num_frames++;
855 :     break;
856 :     default:
857 :     DPRINTF(XVID_DEBUG_RC,
858 :     "[xvid rc] -- WARNING: L%d unknown frame type used (%c).\n",
859 :     lines, type);
860 :     }
861 :     } else {
862 :     DPRINTF(XVID_DEBUG_RC,
863 :     "[xvid rc] -- WARNING: L%d misses some stat fields (%d).\n",
864 :     lines, 6-fields);
865 :     }
866 :    
867 :     /* Free the line buffer */
868 :     free(line);
869 : edgomez 1064 }
870 : suxen_drol 942
871 : edgomez 1202 /* We are done with the file */
872 : edgomez 1064 fclose(f);
873 : suxen_drol 942
874 : edgomez 1202 return(0);
875 : edgomez 1042 }
876 : suxen_drol 942
877 : edgomez 1042 /* open stats file(s) and read into rc->stats array */
878 :     static int
879 : edgomez 1202 statsfile_load(rc_2pass2_t *rc, char * filename)
880 : edgomez 1042 {
881 : edgomez 1064 FILE * f;
882 : edgomez 1202 int processed_entries;
883 : edgomez 1042
884 : edgomez 1202 /* Opens the file */
885 :     if ((f = fopen(filename, "rb"))==NULL)
886 :     return(-1);
887 : edgomez 1064
888 : edgomez 1202 processed_entries = 0;
889 :     while(processed_entries < rc->num_frames) {
890 : edgomez 1064 char type;
891 : edgomez 1202 int fields;
892 :     twopass_stat_t * s = &rc->stats[processed_entries];
893 :     char *line, *ptr;
894 : edgomez 1042
895 : edgomez 1202 /* Read the line from the file */
896 :     if((line = readline(f)) == NULL)
897 :     break;
898 :    
899 :     /* We skip spaces */
900 :     ptr = skipspaces(line);
901 :    
902 : edgomez 1204 /* Skip comment lines or empty lines */
903 :     if(iscomment(ptr) || *ptr == '\0') {
904 : edgomez 1202 free(line);
905 :     continue;
906 : edgomez 1042 }
907 :    
908 : edgomez 1202 /* Reset this field that is optional */
909 :     s->scaled_length = 0;
910 :    
911 :     /* Convert the fields */
912 :     fields = sscanf(ptr,
913 :     "%c %d %d %d %d %d %d\n",
914 :     &type,
915 :     &s->quant,
916 :     &s->blks[0], &s->blks[1], &s->blks[2],
917 :     &s->length,
918 :     &s->scaled_length);
919 :    
920 :     /* Free line buffer, we don't need it anymore */
921 :     free(line);
922 :    
923 :     /* Fail silently, this has probably been warned in
924 :     * statsfile_count_frames */
925 :     if(fields != 6 && fields != 7)
926 :     continue;
927 :    
928 :     /* Convert frame type */
929 :     switch(type) {
930 :     case 'i':
931 :     case 'I':
932 : edgomez 1064 s->type = XVID_TYPE_IVOP;
933 : edgomez 1202 break;
934 :     case 'p':
935 :     case 'P':
936 :     case 's':
937 :     case 'S':
938 : edgomez 1064 s->type = XVID_TYPE_PVOP;
939 : edgomez 1202 break;
940 :     case 'b':
941 :     case 'B':
942 : edgomez 1064 s->type = XVID_TYPE_BVOP;
943 : edgomez 1202 break;
944 :     default:
945 :     /* Same as before, fail silently */
946 :     continue;
947 : edgomez 1064 }
948 : edgomez 1042
949 : edgomez 1202 /* Ok it seems it's been processed correctly */
950 :     processed_entries++;
951 : edgomez 1064 }
952 : suxen_drol 942
953 : edgomez 1202 /* Close the file */
954 : edgomez 1042 fclose(f);
955 :    
956 : edgomez 1202 return(0);
957 : suxen_drol 942 }
958 : edgomez 1042
959 : edgomez 1161 /* pre-process the statistics data
960 : edgomez 1202 * - for each type, count, tot_length, min_length, max_length
961 :     * - set keyframes_locations */
962 : edgomez 1042 static void
963 : edgomez 1202 first_pass_stats_prepare_data(rc_2pass2_t * rc)
964 : edgomez 1042 {
965 : edgomez 1064 int i,j;
966 : edgomez 1042
967 : edgomez 1202 /* *rc fields initialization
968 : edgomez 1048 * NB: INT_MAX and INT_MIN are used in order to be immediately replaced
969 : edgomez 1202 * with real values of the 1pass */
970 : edgomez 1064 for (i=0; i<3; i++) {
971 : edgomez 1048 rc->count[i]=0;
972 :     rc->tot_length[i] = 0;
973 : edgomez 1042 rc->min_length[i] = INT_MAX;
974 : edgomez 1064 }
975 : edgomez 1042
976 :     rc->max_length = INT_MIN;
977 :    
978 : edgomez 1202 /* Loop through all frames and find/compute all the stuff this function
979 :     * is supposed to do */
980 : edgomez 1048 for (i=j=0; i<rc->num_frames; i++) {
981 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
982 : edgomez 1042
983 : edgomez 1048 rc->count[s->type-1]++;
984 :     rc->tot_length[s->type-1] += s->length;
985 : edgomez 1042
986 : edgomez 1048 if (s->length < rc->min_length[s->type-1]) {
987 :     rc->min_length[s->type-1] = s->length;
988 :     }
989 : edgomez 1042
990 : edgomez 1048 if (s->length > rc->max_length) {
991 :     rc->max_length = s->length;
992 :     }
993 : edgomez 1042
994 : edgomez 1048 if (s->type == XVID_TYPE_IVOP) {
995 :     rc->keyframe_locations[j] = i;
996 :     j++;
997 :     }
998 :     }
999 :    
1000 : edgomez 1202 /* NB:
1001 : edgomez 1042 * The "per sequence" overflow system considers a natural sequence to be
1002 :     * formed by all frames between two iframes, so if we want to make sure
1003 :     * the system does not go nuts during last sequence, we force the last
1004 : edgomez 1202 * frame to appear in the keyframe locations array. */
1005 : edgomez 1064 rc->keyframe_locations[j] = i;
1006 : edgomez 1042
1007 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass IFrame length: %d\n", rc->min_length[0]);
1008 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass PFrame length: %d\n", rc->min_length[1]);
1009 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass BFrame length: %d\n", rc->min_length[2]);
1010 : edgomez 1042 }
1011 : edgomez 1064
1012 : edgomez 1042 /* calculate zone weight "center" */
1013 :     static void
1014 :     zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create)
1015 :     {
1016 : edgomez 1064 int i,j;
1017 :     int n = 0;
1018 : edgomez 1042
1019 : edgomez 1064 rc->avg_weight = 0.0;
1020 :     rc->tot_quant = 0;
1021 : edgomez 1042
1022 :    
1023 : edgomez 1064 if (create->num_zones == 0) {
1024 :     for (j = 0; j < rc->num_frames; j++) {
1025 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1026 :     rc->stats[j].weight = 1.0;
1027 :     }
1028 :     rc->avg_weight += rc->num_frames * 1.0;
1029 :     n += rc->num_frames;
1030 :     }
1031 : edgomez 1042
1032 :    
1033 : edgomez 1064 for(i=0; i < create->num_zones; i++) {
1034 : edgomez 1042
1035 : edgomez 1064 int next = (i+1<create->num_zones) ? create->zones[i+1].frame : rc->num_frames;
1036 : edgomez 1042
1037 : edgomez 1064 if (i==0 && create->zones[i].frame > 0) {
1038 :     for (j = 0; j < create->zones[i].frame && j < rc->num_frames; j++) {
1039 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1040 :     rc->stats[j].weight = 1.0;
1041 :     }
1042 :     rc->avg_weight += create->zones[i].frame * 1.0;
1043 :     n += create->zones[i].frame;
1044 :     }
1045 : edgomez 1042
1046 : edgomez 1064 if (create->zones[i].mode == XVID_ZONE_WEIGHT) {
1047 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1048 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1049 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1050 :     }
1051 :     next -= create->zones[i].frame;
1052 :     rc->avg_weight += (double)(next * create->zones[i].increment) / (double)create->zones[i].base;
1053 :     n += next;
1054 :     }else{ /* XVID_ZONE_QUANT */
1055 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1056 :     rc->stats[j].zone_mode = XVID_ZONE_QUANT;
1057 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1058 :     rc->tot_quant += rc->stats[j].length;
1059 :     }
1060 :     }
1061 :     }
1062 :     rc->avg_weight = n>0 ? rc->avg_weight/n : 1.0;
1063 :    
1064 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- center_weight:%f (for %d frames) fixed_bytes:%d\n", rc->avg_weight, n, rc->tot_quant);
1065 : edgomez 1042 }
1066 :    
1067 :    
1068 :     /* scale the curve */
1069 :     static void
1070 : edgomez 1202 first_pass_scale_curve_internal(rc_2pass2_t *rc)
1071 : edgomez 1042 {
1072 : edgomez 1202 int64_t target;
1073 :     int64_t pass1_length;
1074 : edgomez 1042 double scaler;
1075 : edgomez 1047 int i, num_MBs;
1076 : edgomez 1042
1077 : edgomez 1202 /* We remove the bytes used by the fixed quantizer zones
1078 :     * ToDo: this approach is flawed, the same amount of bytes is removed from
1079 :     * target and first pass data, this has no sense, zone_process should
1080 :     * give us two results one for unscaled data (1pass) and the other
1081 :     * one for scaled data and we should then write:
1082 :     * target = rc->target - rc->tot_quant_scaled;
1083 :     * pass1_length = rc->i+p+b - rc->tot_quant_firstpass */
1084 :     target = rc->target - rc->tot_quant;
1085 :    
1086 :     /* Do the same for the first pass data */
1087 :     pass1_length = rc->tot_length[XVID_TYPE_IVOP-1];
1088 :     pass1_length += rc->tot_length[XVID_TYPE_PVOP-1];
1089 :     pass1_length += rc->tot_length[XVID_TYPE_BVOP-1];
1090 :     pass1_length -= rc->tot_quant;
1091 :    
1092 : edgomez 1042 /* Let's compute a linear scaler in order to perform curve scaling */
1093 :     scaler = (double)target / (double)pass1_length;
1094 :    
1095 :     if (target <= 0 || pass1_length <= 0 || target >= pass1_length) {
1096 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- WARNING: Undersize detected before correction\n");
1097 : edgomez 1064 scaler = 1.0;
1098 : edgomez 1042 }
1099 :    
1100 : edgomez 1202 /* Compute min frame lengths (for each frame type) according to the number
1101 :     * of MBs. We sum all block type counters of frame 0, this gives us the
1102 :     * number of MBs.
1103 : edgomez 1049 *
1104 :     * We compare these hardcoded values with observed values in first pass
1105 : edgomez 1202 * (determined in pre_process0).Then we keep the real minimum. */
1106 : edgomez 1047
1107 : edgomez 1202 /* Number of MBs */
1108 :     num_MBs = rc->stats[0].blks[0];
1109 :     num_MBs += rc->stats[0].blks[1];
1110 :     num_MBs += rc->stats[0].blks[2];
1111 : edgomez 1049
1112 : edgomez 1202 /* Minimum for I frames */
1113 :     if(rc->min_length[XVID_TYPE_IVOP-1] > ((num_MBs*22) + 240) / 8)
1114 :     rc->min_length[XVID_TYPE_IVOP-1] = ((num_MBs*22) + 240) / 8;
1115 : edgomez 1049
1116 : edgomez 1202 /* Minimum for P/S frames */
1117 :     if(rc->min_length[XVID_TYPE_PVOP-1] > ((num_MBs) + 88) / 8)
1118 :     rc->min_length[XVID_TYPE_PVOP-1] = ((num_MBs) + 88) / 8;
1119 : edgomez 1049
1120 : edgomez 1202 /* Minimum for B frames */
1121 :     if(rc->min_length[XVID_TYPE_BVOP-1] > 8)
1122 :     rc->min_length[XVID_TYPE_BVOP-1] = 8;
1123 :    
1124 :     /* Perform an initial scale pass.
1125 :     *
1126 : edgomez 1042 * If a frame size is scaled underneath our hardcoded minimums, then we
1127 :     * force the frame size to the minimum, and deduct the original & scaled
1128 : edgomez 1202 * frame length from the original and target total lengths */
1129 : edgomez 1042 for (i=0; i<rc->num_frames; i++) {
1130 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1131 : edgomez 1042 int len;
1132 :    
1133 : edgomez 1202 /* No need to scale frame length for which a specific quantizer is
1134 :     * specified thanks to zones */
1135 : edgomez 1064 if (s->zone_mode == XVID_ZONE_QUANT) {
1136 :     s->scaled_length = s->length;
1137 : edgomez 1042 continue;
1138 :     }
1139 :    
1140 : edgomez 1048 /* Compute the scaled length */
1141 : edgomez 1042 len = (int)((double)s->length * scaler * s->weight / rc->avg_weight);
1142 :    
1143 :     /* Compare with the computed minimum */
1144 : edgomez 1049 if (len < rc->min_length[s->type-1]) {
1145 : edgomez 1202 /* This is a 'forced size' frame, set its frame size to the
1146 :     * computed minimum */
1147 : edgomez 1049 s->scaled_length = rc->min_length[s->type-1];
1148 : edgomez 1202
1149 :     /* Remove both scaled and original size from their respective
1150 :     * total counters, as we prepare a second pass for 'regular'
1151 :     * frames */
1152 : edgomez 1042 target -= s->scaled_length;
1153 :     pass1_length -= s->length;
1154 :     } else {
1155 :     /* Do nothing for now, we'll scale this later */
1156 :     s->scaled_length = 0;
1157 :     }
1158 :     }
1159 :    
1160 : edgomez 1202 /* The first pass on data substracted all 'forced size' frames from the
1161 :     * total counters. Now, it's possible to scale the 'regular' frames. */
1162 :    
1163 :     /* Scaling factor for 'regular' frames */
1164 : edgomez 1042 scaler = (double)target / (double)pass1_length;
1165 :    
1166 :     /* Detect undersizing */
1167 : edgomez 1064 if (target <= 0 || pass1_length <= 0 || target >= pass1_length) {
1168 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- WARNING: Undersize detected after correction\n");
1169 : edgomez 1042 scaler = 1.0;
1170 :     }
1171 :    
1172 :     /* Do another pass with the new scaler */
1173 :     for (i=0; i<rc->num_frames; i++) {
1174 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1175 : edgomez 1042
1176 :     /* Ignore frame with forced frame sizes */
1177 :     if (s->scaled_length == 0)
1178 :     s->scaled_length = (int)((double)s->length * scaler * s->weight / rc->avg_weight);
1179 :     }
1180 : edgomez 1202
1181 :     /* Job done */
1182 :     return;
1183 : edgomez 1042 }
1184 :    
1185 : edgomez 1202 /* Apply all user settings to the scaled curve
1186 :     * This implies:
1187 :     * keyframe boosting
1188 :     * high/low compression */
1189 : edgomez 1042 static void
1190 : edgomez 1202 scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc)
1191 : edgomez 1042 {
1192 : edgomez 1064 int i;
1193 :     uint64_t ivop_boost_total;
1194 : edgomez 1042
1195 : edgomez 1202 /* Reset the rate controller (per frame type) total byte counters */
1196 :     for (i=0; i<3; i++) rc->tot_scaled_length[i] = 0;
1197 : edgomez 1042
1198 : edgomez 1202 /* Compute total bytes for each frame type */
1199 :     for (i=0; i<rc->num_frames;i++) {
1200 :     twopass_stat_t *s = &rc->stats[i];
1201 :     rc->tot_scaled_length[s->type-1] += s->scaled_length;
1202 : edgomez 1064 }
1203 : edgomez 1042
1204 : edgomez 1202 /* First we compute the total amount of bits needed, as being described by
1205 :     * the scaled distribution. During this pass over the complete stats data,
1206 :     * we see how much bits two user settings will get/give from/to p&b frames:
1207 :     * - keyframe boosting
1208 :     * - keyframe distance penalty */
1209 :     rc->KF_idx = 0;
1210 :     ivop_boost_total = 0;
1211 : edgomez 1064 for (i=0; i<rc->num_frames; i++) {
1212 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1213 : edgomez 1042
1214 : edgomez 1202 /* Some more work is needed for I frames */
1215 :     if (s->type == XVID_TYPE_IVOP) {
1216 :     int penalty_distance;
1217 :     int ivop_boost;
1218 : edgomez 1042
1219 : edgomez 1202 /* Accumulate bytes needed for keyframe boosting */
1220 :     ivop_boost = s->scaled_length*rc->param.keyframe_boost/100;
1221 :    
1222 :     if (rc->KF_idx) {
1223 :     /* Minimum keyframe distance penalties */
1224 :     penalty_distance = rc->param.min_key_interval;
1225 :     penalty_distance -= rc->keyframe_locations[rc->KF_idx];
1226 :     penalty_distance += rc->keyframe_locations[rc->KF_idx-1];
1227 :    
1228 :     /* Ah ah ! guilty keyframe, you're under arrest ! */
1229 :     if (penalty_distance > 0)
1230 :     ivop_boost -= (s->scaled_length + ivop_boost)*penalty_distance*rc->param.kfreduction/100;
1231 :     }
1232 :    
1233 :     /* If the frame size drops under the minimum length, then cap ivop_boost */
1234 :     if (ivop_boost + s->scaled_length < rc->min_length[XVID_TYPE_IVOP-1])
1235 :     ivop_boost = rc->min_length[XVID_TYPE_IVOP-1] - s->scaled_length;
1236 :    
1237 :     /* Accumulate the ivop boost */
1238 :     ivop_boost_total += ivop_boost;
1239 :    
1240 :     /* Don't forget to update the keyframe index */
1241 :     rc->KF_idx++;
1242 : edgomez 1064 }
1243 :     }
1244 : edgomez 1042
1245 : edgomez 1202 /* Initialize the IBoost tax ratio for P/S/B frames
1246 :     *
1247 :     * This ratio has to be applied to p/b/s frames in order to reserve
1248 :     * additional bits for keyframes (keyframe boosting) or if too much
1249 :     * keyframe distance is applied, bits retrieved from the keyframes.
1250 :     *
1251 :     * ie pb_length *= rc->pb_iboost_tax_ratio;
1252 :     *
1253 :     * gives the ideal length of a p/b frame */
1254 : edgomez 1042
1255 : edgomez 1202 /* Compute the total length of p/b/s frames (temporary storage into
1256 :     * movie_curve) */
1257 :     rc->pb_iboost_tax_ratio = (double)rc->tot_scaled_length[XVID_TYPE_PVOP-1];
1258 :     rc->pb_iboost_tax_ratio += (double)rc->tot_scaled_length[XVID_TYPE_BVOP-1];
1259 :    
1260 :     /* Compute the ratio described above
1261 :     * taxed_total = sum(0, n, tax*scaled_length)
1262 :     * <=> taxed_total = tax.sum(0, n, tax*scaled_length)
1263 :     * <=> tax = taxed_total / original_total */
1264 :     rc->pb_iboost_tax_ratio =
1265 :     (rc->pb_iboost_tax_ratio - ivop_boost_total) /
1266 :     rc->pb_iboost_tax_ratio;
1267 :    
1268 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- IFrame boost tax ratio:%.2f\n",
1269 :     rc->pb_iboost_tax_ratio);
1270 :    
1271 :     /* Compute the average size of frames per frame type */
1272 : edgomez 1064 for(i=0; i<3; i++) {
1273 : edgomez 1202 /* Special case for missing type or weird case */
1274 :     if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1275 : edgomez 1064 rc->avg_length[i] = 1;
1276 : edgomez 1202 } else {
1277 :     rc->avg_length[i] = rc->tot_scaled_length[i];
1278 :    
1279 : edgomez 1204 if (i == (XVID_TYPE_IVOP-1)) {
1280 : edgomez 1202 /* I Frames total has to be added the boost total */
1281 :     rc->avg_length[i] += ivop_boost_total;
1282 :     } else {
1283 :     /* P/B frames has to taxed */
1284 :     rc->avg_length[i] *= rc->pb_iboost_tax_ratio;
1285 :     }
1286 :    
1287 :     /* Finally compute the average frame size */
1288 :     rc->avg_length[i] /= (double)rc->count[i];
1289 : edgomez 1064 }
1290 :     }
1291 : edgomez 1042
1292 : edgomez 1202 /* Assymetric curve compression */
1293 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
1294 :     double symetric_total;
1295 :     double assymetric_delta_total;
1296 : edgomez 1042
1297 : edgomez 1202 /* Like I frame boosting, assymetric curve compression modifies the total
1298 :     * amount of needed bits, we must compute the ratio so we can prescale
1299 :     lengths */
1300 :     symetric_total = 0;
1301 :     assymetric_delta_total = 0;
1302 :     for (i=0; i<rc->num_frames; i++) {
1303 :     double assymetric_delta;
1304 :     double dbytes;
1305 :     twopass_stat_t * s = &rc->stats[i];
1306 : edgomez 1042
1307 : edgomez 1202 /* I Frames are not concerned by assymetric scaling */
1308 :     if (s->type == XVID_TYPE_IVOP)
1309 :     continue;
1310 : edgomez 1042
1311 : edgomez 1202 /* During the real run, we would have to apply the iboost tax */
1312 :     dbytes = s->scaled_length * rc->pb_iboost_tax_ratio;
1313 : edgomez 1042
1314 : edgomez 1202 /* Update the symmetric curve compression total */
1315 :     symetric_total += dbytes;
1316 : edgomez 1064
1317 : edgomez 1202 /* Apply assymetric curve compression */
1318 :     if (dbytes > rc->avg_length[s->type-1])
1319 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_high / 100.0f;
1320 :     else
1321 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_low / 100.0f;
1322 : edgomez 1042
1323 : edgomez 1202 /* Cap to the minimum frame size if needed */
1324 :     if (dbytes + assymetric_delta < rc->min_length[s->type-1])
1325 :     assymetric_delta = rc->min_length[s->type-1] - dbytes;
1326 : edgomez 1051
1327 : edgomez 1202 /* Accumulate after assymetric curve compression */
1328 :     assymetric_delta_total += assymetric_delta;
1329 : edgomez 1064 }
1330 : edgomez 1202
1331 :     /* Compute the tax that all p/b frames have to pay in order to respect the
1332 :     * bit distribution changes that the assymetric compression curve imposes
1333 :     * We want assymetric_total = sum(0, n-1, tax.scaled_length)
1334 :     * ie assymetric_total = ratio.sum(0, n-1, scaled_length)
1335 :     * ratio = assymetric_total / symmetric_total */
1336 :     rc->assymetric_tax_ratio = ((double)symetric_total - (double)assymetric_delta_total) / (double)symetric_total;
1337 :     } else {
1338 :     rc->assymetric_tax_ratio = 1.0f;
1339 : edgomez 1064 }
1340 : edgomez 1042
1341 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Assymetric tax ratio:%.2f\n", rc->assymetric_tax_ratio);
1342 : edgomez 1042
1343 : edgomez 1202 /* Last bits that need to be reset */
1344 : edgomez 1064 rc->overflow = 0;
1345 :     rc->KFoverflow = 0;
1346 :     rc->KFoverflow_partial = 0;
1347 : edgomez 1202 rc->KF_idx = 0;
1348 :     rc->desired_total = 0;
1349 :     rc->real_total = 0;
1350 :    
1351 :     /* Job done */
1352 :     return;
1353 : edgomez 1042 }
1354 : edgomez 1202
1355 :     /*****************************************************************************
1356 :     * Still more low level stuff (nothing to do with stats treatment)
1357 :     ****************************************************************************/
1358 :    
1359 :     /* This function returns an allocated string containing a complete line read
1360 :     * from the file starting at the current position */
1361 :     static char *
1362 :     readline(FILE *f)
1363 :     {
1364 :     char *buffer = NULL;
1365 :     int buffer_size = 0;
1366 :     int pos = 0;
1367 :    
1368 :     do {
1369 :     int c;
1370 :    
1371 :     /* Read a character from the stream */
1372 :     c = fgetc(f);
1373 :    
1374 :     /* Is that EOF or new line ? */
1375 :     if(c == EOF || c == '\n')
1376 :     break;
1377 :    
1378 :     /* Do we have to update buffer ? */
1379 :     if(pos >= buffer_size - 1) {
1380 :     buffer_size += BUF_SZ;
1381 :     buffer = (char*)realloc(buffer, buffer_size);
1382 :     if (buffer == NULL)
1383 :     return(NULL);
1384 :     }
1385 :    
1386 :     buffer[pos] = c;
1387 :     pos++;
1388 :     } while(1);
1389 :    
1390 :     /* Read \n or EOF */
1391 :     if (buffer == NULL) {
1392 :     /* EOF, so we reached the end of the file, return NULL */
1393 :     if(feof(f))
1394 :     return(NULL);
1395 :    
1396 :     /* Just an empty line with just a newline, allocate a 1 byte buffer to
1397 :     * store a zero length string */
1398 :     buffer = (char*)malloc(1);
1399 :     if(buffer == NULL)
1400 :     return(NULL);
1401 :     }
1402 :    
1403 :     /* Zero terminated string */
1404 :     buffer[pos] = '\0';
1405 :    
1406 :     return(buffer);
1407 :     }
1408 :    
1409 :     /* This function returns a pointer to the first non space char in the given
1410 :     * string */
1411 :     static char *
1412 :     skipspaces(char *string)
1413 :     {
1414 :     const char spaces[] =
1415 :     {
1416 :     ' ','\t','\0'
1417 :     };
1418 :     const char *spacechar = spaces;
1419 :    
1420 :     if (string == NULL) return(NULL);
1421 :    
1422 :     while (*string != '\0') {
1423 :     /* Test against space chars */
1424 :     while (*spacechar != '\0') {
1425 :     if (*string == *spacechar) {
1426 :     string++;
1427 :     spacechar = spaces;
1428 :     break;
1429 :     }
1430 :     spacechar++;
1431 :     }
1432 :    
1433 :     /* No space char */
1434 :     if (*spacechar == '\0') return(string);
1435 :     }
1436 :    
1437 :     return(string);
1438 :     }
1439 :    
1440 :     /* This function returns a boolean that tells if the string is only a
1441 :     * comment */
1442 :     static int
1443 :     iscomment(char *string)
1444 :     {
1445 :     const char comments[] =
1446 :     {
1447 :     '#',';', '%', '\0'
1448 :     };
1449 :     const char *cmtchar = comments;
1450 :     int iscomment = 0;
1451 :    
1452 :     if (string == NULL) return(1);
1453 :    
1454 :     string = skipspaces(string);
1455 :    
1456 :     while(*cmtchar != '\0') {
1457 :     if(*string == *cmtchar) {
1458 :     iscomment = 1;
1459 :     break;
1460 :     }
1461 :     cmtchar++;
1462 :     }
1463 :    
1464 :     return(iscomment);
1465 :     }
1466 :    
1467 :     #if 0
1468 :     static void
1469 :     stats_print(rc_2pass2_t * rc)
1470 :     {
1471 :     int i;
1472 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
1473 :    
1474 :     for (i=0; i<rc->num_frames; i++) {
1475 :     twopass_stat_t *s = &rc->stats[i];
1476 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- frame:%d type:%c quant:%d stats:%d scaled:%d desired:%d actual:%d overflow(%c):%.2f\n",
1477 :     i, frame_type[s->type-1], -1, s->length, s->scaled_length,
1478 :     s->desired_length, -1, frame_type[s->type-1], -1.0f);
1479 :     }
1480 :     }
1481 :     #endif

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4