[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 1202 - (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 1202 * $Id: plugin_2pass2.c,v 1.1.2.24 2003-11-09 20:49:21 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 :     int fields, nouse;
827 :    
828 :     lines++;
829 :    
830 :     /* We skip spaces */
831 :     ptr = skipspaces(line);
832 :    
833 :     /* Skip coment lines */
834 :     if(iscomment(ptr)) {
835 :     free(line);
836 :     continue;
837 : edgomez 1064 }
838 : edgomez 1202
839 :     /* Read the stat line from buffer */
840 :     fields = sscanf(ptr,
841 :     "%c %d %d %d %d %d",
842 :     &type, &nouse, &nouse, &nouse, &nouse, &nouse);
843 :    
844 :     /* Valid stats files have at least 6 fields */
845 :     if (fields == 6) {
846 :     switch(type) {
847 :     case 'i':
848 :     case 'I':
849 :     rc->num_keyframes++;
850 :     case 'p':
851 :     case 'P':
852 :     case 'b':
853 :     case 'B':
854 :     case 's':
855 :     case 'S':
856 :     rc->num_frames++;
857 :     break;
858 :     default:
859 :     DPRINTF(XVID_DEBUG_RC,
860 :     "[xvid rc] -- WARNING: L%d unknown frame type used (%c).\n",
861 :     lines, type);
862 :     }
863 :     } else {
864 :     DPRINTF(XVID_DEBUG_RC,
865 :     "[xvid rc] -- WARNING: L%d misses some stat fields (%d).\n",
866 :     lines, 6-fields);
867 :     }
868 :    
869 :     /* Free the line buffer */
870 :     free(line);
871 : edgomez 1064 }
872 : suxen_drol 942
873 : edgomez 1202 /* We are done with the file */
874 : edgomez 1064 fclose(f);
875 : suxen_drol 942
876 : edgomez 1202 return(0);
877 : edgomez 1042 }
878 : suxen_drol 942
879 : edgomez 1042 /* open stats file(s) and read into rc->stats array */
880 :     static int
881 : edgomez 1202 statsfile_load(rc_2pass2_t *rc, char * filename)
882 : edgomez 1042 {
883 : edgomez 1064 FILE * f;
884 : edgomez 1202 int processed_entries;
885 : edgomez 1042
886 : edgomez 1202 /* Opens the file */
887 :     if ((f = fopen(filename, "rb"))==NULL)
888 :     return(-1);
889 : edgomez 1064
890 : edgomez 1202 processed_entries = 0;
891 :     while(processed_entries < rc->num_frames) {
892 : edgomez 1064 char type;
893 : edgomez 1202 int fields;
894 :     twopass_stat_t * s = &rc->stats[processed_entries];
895 :     char *line, *ptr;
896 : edgomez 1042
897 : edgomez 1202 /* Read the line from the file */
898 :     if((line = readline(f)) == NULL)
899 :     break;
900 :    
901 :     /* We skip spaces */
902 :     ptr = skipspaces(line);
903 :    
904 :     /* Skip comment lines */
905 :     if(iscomment(ptr)) {
906 :     free(line);
907 :     continue;
908 : edgomez 1042 }
909 :    
910 : edgomez 1202 /* Reset this field that is optional */
911 :     s->scaled_length = 0;
912 :    
913 :     /* Convert the fields */
914 :     fields = sscanf(ptr,
915 :     "%c %d %d %d %d %d %d\n",
916 :     &type,
917 :     &s->quant,
918 :     &s->blks[0], &s->blks[1], &s->blks[2],
919 :     &s->length,
920 :     &s->scaled_length);
921 :    
922 :     /* Free line buffer, we don't need it anymore */
923 :     free(line);
924 :    
925 :     /* Fail silently, this has probably been warned in
926 :     * statsfile_count_frames */
927 :     if(fields != 6 && fields != 7)
928 :     continue;
929 :    
930 :     /* Convert frame type */
931 :     switch(type) {
932 :     case 'i':
933 :     case 'I':
934 : edgomez 1064 s->type = XVID_TYPE_IVOP;
935 : edgomez 1202 break;
936 :     case 'p':
937 :     case 'P':
938 :     case 's':
939 :     case 'S':
940 : edgomez 1064 s->type = XVID_TYPE_PVOP;
941 : edgomez 1202 break;
942 :     case 'b':
943 :     case 'B':
944 : edgomez 1064 s->type = XVID_TYPE_BVOP;
945 : edgomez 1202 break;
946 :     default:
947 :     /* Same as before, fail silently */
948 :     continue;
949 : edgomez 1064 }
950 : edgomez 1042
951 : edgomez 1202 /* Ok it seems it's been processed correctly */
952 :     processed_entries++;
953 : edgomez 1064 }
954 : suxen_drol 942
955 : edgomez 1202 /* Close the file */
956 : edgomez 1042 fclose(f);
957 :    
958 : edgomez 1202 return(0);
959 : suxen_drol 942 }
960 : edgomez 1042
961 : edgomez 1161 /* pre-process the statistics data
962 : edgomez 1202 * - for each type, count, tot_length, min_length, max_length
963 :     * - set keyframes_locations */
964 : edgomez 1042 static void
965 : edgomez 1202 first_pass_stats_prepare_data(rc_2pass2_t * rc)
966 : edgomez 1042 {
967 : edgomez 1064 int i,j;
968 : edgomez 1042
969 : edgomez 1202 /* *rc fields initialization
970 : edgomez 1048 * NB: INT_MAX and INT_MIN are used in order to be immediately replaced
971 : edgomez 1202 * with real values of the 1pass */
972 : edgomez 1064 for (i=0; i<3; i++) {
973 : edgomez 1048 rc->count[i]=0;
974 :     rc->tot_length[i] = 0;
975 : edgomez 1042 rc->min_length[i] = INT_MAX;
976 : edgomez 1064 }
977 : edgomez 1042
978 :     rc->max_length = INT_MIN;
979 :    
980 : edgomez 1202 /* Loop through all frames and find/compute all the stuff this function
981 :     * is supposed to do */
982 : edgomez 1048 for (i=j=0; i<rc->num_frames; i++) {
983 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
984 : edgomez 1042
985 : edgomez 1048 rc->count[s->type-1]++;
986 :     rc->tot_length[s->type-1] += s->length;
987 : edgomez 1042
988 : edgomez 1048 if (s->length < rc->min_length[s->type-1]) {
989 :     rc->min_length[s->type-1] = s->length;
990 :     }
991 : edgomez 1042
992 : edgomez 1048 if (s->length > rc->max_length) {
993 :     rc->max_length = s->length;
994 :     }
995 : edgomez 1042
996 : edgomez 1048 if (s->type == XVID_TYPE_IVOP) {
997 :     rc->keyframe_locations[j] = i;
998 :     j++;
999 :     }
1000 :     }
1001 :    
1002 : edgomez 1202 /* NB:
1003 : edgomez 1042 * The "per sequence" overflow system considers a natural sequence to be
1004 :     * formed by all frames between two iframes, so if we want to make sure
1005 :     * the system does not go nuts during last sequence, we force the last
1006 : edgomez 1202 * frame to appear in the keyframe locations array. */
1007 : edgomez 1064 rc->keyframe_locations[j] = i;
1008 : edgomez 1042
1009 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass IFrame length: %d\n", rc->min_length[0]);
1010 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass PFrame length: %d\n", rc->min_length[1]);
1011 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass BFrame length: %d\n", rc->min_length[2]);
1012 : edgomez 1042 }
1013 : edgomez 1064
1014 : edgomez 1042 /* calculate zone weight "center" */
1015 :     static void
1016 :     zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create)
1017 :     {
1018 : edgomez 1064 int i,j;
1019 :     int n = 0;
1020 : edgomez 1042
1021 : edgomez 1064 rc->avg_weight = 0.0;
1022 :     rc->tot_quant = 0;
1023 : edgomez 1042
1024 :    
1025 : edgomez 1064 if (create->num_zones == 0) {
1026 :     for (j = 0; j < rc->num_frames; j++) {
1027 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1028 :     rc->stats[j].weight = 1.0;
1029 :     }
1030 :     rc->avg_weight += rc->num_frames * 1.0;
1031 :     n += rc->num_frames;
1032 :     }
1033 : edgomez 1042
1034 :    
1035 : edgomez 1064 for(i=0; i < create->num_zones; i++) {
1036 : edgomez 1042
1037 : edgomez 1064 int next = (i+1<create->num_zones) ? create->zones[i+1].frame : rc->num_frames;
1038 : edgomez 1042
1039 : edgomez 1064 if (i==0 && create->zones[i].frame > 0) {
1040 :     for (j = 0; j < create->zones[i].frame && j < rc->num_frames; j++) {
1041 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1042 :     rc->stats[j].weight = 1.0;
1043 :     }
1044 :     rc->avg_weight += create->zones[i].frame * 1.0;
1045 :     n += create->zones[i].frame;
1046 :     }
1047 : edgomez 1042
1048 : edgomez 1064 if (create->zones[i].mode == XVID_ZONE_WEIGHT) {
1049 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1050 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1051 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1052 :     }
1053 :     next -= create->zones[i].frame;
1054 :     rc->avg_weight += (double)(next * create->zones[i].increment) / (double)create->zones[i].base;
1055 :     n += next;
1056 :     }else{ /* XVID_ZONE_QUANT */
1057 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1058 :     rc->stats[j].zone_mode = XVID_ZONE_QUANT;
1059 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1060 :     rc->tot_quant += rc->stats[j].length;
1061 :     }
1062 :     }
1063 :     }
1064 :     rc->avg_weight = n>0 ? rc->avg_weight/n : 1.0;
1065 :    
1066 : 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);
1067 : edgomez 1042 }
1068 :    
1069 :    
1070 :     /* scale the curve */
1071 :     static void
1072 : edgomez 1202 first_pass_scale_curve_internal(rc_2pass2_t *rc)
1073 : edgomez 1042 {
1074 : edgomez 1202 int64_t target;
1075 :     int64_t pass1_length;
1076 : edgomez 1042 double scaler;
1077 : edgomez 1047 int i, num_MBs;
1078 : edgomez 1042
1079 : edgomez 1202 /* We remove the bytes used by the fixed quantizer zones
1080 :     * ToDo: this approach is flawed, the same amount of bytes is removed from
1081 :     * target and first pass data, this has no sense, zone_process should
1082 :     * give us two results one for unscaled data (1pass) and the other
1083 :     * one for scaled data and we should then write:
1084 :     * target = rc->target - rc->tot_quant_scaled;
1085 :     * pass1_length = rc->i+p+b - rc->tot_quant_firstpass */
1086 :     target = rc->target - rc->tot_quant;
1087 :    
1088 :     /* Do the same for the first pass data */
1089 :     pass1_length = rc->tot_length[XVID_TYPE_IVOP-1];
1090 :     pass1_length += rc->tot_length[XVID_TYPE_PVOP-1];
1091 :     pass1_length += rc->tot_length[XVID_TYPE_BVOP-1];
1092 :     pass1_length -= rc->tot_quant;
1093 :    
1094 : edgomez 1042 /* Let's compute a linear scaler in order to perform curve scaling */
1095 :     scaler = (double)target / (double)pass1_length;
1096 :    
1097 :     if (target <= 0 || pass1_length <= 0 || target >= pass1_length) {
1098 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- WARNING: Undersize detected before correction\n");
1099 : edgomez 1064 scaler = 1.0;
1100 : edgomez 1042 }
1101 :    
1102 : edgomez 1202 /* Compute min frame lengths (for each frame type) according to the number
1103 :     * of MBs. We sum all block type counters of frame 0, this gives us the
1104 :     * number of MBs.
1105 : edgomez 1049 *
1106 :     * We compare these hardcoded values with observed values in first pass
1107 : edgomez 1202 * (determined in pre_process0).Then we keep the real minimum. */
1108 : edgomez 1047
1109 : edgomez 1202 /* Number of MBs */
1110 :     num_MBs = rc->stats[0].blks[0];
1111 :     num_MBs += rc->stats[0].blks[1];
1112 :     num_MBs += rc->stats[0].blks[2];
1113 : edgomez 1049
1114 : edgomez 1202 /* Minimum for I frames */
1115 :     if(rc->min_length[XVID_TYPE_IVOP-1] > ((num_MBs*22) + 240) / 8)
1116 :     rc->min_length[XVID_TYPE_IVOP-1] = ((num_MBs*22) + 240) / 8;
1117 : edgomez 1049
1118 : edgomez 1202 /* Minimum for P/S frames */
1119 :     if(rc->min_length[XVID_TYPE_PVOP-1] > ((num_MBs) + 88) / 8)
1120 :     rc->min_length[XVID_TYPE_PVOP-1] = ((num_MBs) + 88) / 8;
1121 : edgomez 1049
1122 : edgomez 1202 /* Minimum for B frames */
1123 :     if(rc->min_length[XVID_TYPE_BVOP-1] > 8)
1124 :     rc->min_length[XVID_TYPE_BVOP-1] = 8;
1125 :    
1126 :     /* Perform an initial scale pass.
1127 :     *
1128 : edgomez 1042 * If a frame size is scaled underneath our hardcoded minimums, then we
1129 :     * force the frame size to the minimum, and deduct the original & scaled
1130 : edgomez 1202 * frame length from the original and target total lengths */
1131 : edgomez 1042 for (i=0; i<rc->num_frames; i++) {
1132 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1133 : edgomez 1042 int len;
1134 :    
1135 : edgomez 1202 /* No need to scale frame length for which a specific quantizer is
1136 :     * specified thanks to zones */
1137 : edgomez 1064 if (s->zone_mode == XVID_ZONE_QUANT) {
1138 :     s->scaled_length = s->length;
1139 : edgomez 1042 continue;
1140 :     }
1141 :    
1142 : edgomez 1048 /* Compute the scaled length */
1143 : edgomez 1042 len = (int)((double)s->length * scaler * s->weight / rc->avg_weight);
1144 :    
1145 :     /* Compare with the computed minimum */
1146 : edgomez 1049 if (len < rc->min_length[s->type-1]) {
1147 : edgomez 1202 /* This is a 'forced size' frame, set its frame size to the
1148 :     * computed minimum */
1149 : edgomez 1049 s->scaled_length = rc->min_length[s->type-1];
1150 : edgomez 1202
1151 :     /* Remove both scaled and original size from their respective
1152 :     * total counters, as we prepare a second pass for 'regular'
1153 :     * frames */
1154 : edgomez 1042 target -= s->scaled_length;
1155 :     pass1_length -= s->length;
1156 :     } else {
1157 :     /* Do nothing for now, we'll scale this later */
1158 :     s->scaled_length = 0;
1159 :     }
1160 :     }
1161 :    
1162 : edgomez 1202 /* The first pass on data substracted all 'forced size' frames from the
1163 :     * total counters. Now, it's possible to scale the 'regular' frames. */
1164 :    
1165 :     /* Scaling factor for 'regular' frames */
1166 : edgomez 1042 scaler = (double)target / (double)pass1_length;
1167 :    
1168 :     /* Detect undersizing */
1169 : edgomez 1064 if (target <= 0 || pass1_length <= 0 || target >= pass1_length) {
1170 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- WARNING: Undersize detected after correction\n");
1171 : edgomez 1042 scaler = 1.0;
1172 :     }
1173 :    
1174 :     /* Do another pass with the new scaler */
1175 :     for (i=0; i<rc->num_frames; i++) {
1176 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1177 : edgomez 1042
1178 :     /* Ignore frame with forced frame sizes */
1179 :     if (s->scaled_length == 0)
1180 :     s->scaled_length = (int)((double)s->length * scaler * s->weight / rc->avg_weight);
1181 :     }
1182 : edgomez 1202
1183 :     /* Job done */
1184 :     return;
1185 : edgomez 1042 }
1186 :    
1187 : edgomez 1202 /* Apply all user settings to the scaled curve
1188 :     * This implies:
1189 :     * keyframe boosting
1190 :     * high/low compression */
1191 : edgomez 1042 static void
1192 : edgomez 1202 scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc)
1193 : edgomez 1042 {
1194 : edgomez 1064 int i;
1195 :     uint64_t ivop_boost_total;
1196 : edgomez 1042
1197 : edgomez 1202 /* Reset the rate controller (per frame type) total byte counters */
1198 :     for (i=0; i<3; i++) rc->tot_scaled_length[i] = 0;
1199 : edgomez 1042
1200 : edgomez 1202 /* Compute total bytes for each frame type */
1201 :     for (i=0; i<rc->num_frames;i++) {
1202 :     twopass_stat_t *s = &rc->stats[i];
1203 :     rc->tot_scaled_length[s->type-1] += s->scaled_length;
1204 : edgomez 1064 }
1205 : edgomez 1042
1206 : edgomez 1202 /* First we compute the total amount of bits needed, as being described by
1207 :     * the scaled distribution. During this pass over the complete stats data,
1208 :     * we see how much bits two user settings will get/give from/to p&b frames:
1209 :     * - keyframe boosting
1210 :     * - keyframe distance penalty */
1211 :     rc->KF_idx = 0;
1212 :     ivop_boost_total = 0;
1213 : edgomez 1064 for (i=0; i<rc->num_frames; i++) {
1214 : edgomez 1202 twopass_stat_t * s = &rc->stats[i];
1215 : edgomez 1042
1216 : edgomez 1202 /* Some more work is needed for I frames */
1217 :     if (s->type == XVID_TYPE_IVOP) {
1218 :     int penalty_distance;
1219 :     int ivop_boost;
1220 : edgomez 1042
1221 : edgomez 1202 /* Accumulate bytes needed for keyframe boosting */
1222 :     ivop_boost = s->scaled_length*rc->param.keyframe_boost/100;
1223 :    
1224 :     if (rc->KF_idx) {
1225 :     /* Minimum keyframe distance penalties */
1226 :     penalty_distance = rc->param.min_key_interval;
1227 :     penalty_distance -= rc->keyframe_locations[rc->KF_idx];
1228 :     penalty_distance += rc->keyframe_locations[rc->KF_idx-1];
1229 :    
1230 :     /* Ah ah ! guilty keyframe, you're under arrest ! */
1231 :     if (penalty_distance > 0)
1232 :     ivop_boost -= (s->scaled_length + ivop_boost)*penalty_distance*rc->param.kfreduction/100;
1233 :     }
1234 :    
1235 :     /* If the frame size drops under the minimum length, then cap ivop_boost */
1236 :     if (ivop_boost + s->scaled_length < rc->min_length[XVID_TYPE_IVOP-1])
1237 :     ivop_boost = rc->min_length[XVID_TYPE_IVOP-1] - s->scaled_length;
1238 :    
1239 :     /* Accumulate the ivop boost */
1240 :     ivop_boost_total += ivop_boost;
1241 :    
1242 :     /* Don't forget to update the keyframe index */
1243 :     rc->KF_idx++;
1244 : edgomez 1064 }
1245 :     }
1246 : edgomez 1042
1247 : edgomez 1202 /* Initialize the IBoost tax ratio for P/S/B frames
1248 :     *
1249 :     * This ratio has to be applied to p/b/s frames in order to reserve
1250 :     * additional bits for keyframes (keyframe boosting) or if too much
1251 :     * keyframe distance is applied, bits retrieved from the keyframes.
1252 :     *
1253 :     * ie pb_length *= rc->pb_iboost_tax_ratio;
1254 :     *
1255 :     * gives the ideal length of a p/b frame */
1256 : edgomez 1042
1257 : edgomez 1202 /* Compute the total length of p/b/s frames (temporary storage into
1258 :     * movie_curve) */
1259 :     rc->pb_iboost_tax_ratio = (double)rc->tot_scaled_length[XVID_TYPE_PVOP-1];
1260 :     rc->pb_iboost_tax_ratio += (double)rc->tot_scaled_length[XVID_TYPE_BVOP-1];
1261 :    
1262 :     /* Compute the ratio described above
1263 :     * taxed_total = sum(0, n, tax*scaled_length)
1264 :     * <=> taxed_total = tax.sum(0, n, tax*scaled_length)
1265 :     * <=> tax = taxed_total / original_total */
1266 :     rc->pb_iboost_tax_ratio =
1267 :     (rc->pb_iboost_tax_ratio - ivop_boost_total) /
1268 :     rc->pb_iboost_tax_ratio;
1269 :    
1270 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- IFrame boost tax ratio:%.2f\n",
1271 :     rc->pb_iboost_tax_ratio);
1272 :    
1273 :     /* Compute the average size of frames per frame type */
1274 : edgomez 1064 for(i=0; i<3; i++) {
1275 : edgomez 1202 /* Special case for missing type or weird case */
1276 :     if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1277 : edgomez 1064 rc->avg_length[i] = 1;
1278 : edgomez 1202 } else {
1279 :     rc->avg_length[i] = rc->tot_scaled_length[i];
1280 :    
1281 :     if (i == XVID_TYPE_IVOP) {
1282 :     /* I Frames total has to be added the boost total */
1283 :     rc->avg_length[i] += ivop_boost_total;
1284 :     } else {
1285 :     /* P/B frames has to taxed */
1286 :     rc->avg_length[i] *= rc->pb_iboost_tax_ratio;
1287 :     }
1288 :    
1289 :     /* Finally compute the average frame size */
1290 :     rc->avg_length[i] /= (double)rc->count[i];
1291 : edgomez 1064 }
1292 :     }
1293 : edgomez 1042
1294 : edgomez 1202 /* Assymetric curve compression */
1295 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
1296 :     double symetric_total;
1297 :     double assymetric_delta_total;
1298 : edgomez 1042
1299 : edgomez 1202 /* Like I frame boosting, assymetric curve compression modifies the total
1300 :     * amount of needed bits, we must compute the ratio so we can prescale
1301 :     lengths */
1302 :     symetric_total = 0;
1303 :     assymetric_delta_total = 0;
1304 :     for (i=0; i<rc->num_frames; i++) {
1305 :     double assymetric_delta;
1306 :     double dbytes;
1307 :     twopass_stat_t * s = &rc->stats[i];
1308 : edgomez 1042
1309 : edgomez 1202 /* I Frames are not concerned by assymetric scaling */
1310 :     if (s->type == XVID_TYPE_IVOP)
1311 :     continue;
1312 : edgomez 1042
1313 : edgomez 1202 /* During the real run, we would have to apply the iboost tax */
1314 :     dbytes = s->scaled_length * rc->pb_iboost_tax_ratio;
1315 : edgomez 1042
1316 : edgomez 1202 /* Update the symmetric curve compression total */
1317 :     symetric_total += dbytes;
1318 : edgomez 1064
1319 : edgomez 1202 /* Apply assymetric curve compression */
1320 :     if (dbytes > rc->avg_length[s->type-1])
1321 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_high / 100.0f;
1322 :     else
1323 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_low / 100.0f;
1324 : edgomez 1042
1325 : edgomez 1202 /* Cap to the minimum frame size if needed */
1326 :     if (dbytes + assymetric_delta < rc->min_length[s->type-1])
1327 :     assymetric_delta = rc->min_length[s->type-1] - dbytes;
1328 : edgomez 1051
1329 : edgomez 1202 /* Accumulate after assymetric curve compression */
1330 :     assymetric_delta_total += assymetric_delta;
1331 : edgomez 1064 }
1332 : edgomez 1202
1333 :     /* Compute the tax that all p/b frames have to pay in order to respect the
1334 :     * bit distribution changes that the assymetric compression curve imposes
1335 :     * We want assymetric_total = sum(0, n-1, tax.scaled_length)
1336 :     * ie assymetric_total = ratio.sum(0, n-1, scaled_length)
1337 :     * ratio = assymetric_total / symmetric_total */
1338 :     rc->assymetric_tax_ratio = ((double)symetric_total - (double)assymetric_delta_total) / (double)symetric_total;
1339 :     } else {
1340 :     rc->assymetric_tax_ratio = 1.0f;
1341 : edgomez 1064 }
1342 : edgomez 1042
1343 : edgomez 1202 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Assymetric tax ratio:%.2f\n", rc->assymetric_tax_ratio);
1344 : edgomez 1042
1345 : edgomez 1202 /* Last bits that need to be reset */
1346 : edgomez 1064 rc->overflow = 0;
1347 :     rc->KFoverflow = 0;
1348 :     rc->KFoverflow_partial = 0;
1349 : edgomez 1202 rc->KF_idx = 0;
1350 :     rc->desired_total = 0;
1351 :     rc->real_total = 0;
1352 :    
1353 :     /* Job done */
1354 :     return;
1355 : edgomez 1042 }
1356 : edgomez 1202
1357 :     /*****************************************************************************
1358 :     * Still more low level stuff (nothing to do with stats treatment)
1359 :     ****************************************************************************/
1360 :    
1361 :     /* This function returns an allocated string containing a complete line read
1362 :     * from the file starting at the current position */
1363 :     static char *
1364 :     readline(FILE *f)
1365 :     {
1366 :     char *buffer = NULL;
1367 :     int buffer_size = 0;
1368 :     int pos = 0;
1369 :    
1370 :     do {
1371 :     int c;
1372 :    
1373 :     /* Read a character from the stream */
1374 :     c = fgetc(f);
1375 :    
1376 :     /* Is that EOF or new line ? */
1377 :     if(c == EOF || c == '\n')
1378 :     break;
1379 :    
1380 :     /* Do we have to update buffer ? */
1381 :     if(pos >= buffer_size - 1) {
1382 :     buffer_size += BUF_SZ;
1383 :     buffer = (char*)realloc(buffer, buffer_size);
1384 :     if (buffer == NULL)
1385 :     return(NULL);
1386 :     }
1387 :    
1388 :     buffer[pos] = c;
1389 :     pos++;
1390 :     } while(1);
1391 :    
1392 :     /* Read \n or EOF */
1393 :     if (buffer == NULL) {
1394 :     /* EOF, so we reached the end of the file, return NULL */
1395 :     if(feof(f))
1396 :     return(NULL);
1397 :    
1398 :     /* Just an empty line with just a newline, allocate a 1 byte buffer to
1399 :     * store a zero length string */
1400 :     buffer = (char*)malloc(1);
1401 :     if(buffer == NULL)
1402 :     return(NULL);
1403 :     }
1404 :    
1405 :     /* Zero terminated string */
1406 :     buffer[pos] = '\0';
1407 :    
1408 :     return(buffer);
1409 :     }
1410 :    
1411 :     /* This function returns a pointer to the first non space char in the given
1412 :     * string */
1413 :     static char *
1414 :     skipspaces(char *string)
1415 :     {
1416 :     const char spaces[] =
1417 :     {
1418 :     ' ','\t','\0'
1419 :     };
1420 :     const char *spacechar = spaces;
1421 :    
1422 :     if (string == NULL) return(NULL);
1423 :    
1424 :     while (*string != '\0') {
1425 :     /* Test against space chars */
1426 :     while (*spacechar != '\0') {
1427 :     if (*string == *spacechar) {
1428 :     string++;
1429 :     spacechar = spaces;
1430 :     break;
1431 :     }
1432 :     spacechar++;
1433 :     }
1434 :    
1435 :     /* No space char */
1436 :     if (*spacechar == '\0') return(string);
1437 :     }
1438 :    
1439 :     return(string);
1440 :     }
1441 :    
1442 :     /* This function returns a boolean that tells if the string is only a
1443 :     * comment */
1444 :     static int
1445 :     iscomment(char *string)
1446 :     {
1447 :     const char comments[] =
1448 :     {
1449 :     '#',';', '%', '\0'
1450 :     };
1451 :     const char *cmtchar = comments;
1452 :     int iscomment = 0;
1453 :    
1454 :     if (string == NULL) return(1);
1455 :    
1456 :     string = skipspaces(string);
1457 :    
1458 :     while(*cmtchar != '\0') {
1459 :     if(*string == *cmtchar) {
1460 :     iscomment = 1;
1461 :     break;
1462 :     }
1463 :     cmtchar++;
1464 :     }
1465 :    
1466 :     return(iscomment);
1467 :     }
1468 :    
1469 :     #if 0
1470 :     static void
1471 :     stats_print(rc_2pass2_t * rc)
1472 :     {
1473 :     int i;
1474 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
1475 :    
1476 :     for (i=0; i<rc->num_frames; i++) {
1477 :     twopass_stat_t *s = &rc->stats[i];
1478 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- frame:%d type:%c quant:%d stats:%d scaled:%d desired:%d actual:%d overflow(%c):%.2f\n",
1479 :     i, frame_type[s->type-1], -1, s->length, s->scaled_length,
1480 :     s->desired_length, -1, frame_type[s->type-1], -1.0f);
1481 :     }
1482 :     }
1483 :     #endif

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