[svn] / trunk / xvidcore / src / plugins / plugin_2pass2.c Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/src/plugins/plugin_2pass2.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1988 - (view) (download)

1 : edgomez 1382 /******************************************************************************
2 :     *
3 : Isibaar 1883 * Xvid Bit Rate Controller Library
4 : edgomez 1382 * - VBR 2 pass bitrate controller implementation -
5 :     *
6 : Isibaar 1883 * Copyright (C) 2002 Benjamin Lambert <foxer@hotmail.com>
7 : edgomez 1382 * 2002 Dirk Knop <dknop@gwdg.de>
8 :     * 2002-2003 Edouard Gomez <ed.gomez@free.fr>
9 :     * 2003 Pete Ross <pross@xvid.org>
10 :     *
11 :     * This curve treatment algorithm is the one originally implemented by Foxer
12 : Isibaar 1883 * and tuned by Dirk Knop for the Xvid vfw frontend.
13 : edgomez 1382 *
14 :     * 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 :     *
19 :     * 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 :     *
24 :     * 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 :     *
28 : Isibaar 1988 * $Id$
29 : edgomez 1382 *
30 :     *****************************************************************************/
31 :    
32 :     #define BQUANT_PRESCALE
33 :     #undef COMPENSATE_FORMULA
34 :    
35 :     /* forces second pass not to be bigger than first */
36 :     #undef PASS_SMALLER
37 :    
38 : edgomez 1473 /* automatically alters overflow controls (strength and improvement/degradation)
39 : edgomez 1382 to fight most common problems without user's knowladge */
40 :     #define SMART_OVERFLOW_SETTING
41 :    
42 :     #include <stdio.h>
43 :     #include <math.h>
44 :     #include <limits.h>
45 :    
46 :     #include "../xvid.h"
47 :     #include "../image/image.h"
48 :    
49 :     /*****************************************************************************
50 :     * Some default settings
51 :     ****************************************************************************/
52 :    
53 :     #define DEFAULT_KEYFRAME_BOOST 0
54 :     #define DEFAULT_OVERFLOW_CONTROL_STRENGTH 10
55 :     #define DEFAULT_CURVE_COMPRESSION_HIGH 0
56 :     #define DEFAULT_CURVE_COMPRESSION_LOW 0
57 :     #define DEFAULT_MAX_OVERFLOW_IMPROVEMENT 10
58 :     #define DEFAULT_MAX_OVERFLOW_DEGRADATION 10
59 :    
60 :     /* Keyframe settings */
61 :     #define DEFAULT_KFREDUCTION 20
62 :     #define DEFAULT_KFTHRESHOLD 1
63 :    
64 :     /*****************************************************************************
65 :     * Some default constants (can be tuned)
66 :     ****************************************************************************/
67 :    
68 :     /* Specify the invariant part of the headers bits (header+MV)
69 :     * as hlength/cst */
70 :     #define INVARIANT_HEADER_PART_IVOP 1 /* factor 1.0f */
71 :     #define INVARIANT_HEADER_PART_PVOP 2 /* factor 0.5f */
72 :     #define INVARIANT_HEADER_PART_BVOP 8 /* factor 0.125f */
73 :    
74 :     /*****************************************************************************
75 :     * Structures
76 :     ****************************************************************************/
77 :    
78 :     /* Statistics */
79 :     typedef struct {
80 :     int type; /* first pass type */
81 :     int quant; /* first pass quant */
82 :     int blks[3]; /* k,m,y blks */
83 :     int length; /* first pass length */
84 :     int invariant; /* what we assume as being invariant between the two passes, it's a sub part of header + MV bits */
85 :     int scaled_length; /* scaled length */
86 :     int desired_length; /* desired length; calculated during encoding */
87 :     int error;
88 :    
89 :     int zone_mode; /* XVID_ZONE_xxx */
90 :     double weight;
91 :     } twopass_stat_t;
92 :    
93 :     /* Context struct */
94 :     typedef struct
95 :     {
96 :     xvid_plugin_2pass2_t param;
97 :    
98 :     /*----------------------------------
99 :     * constant statistical data
100 :     *--------------------------------*/
101 :    
102 :     /* Number of frames of the sequence */
103 :     int num_frames;
104 :    
105 :     /* Number of Intra frames of the sequence */
106 :     int num_keyframes;
107 :    
108 :     /* Target filesize to reach */
109 :     uint64_t target;
110 :    
111 :     /* Count of each frame types */
112 :     int count[3];
113 :    
114 :     /* Total length of each frame types (1st pass) */
115 :     uint64_t tot_length[3];
116 :     uint64_t tot_invariant[3];
117 :    
118 :     /* Average length of each frame types (used first for 1st pass data and
119 :     * then for scaled averages */
120 :     double avg_length[3];
121 :    
122 :     /* Minimum frame length allowed for each frame type */
123 :     int min_length[3];
124 :    
125 :     /* Total bytes per frame type once the curve has been scaled
126 :     * NB: advanced parameters do not change this value. This field
127 :     * represents the total scaled w/o any advanced settings */
128 :     uint64_t tot_scaled_length[3];
129 :    
130 :     /* Maximum observed frame size observed during the first pass, the RC
131 :     * will try tp force all frame sizes in the second pass to be under that
132 :     * limit */
133 :     int max_length;
134 :    
135 :     /*----------------------------------
136 :     * Zones statistical data
137 :     *--------------------------------*/
138 :    
139 :     /* Total length used by XVID_ZONE_QUANT zones */
140 :     uint64_t tot_quant;
141 :     uint64_t tot_quant_invariant;
142 :    
143 :     /* Holds the total amount of frame bytes, zone weighted (only scalable
144 :     * part of frame bytes) */
145 :     uint64_t tot_weighted;
146 :    
147 :     /*----------------------------------
148 :     * Advanced settings helper ratios
149 :     *--------------------------------*/
150 :    
151 :     /* This the ratio that has to be applied to all p/b frames in order
152 :     * to reserve/retrieve bits for/from keyframe boosting and consecutive
153 :     * keyframe penalty */
154 :     double pb_iboost_tax_ratio;
155 :    
156 :     /* This the ratio to apply to all b/p frames in order to respect the
157 :     * assymetric curve compression while respecting a target filesize
158 :     * NB: The assymetric delta gain has to be computed before this ratio
159 :     * is applied, and then the delta is added to the scaled size */
160 :     double assymetric_tax_ratio;
161 :    
162 :     /*----------------------------------
163 :     * Data from the stats file kept
164 :     * into RAM for easy access
165 :     *--------------------------------*/
166 :    
167 :     /* Array of keyframe locations
168 :     * eg: rc->keyframe_locations[100] returns the frame number of the 100th
169 :     * keyframe */
170 :     int *keyframe_locations;
171 :    
172 :     /* Index of the last keyframe used in the keyframe_location */
173 :     int KF_idx;
174 :    
175 :     /* Array of all 1st pass data file -- see the twopass_stat_t structure
176 :     * definition for more details */
177 :     twopass_stat_t * stats;
178 :    
179 :     /*----------------------------------
180 : chl 1470 * Hysteresis helpers
181 : edgomez 1382 *--------------------------------*/
182 :    
183 :     /* This field holds the int2float conversion errors of each quant per
184 :     * frame type, this allow the RC to keep track of rouding error and thus
185 :     * increase or decrease the chosen quant according to this residue */
186 :     double quant_error[3][32];
187 :    
188 :     /* This fields stores the count of each quant usage per frame type
189 :     * No real role but for debugging */
190 :     int quant_count[3][32];
191 :    
192 :     /* Last valid quantizer used per frame type, it allows quantizer
193 :     * increament/decreament limitation in order to avoid big image quality
194 :     * "jumps" */
195 :     int last_quant[3];
196 :    
197 :     /*----------------------------------
198 :     * Overflow control
199 :     *--------------------------------*/
200 :    
201 :     /* Current overflow that has to be distributed to p/b frames */
202 :     double overflow;
203 :    
204 :     /* Total overflow for keyframes -- not distributed directly */
205 :     double KFoverflow;
206 :    
207 :     /* Amount of keyframe overflow to introduce to the global p/b frame
208 :     * overflow counter at each encoded frame */
209 :     double KFoverflow_partial;
210 :    
211 :     /* Unknown ???
212 :     * ToDo: description */
213 :     double fq_error;
214 :    
215 :     int min_quant; /* internal minimal quant, prevents wrong quants from being used */
216 :    
217 :     /*----------------------------------
218 :     * Debug
219 :     *--------------------------------*/
220 :     double desired_total;
221 :     double real_total;
222 : Isibaar 1883
223 :     int scaled_frames;
224 : edgomez 1382 } rc_2pass2_t;
225 :    
226 :    
227 :     /*****************************************************************************
228 :     * Sub plugin functions prototypes
229 :     ****************************************************************************/
230 :    
231 :     static int rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t ** handle);
232 :     static int rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data);
233 :     static int rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data);
234 :     static int rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy);
235 :    
236 :     /*****************************************************************************
237 :     * Plugin definition
238 :     ****************************************************************************/
239 :    
240 :     int
241 :     xvid_plugin_2pass2(void * handle, int opt, void * param1, void * param2)
242 :     {
243 :     switch(opt) {
244 :     case XVID_PLG_INFO :
245 :     case XVID_PLG_FRAME :
246 :     return 0;
247 :    
248 :     case XVID_PLG_CREATE :
249 :     return rc_2pass2_create((xvid_plg_create_t*)param1, param2);
250 :    
251 :     case XVID_PLG_DESTROY :
252 :     return rc_2pass2_destroy((rc_2pass2_t*)handle, (xvid_plg_destroy_t*)param1);
253 :    
254 :     case XVID_PLG_BEFORE :
255 :     return rc_2pass2_before((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
256 :    
257 :     case XVID_PLG_AFTER :
258 :     return rc_2pass2_after((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
259 :     }
260 :    
261 :     return XVID_ERR_FAIL;
262 :     }
263 :    
264 :     /*****************************************************************************
265 :     * Sub plugin functions definitions
266 :     ****************************************************************************/
267 :    
268 :     /* First a few local helping function prototypes */
269 :     static int statsfile_count_frames(rc_2pass2_t * rc, char * filename);
270 :     static int statsfile_load(rc_2pass2_t *rc, char * filename);
271 :     static void zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create);
272 :     static void first_pass_stats_prepare_data(rc_2pass2_t * rc);
273 :     static void first_pass_scale_curve_internal(rc_2pass2_t *rc);
274 :     static void scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc);
275 : chl 1470 static int check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);
276 :     static int scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);
277 : edgomez 1382 #if 0
278 :     static void stats_print(rc_2pass2_t * rc);
279 :     #endif
280 :    
281 :     /*----------------------------------------------------------------------------
282 :     *--------------------------------------------------------------------------*/
283 :    
284 :     static int
285 :     rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t **handle)
286 :     {
287 :     xvid_plugin_2pass2_t * param = (xvid_plugin_2pass2_t *)create->param;
288 :     rc_2pass2_t * rc;
289 :     int i;
290 :    
291 :     rc = malloc(sizeof(rc_2pass2_t));
292 :     if (rc == NULL)
293 :     return XVID_ERR_MEMORY;
294 :    
295 : suxen_drol 1471 /* v1.0.x */
296 :     rc->param.version = param->version;
297 :     rc->param.bitrate = param->bitrate;
298 :     rc->param.filename = param->filename;
299 :     rc->param.keyframe_boost = param->keyframe_boost;
300 :     rc->param.curve_compression_high = param->curve_compression_high;
301 :     rc->param.curve_compression_low = param->curve_compression_low;
302 :     rc->param.overflow_control_strength = param->overflow_control_strength;
303 :     rc->param.max_overflow_improvement = param->max_overflow_improvement;
304 :     rc->param.max_overflow_degradation = param->max_overflow_degradation;
305 :     rc->param.kfreduction = param->kfreduction;
306 :     rc->param.kfthreshold = param->kfthreshold;
307 :     rc->param.container_frame_overhead = param->container_frame_overhead;
308 : edgomez 1382
309 : suxen_drol 1471 if (XVID_VERSION_MINOR(param->version) >= 1) {
310 :     rc->param.vbv_size = param->vbv_size;
311 :     rc->param.vbv_initial = param->vbv_initial;
312 :     rc->param.vbv_maxrate = param->vbv_maxrate;
313 :     rc->param.vbv_peakrate = param->vbv_peakrate;
314 :     }else{
315 : edgomez 1473 rc->param.vbv_size =
316 :     rc->param.vbv_initial =
317 :     rc->param.vbv_maxrate =
318 : suxen_drol 1471 rc->param.vbv_peakrate = 0;
319 :     }
320 :    
321 : edgomez 1382 /* Initialize all defaults */
322 :     #define _INIT(a, b) if((a) <= 0) (a) = (b)
323 :     /* Let's set our defaults if needed */
324 :     _INIT(rc->param.keyframe_boost, DEFAULT_KEYFRAME_BOOST);
325 :     _INIT(rc->param.overflow_control_strength, DEFAULT_OVERFLOW_CONTROL_STRENGTH);
326 :     _INIT(rc->param.curve_compression_high, DEFAULT_CURVE_COMPRESSION_HIGH);
327 :     _INIT(rc->param.curve_compression_low, DEFAULT_CURVE_COMPRESSION_LOW);
328 :     _INIT(rc->param.max_overflow_improvement, DEFAULT_MAX_OVERFLOW_IMPROVEMENT);
329 :     _INIT(rc->param.max_overflow_degradation, DEFAULT_MAX_OVERFLOW_DEGRADATION);
330 :    
331 :     /* Keyframe settings */
332 :     _INIT(rc->param.kfreduction, DEFAULT_KFREDUCTION);
333 :     _INIT(rc->param.kfthreshold, DEFAULT_KFTHRESHOLD);
334 :     #undef _INIT
335 :    
336 :     /* Initialize some stuff to zero */
337 :     for(i=0; i<3; i++) {
338 :     int j;
339 :     for (j=0; j<32; j++) {
340 :     rc->quant_error[i][j] = 0;
341 :     rc->quant_count[i][j] = 0;
342 :     }
343 :     }
344 :    
345 :     for (i=0; i<3; i++) rc->last_quant[i] = 0;
346 :    
347 :     rc->fq_error = 0;
348 :     rc->min_quant = 1;
349 : Isibaar 1883 rc->scaled_frames = 0;
350 : edgomez 1382
351 :     /* Count frames (and intra frames) in the stats file, store the result into
352 :     * the rc structure */
353 :     if (statsfile_count_frames(rc, param->filename) == -1) {
354 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
355 :     free(rc);
356 :     return(XVID_ERR_FAIL);
357 :     }
358 :    
359 :     /* Allocate the stats' memory */
360 :     if ((rc->stats = malloc(rc->num_frames * sizeof(twopass_stat_t))) == NULL) {
361 :     free(rc);
362 :     return(XVID_ERR_MEMORY);
363 :     }
364 :    
365 :     /* Allocate keyframes location's memory
366 :     * PS: see comment in pre_process0 for the +1 location requirement */
367 :     rc->keyframe_locations = malloc((rc->num_keyframes + 1) * sizeof(int));
368 :     if (rc->keyframe_locations == NULL) {
369 :     free(rc->stats);
370 :     free(rc);
371 :     return(XVID_ERR_MEMORY);
372 :     }
373 :    
374 :     /* Load the first pass stats */
375 :     if (statsfile_load(rc, param->filename) == -1) {
376 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
377 :     free(rc->keyframe_locations);
378 :     free(rc->stats);
379 :     free(rc);
380 :     return XVID_ERR_FAIL;
381 :     }
382 :    
383 :     /* Compute the target filesize */
384 :     if (rc->param.bitrate<0) {
385 :     /* if negative, bitrate equals the target (in kbytes) */
386 :     rc->target = ((uint64_t)(-rc->param.bitrate)) * 1024;
387 :     } else if (rc->num_frames < create->fbase/create->fincr) {
388 :     /* Source sequence is less than 1s long, we do as if it was 1s long */
389 :     rc->target = rc->param.bitrate / 8;
390 :     } else {
391 :     /* Target filesize = bitrate/8 * numframes / framerate */
392 :     rc->target =
393 :     ((uint64_t)rc->param.bitrate * (uint64_t)rc->num_frames * \
394 :     (uint64_t)create->fincr) / \
395 :     ((uint64_t)create->fbase * 8);
396 :     }
397 :    
398 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Frame rate: %d/%d (%ffps)\n",
399 :     create->fbase, create->fincr,
400 :     (double)create->fbase/(double)create->fincr);
401 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Number of frames: %d\n", rc->num_frames);
402 :     if(rc->param.bitrate>=0)
403 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target bitrate: %ld\n", rc->param.bitrate);
404 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target filesize: %lld\n", rc->target);
405 :    
406 :     /* Compensate the average frame overhead caused by the container */
407 :     rc->target -= rc->num_frames*rc->param.container_frame_overhead;
408 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Container Frame overhead: %d\n", rc->param.container_frame_overhead);
409 :     if(rc->param.container_frame_overhead)
410 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- New target filesize after container compensation: %lld\n", rc->target);
411 :    
412 :     /* When bitrate is not given it means it has been scaled by an external
413 :     * application */
414 :     if (rc->param.bitrate) {
415 :     /* Apply zone settings
416 :     * - set rc->tot_quant which represents the total num of bytes spent in
417 :     * fixed quant zones
418 :     * - set rc->tot_weighted which represents the total amount of bytes
419 :     * spent in normal or weighted zones in first pass (normal zones can
420 :     * be considered weight=1)
421 :     * - set rc->tot_quant_invariant which represents the total num of bytes
422 :     * spent in fixed quant zones for headers */
423 :     zone_process(rc, create);
424 :     } else {
425 :     /* External scaling -- zones are ignored */
426 :     for (i=0;i<rc->num_frames;i++) {
427 :     rc->stats[i].zone_mode = XVID_ZONE_WEIGHT;
428 :     rc->stats[i].weight = 1.0;
429 :     }
430 :     rc->tot_quant = 0;
431 :     }
432 :    
433 :     /* Gathers some information about first pass stats:
434 :     * - finds the minimum frame length for each frame type during 1st pass.
435 :     * rc->min_size[]
436 :     * - determines the maximum frame length observed (no frame type distinction).
437 :     * rc->max_size
438 :     * - count how many times each frame type has been used.
439 :     * rc->count[]
440 :     * - total bytes used per frame type
441 :     * rc->tot_length[]
442 :     * - total bytes considered invariant between the 2 passes
443 :     * - store keyframe location
444 :     * rc->keyframe_locations[]
445 :     */
446 :     first_pass_stats_prepare_data(rc);
447 :    
448 :     /* If we have a user bitrate, it means it's an internal curve scaling */
449 :     if (rc->param.bitrate) {
450 :     /* Perform internal curve scaling */
451 :     first_pass_scale_curve_internal(rc);
452 :     }
453 :    
454 :     /* Apply advanced curve options, and compute some parameters in order to
455 :     * shape the curve in the BEFORE/AFTER pair of functions */
456 :     scaled_curve_apply_advanced_parameters(rc);
457 :    
458 : edgomez 1473 /* Check curve for VBV compliancy and rescale if necessary */
459 : chl 1470 #ifdef VBV_FORCE
460 : edgomez 1473 if (rc->param.vbv_size==0) {
461 :     rc->param.vbv_size = 3145728;
462 :     rc->param.vbv_initial = 2359296;
463 : suxen_drol 1607 rc->param.vbv_maxrate = 4854000;
464 :     rc->param.vbv_peakrate = 8000000;
465 : edgomez 1473 }
466 : chl 1470 #endif
467 :    
468 : edgomez 1473 /* vbv_size==0 switches VBV check off */
469 :     if (rc->param.vbv_size > 0) {
470 : Isibaar 1928 const float fps = (float) ((double)create->fbase/(double)create->fincr);
471 : edgomez 1473 int status = check_curve_for_vbv_compliancy(rc, fps);
472 : chl 1470
473 : edgomez 1473 if (status) {
474 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] Underflow detected - Scaling Curve for compliancy.\n");
475 :     }
476 : chl 1470
477 : edgomez 1473 status = scale_curve_for_vbv_compliancy(rc, fps);
478 :    
479 :     if (status == 0) {
480 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] VBV compliant curve scaling done.\n");
481 :     } else {
482 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] VBV compliant curve scaling impossible.\n");
483 :     }
484 :     }
485 : edgomez 1382 *handle = rc;
486 :     return(0);
487 :     }
488 :    
489 :     /*----------------------------------------------------------------------------
490 :     *--------------------------------------------------------------------------*/
491 :    
492 :     static int
493 :     rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy)
494 :     {
495 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- target_total:%lld desired_total:%.2f (%.2f%%) actual_total:%.2f (%.2f%%)\n",
496 :     rc->target,
497 :     rc->desired_total,
498 :     100*rc->desired_total/(double)rc->target,
499 :     rc->real_total,
500 :     100*rc->real_total/(double)rc->target);
501 :    
502 :     free(rc->keyframe_locations);
503 :     free(rc->stats);
504 :     free(rc);
505 :     return(0);
506 :     }
507 :    
508 :     /*----------------------------------------------------------------------------
509 :     *--------------------------------------------------------------------------*/
510 :    
511 :     static int
512 :     rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data)
513 :     {
514 :     twopass_stat_t * s = &rc->stats[data->frame_num];
515 :     double dbytes;
516 :     double scaled_quant;
517 :     double overflow;
518 :     int capped_to_max_framesize = 0;
519 :    
520 :     /* This function is quite long but easy to understand. In order to simplify
521 :     * the code path (a bit), we treat 3 cases that can return immediatly. */
522 :    
523 :     /* First case: Another plugin has already set a quantizer */
524 :     if (data->quant > 0)
525 :     return(0);
526 :    
527 :     /* Second case: insufficent stats data
528 :     * We can't guess much what we should do, let core decide all alone */
529 :     if (data->frame_num >= rc->num_frames) {
530 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- stats file too short (now processing frame %d)",
531 :     data->frame_num);
532 :     return(0);
533 :     }
534 :    
535 :     /* Third case: We are in a Quant zone
536 :     * Quant zones must just ensure we use the same settings as first pass
537 :     * So set the quantizer and the type */
538 :     if (s->zone_mode == XVID_ZONE_QUANT) {
539 :     /* Quant stuff */
540 :     rc->fq_error += s->weight;
541 :     data->quant = (int)rc->fq_error;
542 :     rc->fq_error -= data->quant;
543 :    
544 :     /* The type stuff */
545 :     data->type = s->type;
546 :    
547 :     /* The only required data for AFTER step is this one for the overflow
548 :     * control */
549 :     s->desired_length = s->length;
550 :    
551 :     return(0);
552 :     }
553 :    
554 :    
555 :     /*************************************************************************/
556 :     /*************************************************************************/
557 :     /*************************************************************************/
558 :    
559 :     /*-------------------------------------------------------------------------
560 :     * Frame bit allocation first part
561 :     *
562 :     * First steps apply user settings, just like it is done in the theoritical
563 :     * scaled_curve_apply_advanced_parameters
564 :     *-----------------------------------------------------------------------*/
565 :    
566 :     /* Set desired to what we are wanting to obtain for this frame */
567 :     dbytes = (double)s->scaled_length;
568 :    
569 :     /* IFrame user settings*/
570 :     if (s->type == XVID_TYPE_IVOP) {
571 :     /* Keyframe boosting -- All keyframes benefit from it */
572 :     dbytes += dbytes*rc->param.keyframe_boost / 100;
573 :    
574 :     #if 0 /* ToDo: decide how to apply kfthresholding */
575 :     #endif
576 :     } else {
577 :    
578 :     /* P/S/B frames must reserve some bits for iframe boosting */
579 :     dbytes *= rc->pb_iboost_tax_ratio;
580 :    
581 :     /* Apply assymetric curve compression */
582 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
583 :     double assymetric_delta;
584 :    
585 :     /* Compute the assymetric delta, this is computed before applying
586 :     * the tax, as done in the pre_process function */
587 :     if (dbytes > rc->avg_length[s->type-1])
588 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_high / 100.0;
589 :     else
590 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_low / 100.0;
591 :    
592 :     /* Now we must apply the assymetric tax, else our curve compression
593 :     * would not give a theoritical target size equal to what it is
594 :     * expected */
595 :     dbytes *= rc->assymetric_tax_ratio;
596 :    
597 :     /* Now we can add the assymetric delta */
598 :     dbytes += assymetric_delta;
599 :     }
600 :     }
601 :    
602 :     /* That is what we would like to have -- Don't put that chunk after
603 :     * overflow control, otherwise, overflow is counted twice and you obtain
604 :     * half sized bitrate sequences */
605 :     s->desired_length = (int)dbytes;
606 :     rc->desired_total += dbytes;
607 :    
608 :     /*------------------------------------------------------------------------
609 :     * Frame bit allocation: overflow control part.
610 :     *
611 :     * Unlike the theoritical scaled_curve_apply_advanced_parameters, here
612 :     * it's real encoding and we need to make sure we don't go so far from
613 :     * what is our ideal scaled curve.
614 :     *-----------------------------------------------------------------------*/
615 :    
616 :     /* Compute the overflow we should compensate */
617 :     if (s->type != XVID_TYPE_IVOP || rc->overflow > 0) {
618 :     double frametype_factor;
619 :     double framesize_factor;
620 :    
621 :     /* Take only the desired part of overflow */
622 :     overflow = rc->overflow;
623 :    
624 :     /* Factor that will take care to decrease the overflow applied
625 :     * according to the importance of this frame type in term of
626 :     * overall size */
627 :     frametype_factor = rc->count[XVID_TYPE_IVOP-1]*rc->avg_length[XVID_TYPE_IVOP-1];
628 :     frametype_factor += rc->count[XVID_TYPE_PVOP-1]*rc->avg_length[XVID_TYPE_PVOP-1];
629 :     frametype_factor += rc->count[XVID_TYPE_BVOP-1]*rc->avg_length[XVID_TYPE_BVOP-1];
630 :     frametype_factor /= rc->count[s->type-1]*rc->avg_length[s->type-1];
631 :     frametype_factor = 1/frametype_factor;
632 :    
633 :     /* Factor that will take care not to compensate too much for this frame
634 :     * size */
635 :     framesize_factor = dbytes;
636 :     framesize_factor /= rc->avg_length[s->type-1];
637 :    
638 :     /* Treat only the overflow part concerned by this frame type and size */
639 :     overflow *= frametype_factor;
640 :     #if 0
641 :     /* Leave this one alone, as it impacts badly on quality */
642 :     overflow *= framesize_factor;
643 :     #endif
644 :    
645 :     /* Apply the overflow strength imposed by the user */
646 :     overflow *= (rc->param.overflow_control_strength/100.0f);
647 :     } else {
648 :     /* no negative overflow applied in IFrames because:
649 :     * - their role is important as they're references for P/BFrames.
650 :     * - there aren't much in typical sequences, so if an IFrame overflows too
651 :     * much, this overflow may impact the next IFrame too much and generate
652 :     * a sequence of poor quality frames */
653 :     overflow = 0;
654 :     }
655 :    
656 :     /* Make sure we are not trying to compensate more overflow than we even have */
657 :     if (fabs(overflow) > fabs(rc->overflow))
658 :     overflow = rc->overflow;
659 :    
660 :     /* Make sure the overflow doesn't make the frame size to get out of the range
661 :     * [-max_degradation..+max_improvment] */
662 :     if (overflow > dbytes*rc->param.max_overflow_improvement / 100) {
663 :     if(overflow <= dbytes)
664 :     dbytes += dbytes * rc->param.max_overflow_improvement / 100;
665 :     else
666 :     dbytes += overflow * rc->param.max_overflow_improvement / 100;
667 :     } else if (overflow < - dbytes * rc->param.max_overflow_degradation / 100) {
668 :     dbytes -= dbytes * rc->param.max_overflow_degradation / 100;
669 :     } else {
670 :     dbytes += overflow;
671 :     }
672 :    
673 :     /*-------------------------------------------------------------------------
674 :     * Frame bit allocation last part:
675 :     *
676 :     * Cap frame length so we don't reach neither bigger frame sizes than first
677 :     * pass nor smaller than the allowed minimum.
678 :     *-----------------------------------------------------------------------*/
679 :    
680 :     #ifdef PASS_SMALLER
681 :     if (dbytes > s->length) {
682 :     dbytes = s->length;
683 :     }
684 :     #endif
685 :    
686 :     /* Prevent stupid desired sizes under logical values */
687 :     if (dbytes < rc->min_length[s->type-1]) {
688 :     dbytes = rc->min_length[s->type-1];
689 :     }
690 :    
691 :     /*------------------------------------------------------------------------
692 :     * Desired frame length <-> quantizer mapping
693 :     *-----------------------------------------------------------------------*/
694 :    
695 :     #ifdef BQUANT_PRESCALE
696 :     /* For bframes we prescale the quantizer to avoid too high quant scaling */
697 :     if(s->type == XVID_TYPE_BVOP) {
698 :    
699 :     twopass_stat_t *b_ref = s;
700 :    
701 :     /* Find the reference frame */
702 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
703 :     b_ref--;
704 :    
705 :     /* Compute the original quant */
706 :     s->quant = 2*(100*s->quant - data->bquant_offset);
707 :     s->quant += data->bquant_ratio - 1; /* to avoid rounding issues */
708 :     s->quant = s->quant/data->bquant_ratio - b_ref->quant;
709 :     }
710 :     #endif
711 :    
712 :     /* Don't laugh at this very 'simple' quant<->size relationship, it
713 :     * proves to be acurate enough for our algorithm */
714 :     scaled_quant = (double)s->quant*(double)s->length/(double)dbytes;
715 :    
716 :     #ifdef COMPENSATE_FORMULA
717 :     /* We know xvidcore will apply the bframe formula again, so we compensate
718 :     * it right now to make sure we would not apply it twice */
719 :     if(s->type == XVID_TYPE_BVOP) {
720 :    
721 :     twopass_stat_t *b_ref = s;
722 :    
723 :     /* Find the reference frame */
724 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
725 :     b_ref--;
726 :    
727 :     /* Compute the quant it would be if the core did not apply the bframe
728 :     * formula */
729 :     scaled_quant = 100*scaled_quant - data->bquant_offset;
730 :     scaled_quant += data->bquant_ratio - 1; /* to avoid rouding issues */
731 :     scaled_quant /= data->bquant_ratio;
732 :     }
733 :     #endif
734 :    
735 :     /* Quantizer has been scaled using floating point operations/results, we
736 :     * must cast it to integer */
737 :     data->quant = (int)scaled_quant;
738 :    
739 :     /* Let's clip the computed quantizer, if needed */
740 :     if (data->quant < 1) {
741 :     data->quant = 1;
742 :     } else if (data->quant > 31) {
743 :     data->quant = 31;
744 :     } else {
745 :    
746 :     /* The frame quantizer has not been clipped, this appears to be a good
747 :     * computed quantizer, do not loose quantizer decimal part that we
748 :     * accumulate for later reuse when its sum represents a complete
749 :     * unit. */
750 :     rc->quant_error[s->type-1][data->quant] += scaled_quant - (double)data->quant;
751 :    
752 :     if (rc->quant_error[s->type-1][data->quant] >= 1.0) {
753 :     rc->quant_error[s->type-1][data->quant] -= 1.0;
754 :     data->quant++;
755 :     } else if (rc->quant_error[s->type-1][data->quant] <= -1.0) {
756 :     rc->quant_error[s->type-1][data->quant] += 1.0;
757 :     data->quant--;
758 :     }
759 :     }
760 :    
761 :     /* Now we have a computed quant that is in the right quante range, with a
762 :     * possible +1 correction due to cumulated error. We can now safely clip
763 :     * the quantizer again with user's quant ranges. "Safely" means the Rate
764 :     * Control could learn more about this quantizer, this knowledge is useful
765 :     * for future frames even if it this quantizer won't be really used atm,
766 :     * that's why we don't perform this clipping earlier. */
767 :     if (data->quant < data->min_quant[s->type-1]) {
768 :     data->quant = data->min_quant[s->type-1];
769 :     } else if (data->quant > data->max_quant[s->type-1]) {
770 :     data->quant = data->max_quant[s->type-1];
771 :     }
772 :    
773 :     if (data->quant < rc->min_quant) data->quant = rc->min_quant;
774 :    
775 :     /* To avoid big quality jumps from frame to frame, we apply a "security"
776 :     * rule that makes |last_quant - new_quant| <= 2. This rule only applies
777 :     * to predicted frames (P and B) */
778 :     if (s->type != XVID_TYPE_IVOP && rc->last_quant[s->type-1] && capped_to_max_framesize == 0) {
779 :    
780 :     if (data->quant > rc->last_quant[s->type-1] + 2) {
781 :     data->quant = rc->last_quant[s->type-1] + 2;
782 :     DPRINTF(XVID_DEBUG_RC,
783 :     "[xvid rc] -- frame %d p/b-frame quantizer prevented from rising too steeply\n",
784 :     data->frame_num);
785 :     }
786 :     if (data->quant < rc->last_quant[s->type-1] - 2) {
787 :     data->quant = rc->last_quant[s->type-1] - 2;
788 :     DPRINTF(XVID_DEBUG_RC,
789 :     "[xvid rc] -- frame:%d p/b-frame quantizer prevented from falling too steeply\n",
790 :     data->frame_num);
791 :     }
792 :     }
793 :    
794 :     /* We don't want to pollute the RC histerisis when our computed quant has
795 :     * been computed from a capped frame size */
796 :     if (capped_to_max_framesize == 0)
797 :     rc->last_quant[s->type-1] = data->quant;
798 :    
799 :     /* Don't forget to force 1st pass frame type ;-) */
800 : Isibaar 1883 if (rc->scaled_frames)
801 :     data->type = s->type;
802 : edgomez 1382
803 : Isibaar 1883 rc->scaled_frames++;
804 : edgomez 1382 return 0;
805 :     }
806 :    
807 :     /*----------------------------------------------------------------------------
808 :     *--------------------------------------------------------------------------*/
809 :    
810 :     static int
811 :     rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data)
812 :     {
813 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
814 :     twopass_stat_t * s = &rc->stats[data->frame_num];
815 :    
816 :     /* Insufficent stats data */
817 :     if (data->frame_num >= rc->num_frames)
818 :     return 0;
819 :    
820 :     /* Update the quantizer counter */
821 :     rc->quant_count[s->type-1][data->quant]++;
822 :    
823 :     /* Update the frame type overflow */
824 :     if (data->type == XVID_TYPE_IVOP) {
825 :     int kfdiff = 0;
826 :    
827 :     if(rc->KF_idx != rc->num_frames -1) {
828 :     kfdiff = rc->keyframe_locations[rc->KF_idx+1];
829 :     kfdiff -= rc->keyframe_locations[rc->KF_idx];
830 :     }
831 :    
832 :     /* Flush Keyframe overflow accumulator */
833 :     rc->overflow += rc->KFoverflow;
834 :    
835 :     /* Store the frame overflow to the keyframe accumulator */
836 :     rc->KFoverflow = s->desired_length - data->length;
837 :    
838 :     if (kfdiff > 1) {
839 :     /* Non-consecutive keyframes case:
840 :     * We can then divide this total keyframe overflow into equal parts
841 :     * that we will distribute into regular overflow at each frame
842 :     * between the sequence bounded by two IFrames */
843 :     rc->KFoverflow_partial = rc->KFoverflow / (kfdiff - 1);
844 :     } else {
845 :     /* Consecutive keyframes case:
846 :     * Flush immediatly the keyframe overflow and reset keyframe
847 :     * overflow */
848 :     rc->overflow += rc->KFoverflow;
849 :     rc->KFoverflow = 0;
850 :     rc->KFoverflow_partial = 0;
851 :     }
852 :     rc->KF_idx++;
853 :     } else {
854 :     /* Accumulate the frame overflow */
855 :     rc->overflow += s->desired_length - data->length;
856 :    
857 :     /* Distribute part of the keyframe overflow */
858 :     rc->overflow += rc->KFoverflow_partial;
859 :    
860 :     /* Don't forget to substract that same amount from the total keyframe
861 :     * overflow */
862 :     rc->KFoverflow -= rc->KFoverflow_partial;
863 :     }
864 :    
865 : edgomez 1589 s->error = s->desired_length - data->length;
866 : edgomez 1382 rc->real_total += data->length;
867 :    
868 :     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",
869 :     data->frame_num,
870 :     frame_type[data->type-1],
871 :     data->quant,
872 :     s->length,
873 :     s->scaled_length,
874 :     s->desired_length,
875 :     s->desired_length - s->error,
876 :     -s->error,
877 :     rc->overflow);
878 :    
879 :     return(0);
880 :     }
881 :    
882 :     /*****************************************************************************
883 :     * Helper functions definition
884 :     ****************************************************************************/
885 :    
886 :     /* Default buffer size for reading lines */
887 :     #define BUF_SZ 1024
888 :    
889 :     /* Helper functions for reading/parsing the stats file */
890 :     static char *skipspaces(char *string);
891 :     static int iscomment(char *string);
892 :     static char *readline(FILE *f);
893 :    
894 :     /* This function counts the number of frame entries in the stats file
895 :     * It also counts the number of I Frames */
896 :     static int
897 :     statsfile_count_frames(rc_2pass2_t * rc, char * filename)
898 :     {
899 :     FILE * f;
900 :     char *line;
901 :     int lines;
902 :    
903 :     rc->num_frames = 0;
904 :     rc->num_keyframes = 0;
905 :    
906 :     if ((f = fopen(filename, "rb")) == NULL)
907 :     return(-1);
908 :    
909 :     lines = 0;
910 :     while ((line = readline(f)) != NULL) {
911 :    
912 :     char *ptr;
913 :     char type;
914 :     int fields;
915 :    
916 :     lines++;
917 :    
918 :     /* We skip spaces */
919 :     ptr = skipspaces(line);
920 :    
921 :     /* Skip coment lines or empty lines */
922 :     if(iscomment(ptr) || *ptr == '\0') {
923 :     free(line);
924 :     continue;
925 :     }
926 :    
927 :     /* Read the stat line from buffer */
928 :     fields = sscanf(ptr, "%c", &type);
929 :    
930 :     /* Valid stats files have at least 7 fields */
931 :     if (fields == 1) {
932 :     switch(type) {
933 :     case 'i':
934 :     case 'I':
935 :     rc->num_keyframes++;
936 :     case 'p':
937 :     case 'P':
938 :     case 'b':
939 :     case 'B':
940 :     case 's':
941 :     case 'S':
942 :     rc->num_frames++;
943 :     break;
944 :     default:
945 :     DPRINTF(XVID_DEBUG_RC,
946 :     "[xvid rc] -- WARNING: L%d unknown frame type used (%c).\n",
947 :     lines, type);
948 :     }
949 :     } else {
950 :     DPRINTF(XVID_DEBUG_RC,
951 :     "[xvid rc] -- WARNING: L%d misses some stat fields (%d).\n",
952 :     lines, 7-fields);
953 :     }
954 :    
955 :     /* Free the line buffer */
956 :     free(line);
957 :     }
958 :    
959 :     /* We are done with the file */
960 :     fclose(f);
961 :    
962 : Isibaar 1876 if (!rc->num_keyframes) return (-1); /* No keyframes? Then something is wrong */
963 :     else return(0);
964 : edgomez 1382 }
965 :    
966 :     /* open stats file(s) and read into rc->stats array */
967 :     static int
968 :     statsfile_load(rc_2pass2_t *rc, char * filename)
969 :     {
970 :     FILE * f;
971 :     int processed_entries;
972 :    
973 :     /* Opens the file */
974 :     if ((f = fopen(filename, "rb"))==NULL)
975 :     return(-1);
976 :    
977 :     processed_entries = 0;
978 :     while(processed_entries < rc->num_frames) {
979 :     char type;
980 :     int fields;
981 :     twopass_stat_t * s = &rc->stats[processed_entries];
982 :     char *line, *ptr;
983 :    
984 :     /* Read the line from the file */
985 :     if((line = readline(f)) == NULL)
986 :     break;
987 :    
988 :     /* We skip spaces */
989 :     ptr = skipspaces(line);
990 :    
991 :     /* Skip comment lines or empty lines */
992 :     if(iscomment(ptr) || *ptr == '\0') {
993 :     free(line);
994 :     continue;
995 :     }
996 :    
997 :     /* Reset this field that is optional */
998 :     s->scaled_length = 0;
999 :    
1000 :     /* Convert the fields */
1001 :     fields = sscanf(ptr,
1002 :     "%c %d %d %d %d %d %d %d\n",
1003 :     &type,
1004 :     &s->quant,
1005 :     &s->blks[0], &s->blks[1], &s->blks[2],
1006 :     &s->length, &s->invariant /* not really yet */,
1007 :     &s->scaled_length);
1008 :    
1009 :     /* Free line buffer, we don't need it anymore */
1010 :     free(line);
1011 :    
1012 :     /* Fail silently, this has probably been warned in
1013 :     * statsfile_count_frames */
1014 :     if(fields != 7 && fields != 8)
1015 :     continue;
1016 :    
1017 :     /* Convert frame type and compute the invariant length part */
1018 :     switch(type) {
1019 :     case 'i':
1020 :     case 'I':
1021 :     s->type = XVID_TYPE_IVOP;
1022 :     s->invariant /= INVARIANT_HEADER_PART_IVOP;
1023 :     break;
1024 :     case 'p':
1025 :     case 'P':
1026 :     case 's':
1027 :     case 'S':
1028 :     s->type = XVID_TYPE_PVOP;
1029 :     s->invariant /= INVARIANT_HEADER_PART_PVOP;
1030 :     break;
1031 :     case 'b':
1032 :     case 'B':
1033 :     s->type = XVID_TYPE_BVOP;
1034 :     s->invariant /= INVARIANT_HEADER_PART_BVOP;
1035 :     break;
1036 :     default:
1037 :     /* Same as before, fail silently */
1038 :     continue;
1039 :     }
1040 :    
1041 :     /* Ok it seems it's been processed correctly */
1042 :     processed_entries++;
1043 :     }
1044 :    
1045 :     /* Close the file */
1046 :     fclose(f);
1047 :    
1048 :     return(0);
1049 :     }
1050 :    
1051 :     /* pre-process the statistics data
1052 :     * - for each type, count, tot_length, min_length, max_length
1053 :     * - set keyframes_locations, tot_prescaled */
1054 :     static void
1055 :     first_pass_stats_prepare_data(rc_2pass2_t * rc)
1056 :     {
1057 :     int i,j;
1058 :    
1059 :     /* *rc fields initialization
1060 :     * NB: INT_MAX and INT_MIN are used in order to be immediately replaced
1061 :     * with real values of the 1pass */
1062 :     for (i=0; i<3; i++) {
1063 :     rc->count[i]=0;
1064 :     rc->tot_length[i] = 0;
1065 :     rc->tot_invariant[i] = 0;
1066 :     rc->min_length[i] = INT_MAX;
1067 :     }
1068 :    
1069 :     rc->max_length = INT_MIN;
1070 :     rc->tot_weighted = 0;
1071 :    
1072 :     /* Loop through all frames and find/compute all the stuff this function
1073 :     * is supposed to do */
1074 :     for (i=j=0; i<rc->num_frames; i++) {
1075 :     twopass_stat_t * s = &rc->stats[i];
1076 :    
1077 :     rc->count[s->type-1]++;
1078 :     rc->tot_length[s->type-1] += s->length;
1079 :     rc->tot_invariant[s->type-1] += s->invariant;
1080 :     if (s->zone_mode != XVID_ZONE_QUANT)
1081 :     rc->tot_weighted += (int)(s->weight*(s->length - s->invariant));
1082 :    
1083 :     if (s->length < rc->min_length[s->type-1]) {
1084 :     rc->min_length[s->type-1] = s->length;
1085 :     }
1086 :    
1087 :     if (s->length > rc->max_length) {
1088 :     rc->max_length = s->length;
1089 :     }
1090 :    
1091 :     if (s->type == XVID_TYPE_IVOP) {
1092 :     rc->keyframe_locations[j] = i;
1093 :     j++;
1094 :     }
1095 :     }
1096 :    
1097 :     /* NB:
1098 :     * The "per sequence" overflow system considers a natural sequence to be
1099 :     * formed by all frames between two iframes, so if we want to make sure
1100 :     * the system does not go nuts during last sequence, we force the last
1101 :     * frame to appear in the keyframe locations array. */
1102 :     rc->keyframe_locations[j] = i;
1103 :    
1104 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass IFrame length: %d\n", rc->min_length[0]);
1105 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass PFrame length: %d\n", rc->min_length[1]);
1106 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass BFrame length: %d\n", rc->min_length[2]);
1107 :     }
1108 :    
1109 :     /* calculate zone weight "center" */
1110 :     static void
1111 :     zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create)
1112 :     {
1113 :     int i,j;
1114 :     int n = 0;
1115 :    
1116 :     rc->tot_quant = 0;
1117 :     rc->tot_quant_invariant = 0;
1118 :    
1119 :     if (create->num_zones == 0) {
1120 :     for (j = 0; j < rc->num_frames; j++) {
1121 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1122 :     rc->stats[j].weight = 1.0;
1123 :     }
1124 :     n += rc->num_frames;
1125 :     }
1126 :    
1127 :    
1128 :     for(i=0; i < create->num_zones; i++) {
1129 :    
1130 :     int next = (i+1<create->num_zones) ? create->zones[i+1].frame : rc->num_frames;
1131 :    
1132 :     /* Zero weight make no sense */
1133 :     if (create->zones[i].increment == 0) create->zones[i].increment = 1;
1134 :     /* And obviously an undetermined infinite makes even less sense */
1135 :     if (create->zones[i].base == 0) create->zones[i].base = 1;
1136 :    
1137 :     if (i==0 && create->zones[i].frame > 0) {
1138 :     for (j = 0; j < create->zones[i].frame && j < rc->num_frames; j++) {
1139 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1140 :     rc->stats[j].weight = 1.0;
1141 :     }
1142 :     n += create->zones[i].frame;
1143 :     }
1144 :    
1145 :     if (create->zones[i].mode == XVID_ZONE_WEIGHT) {
1146 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1147 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1148 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1149 :     }
1150 :     next -= create->zones[i].frame;
1151 :     n += next;
1152 :     } else{ /* XVID_ZONE_QUANT */
1153 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1154 :     rc->stats[j].zone_mode = XVID_ZONE_QUANT;
1155 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1156 :     rc->tot_quant += rc->stats[j].length;
1157 :     rc->tot_quant_invariant += rc->stats[j].invariant;
1158 :     }
1159 :     }
1160 :     }
1161 :     }
1162 :    
1163 :    
1164 :     /* scale the curve */
1165 :     static void
1166 :     first_pass_scale_curve_internal(rc_2pass2_t *rc)
1167 :     {
1168 :     int64_t target;
1169 :     int64_t total_invariant;
1170 :     double scaler;
1171 :     int i, num_MBs;
1172 :    
1173 :     /* We only scale texture data ! */
1174 :     total_invariant = rc->tot_invariant[XVID_TYPE_IVOP-1];
1175 :     total_invariant += rc->tot_invariant[XVID_TYPE_PVOP-1];
1176 :     total_invariant += rc->tot_invariant[XVID_TYPE_BVOP-1];
1177 :     /* don't forget to substract header bytes used in quant zones, otherwise we
1178 :     * counting them twice */
1179 :     total_invariant -= rc->tot_quant_invariant;
1180 :    
1181 :     /* We remove the bytes used by the fixed quantizer zones during first pass
1182 :     * with the same quants, so we know very precisely how much that
1183 :     * represents */
1184 :     target = rc->target;
1185 :     target -= rc->tot_quant;
1186 :    
1187 :     /* Let's compute a linear scaler in order to perform curve scaling */
1188 :     scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1189 :    
1190 :     #ifdef SMART_OVERFLOW_SETTING
1191 :     if (scaler > 0.9) {
1192 :     rc->param.max_overflow_degradation *= 5;
1193 :     rc->param.max_overflow_improvement *= 5;
1194 :     rc->param.overflow_control_strength *= 3;
1195 :     } else if (scaler > 0.6) {
1196 :     rc->param.max_overflow_degradation *= 2;
1197 :     rc->param.max_overflow_improvement *= 2;
1198 :     rc->param.overflow_control_strength *= 2;
1199 :     } else {
1200 :     rc->min_quant = 2;
1201 :     }
1202 :     #endif
1203 :    
1204 :     /* Compute min frame lengths (for each frame type) according to the number
1205 :     * of MBs. We sum all block type counters of frame 0, this gives us the
1206 :     * number of MBs.
1207 :     *
1208 :     * We compare these hardcoded values with observed values in first pass
1209 :     * (determined in pre_process0).Then we keep the real minimum. */
1210 :    
1211 :     /* Number of MBs */
1212 :     num_MBs = rc->stats[0].blks[0];
1213 :     num_MBs += rc->stats[0].blks[1];
1214 :     num_MBs += rc->stats[0].blks[2];
1215 :    
1216 :     /* Minimum for I frames */
1217 :     if(rc->min_length[XVID_TYPE_IVOP-1] > ((num_MBs*22) + 240) / 8)
1218 :     rc->min_length[XVID_TYPE_IVOP-1] = ((num_MBs*22) + 240) / 8;
1219 :    
1220 :     /* Minimum for P/S frames */
1221 :     if(rc->min_length[XVID_TYPE_PVOP-1] > ((num_MBs) + 88) / 8)
1222 :     rc->min_length[XVID_TYPE_PVOP-1] = ((num_MBs) + 88) / 8;
1223 :    
1224 :     /* Minimum for B frames */
1225 :     if(rc->min_length[XVID_TYPE_BVOP-1] > 8)
1226 :     rc->min_length[XVID_TYPE_BVOP-1] = 8;
1227 :    
1228 :     /* Perform an initial scale pass.
1229 :     *
1230 :     * If a frame size is scaled underneath our hardcoded minimums, then we
1231 :     * force the frame size to the minimum, and deduct the original & scaled
1232 :     * frame length from the original and target total lengths */
1233 :     for (i=0; i<rc->num_frames; i++) {
1234 :     twopass_stat_t * s = &rc->stats[i];
1235 :     int len;
1236 :    
1237 :     /* No need to scale frame length for which a specific quantizer is
1238 :     * specified thanks to zones */
1239 :     if (s->zone_mode == XVID_ZONE_QUANT) {
1240 :     s->scaled_length = s->length;
1241 :     continue;
1242 :     }
1243 :    
1244 :     /* Compute the scaled length -- only non invariant data length is scaled */
1245 :     len = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1246 :    
1247 :     /* Compare with the computed minimum */
1248 :     if (len < rc->min_length[s->type-1]) {
1249 :     /* This is a 'forced size' frame, set its frame size to the
1250 :     * computed minimum */
1251 :     s->scaled_length = rc->min_length[s->type-1];
1252 :    
1253 :     /* Remove both scaled and original size from their respective
1254 :     * total counters, as we prepare a second pass for 'regular'
1255 :     * frames */
1256 :     target -= s->scaled_length;
1257 :     } else {
1258 :     /* Do nothing for now, we'll scale this later */
1259 :     s->scaled_length = 0;
1260 :     }
1261 :     }
1262 :    
1263 :     /* The first pass on data substracted all 'forced size' frames from the
1264 :     * total counters. Now, it's possible to scale the 'regular' frames. */
1265 :    
1266 :     /* Scaling factor for 'regular' frames */
1267 :     scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1268 :    
1269 :     /* Do another pass with the new scaler */
1270 :     for (i=0; i<rc->num_frames; i++) {
1271 :     twopass_stat_t * s = &rc->stats[i];
1272 :    
1273 :     /* Ignore frame with forced frame sizes */
1274 :     if (s->scaled_length == 0)
1275 :     s->scaled_length = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1276 :     }
1277 :    
1278 :     /* Job done */
1279 :     return;
1280 :     }
1281 :    
1282 :     /* Apply all user settings to the scaled curve
1283 :     * This implies:
1284 :     * keyframe boosting
1285 :     * high/low compression */
1286 :     static void
1287 :     scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc)
1288 :     {
1289 :     int i;
1290 :     int64_t ivop_boost_total;
1291 :    
1292 :     /* Reset the rate controller (per frame type) total byte counters */
1293 :     for (i=0; i<3; i++) rc->tot_scaled_length[i] = 0;
1294 :    
1295 :     /* Compute total bytes for each frame type */
1296 :     for (i=0; i<rc->num_frames;i++) {
1297 :     twopass_stat_t *s = &rc->stats[i];
1298 :     rc->tot_scaled_length[s->type-1] += s->scaled_length;
1299 :     }
1300 :    
1301 :     /* First we compute the total amount of bits needed, as being described by
1302 :     * the scaled distribution. During this pass over the complete stats data,
1303 :     * we see how much bits two user settings will get/give from/to p&b frames:
1304 :     * - keyframe boosting
1305 :     * - keyframe distance penalty */
1306 :     rc->KF_idx = 0;
1307 :     ivop_boost_total = 0;
1308 :     for (i=0; i<rc->num_frames; i++) {
1309 :     twopass_stat_t * s = &rc->stats[i];
1310 :    
1311 :     /* Some more work is needed for I frames */
1312 :     if (s->type == XVID_TYPE_IVOP) {
1313 :     int ivop_boost;
1314 :    
1315 :     /* Accumulate bytes needed for keyframe boosting */
1316 :     ivop_boost = s->scaled_length*rc->param.keyframe_boost/100;
1317 :    
1318 :     #if 0 /* ToDo: decide how to apply kfthresholding */
1319 :     #endif
1320 :     /* If the frame size drops under the minimum length, then cap ivop_boost */
1321 :     if (ivop_boost + s->scaled_length < rc->min_length[XVID_TYPE_IVOP-1])
1322 :     ivop_boost = rc->min_length[XVID_TYPE_IVOP-1] - s->scaled_length;
1323 :    
1324 :     /* Accumulate the ivop boost */
1325 :     ivop_boost_total += ivop_boost;
1326 :    
1327 :     /* Don't forget to update the keyframe index */
1328 :     rc->KF_idx++;
1329 :     }
1330 :     }
1331 :    
1332 :     /* Initialize the IBoost tax ratio for P/S/B frames
1333 :     *
1334 :     * This ratio has to be applied to p/b/s frames in order to reserve
1335 :     * additional bits for keyframes (keyframe boosting) or if too much
1336 :     * keyframe distance is applied, bits retrieved from the keyframes.
1337 :     *
1338 :     * ie pb_length *= rc->pb_iboost_tax_ratio;
1339 :     *
1340 :     * gives the ideal length of a p/b frame */
1341 :    
1342 :     /* Compute the total length of p/b/s frames (temporary storage into
1343 :     * movie_curve) */
1344 :     rc->pb_iboost_tax_ratio = (double)rc->tot_scaled_length[XVID_TYPE_PVOP-1];
1345 :     rc->pb_iboost_tax_ratio += (double)rc->tot_scaled_length[XVID_TYPE_BVOP-1];
1346 :    
1347 :     /* Compute the ratio described above
1348 :     * taxed_total = sum(0, n, tax*scaled_length)
1349 :     * <=> taxed_total = tax.sum(0, n, scaled_length)
1350 :     * <=> tax = taxed_total / original_total */
1351 :     rc->pb_iboost_tax_ratio =
1352 :     (rc->pb_iboost_tax_ratio - ivop_boost_total) /
1353 :     rc->pb_iboost_tax_ratio;
1354 :    
1355 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- IFrame boost tax ratio:%.2f\n",
1356 :     rc->pb_iboost_tax_ratio);
1357 :    
1358 :     /* Compute the average size of frames per frame type */
1359 :     for(i=0; i<3; i++) {
1360 :     /* Special case for missing type or weird case */
1361 :     if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1362 :     rc->avg_length[i] = 1;
1363 :     } else {
1364 : Isibaar 1928 rc->avg_length[i] = (double) rc->tot_scaled_length[i];
1365 : edgomez 1382
1366 :     if (i == (XVID_TYPE_IVOP-1)) {
1367 :     /* I Frames total has to be added the boost total */
1368 :     rc->avg_length[i] += ivop_boost_total;
1369 :     } else {
1370 :     /* P/B frames has to taxed */
1371 :     rc->avg_length[i] *= rc->pb_iboost_tax_ratio;
1372 :     }
1373 :    
1374 :     /* Finally compute the average frame size */
1375 :     rc->avg_length[i] /= (double)rc->count[i];
1376 :     }
1377 :     }
1378 :    
1379 :     /* Assymetric curve compression */
1380 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
1381 :     double symetric_total;
1382 :     double assymetric_delta_total;
1383 :    
1384 :     /* Like I frame boosting, assymetric curve compression modifies the total
1385 :     * amount of needed bits, we must compute the ratio so we can prescale
1386 :     lengths */
1387 :     symetric_total = 0;
1388 :     assymetric_delta_total = 0;
1389 :     for (i=0; i<rc->num_frames; i++) {
1390 :     double assymetric_delta;
1391 :     double dbytes;
1392 :     twopass_stat_t * s = &rc->stats[i];
1393 :    
1394 :     /* I Frames are not concerned by assymetric scaling */
1395 :     if (s->type == XVID_TYPE_IVOP)
1396 :     continue;
1397 :    
1398 :     /* During the real run, we would have to apply the iboost tax */
1399 :     dbytes = s->scaled_length * rc->pb_iboost_tax_ratio;
1400 :    
1401 :     /* Update the symmetric curve compression total */
1402 :     symetric_total += dbytes;
1403 :    
1404 :     /* Apply assymetric curve compression */
1405 :     if (dbytes > rc->avg_length[s->type-1])
1406 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_high / 100.0f;
1407 :     else
1408 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_low / 100.0f;
1409 :    
1410 :     /* Cap to the minimum frame size if needed */
1411 :     if (dbytes + assymetric_delta < rc->min_length[s->type-1])
1412 :     assymetric_delta = rc->min_length[s->type-1] - dbytes;
1413 :    
1414 :     /* Accumulate after assymetric curve compression */
1415 :     assymetric_delta_total += assymetric_delta;
1416 :     }
1417 :    
1418 :     /* Compute the tax that all p/b frames have to pay in order to respect the
1419 :     * bit distribution changes that the assymetric compression curve imposes
1420 :     * We want assymetric_total = sum(0, n-1, tax.scaled_length)
1421 :     * ie assymetric_total = ratio.sum(0, n-1, scaled_length)
1422 :     * ratio = assymetric_total / symmetric_total */
1423 :     rc->assymetric_tax_ratio = ((double)symetric_total - (double)assymetric_delta_total) / (double)symetric_total;
1424 :     } else {
1425 :     rc->assymetric_tax_ratio = 1.0f;
1426 :     }
1427 :    
1428 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Assymetric tax ratio:%.2f\n", rc->assymetric_tax_ratio);
1429 :    
1430 :     /* Last bits that need to be reset */
1431 :     rc->overflow = 0;
1432 :     rc->KFoverflow = 0;
1433 :     rc->KFoverflow_partial = 0;
1434 :     rc->KF_idx = 0;
1435 :     rc->desired_total = 0;
1436 :     rc->real_total = 0;
1437 :    
1438 :     /* Job done */
1439 :     return;
1440 :     }
1441 :    
1442 :     /*****************************************************************************
1443 : chl 1470 * VBV compliancy check and scale
1444 :     * MPEG-4 standard specifies certain restrictions for bitrate/framesize in VBR
1445 :     * to enable playback on devices with limited readspeed and memory (and which
1446 :     * aren't...)
1447 :     *
1448 :     * DivX profiles have 2 criteria: VBV as in MPEG standard
1449 : Isibaar 1906 * a limit on peak bitrate for any 1 second
1450 : chl 1470 *
1451 : edgomez 1473 * But if VBV is fulfilled, peakrate is automatically fulfilled in any profile
1452 : Isibaar 1906 * defined so far, so we check for it (for completeness) but correct only VBV
1453 : edgomez 1473 *
1454 : chl 1470 *****************************************************************************/
1455 :    
1456 : edgomez 1473 #define VBV_COMPLIANT 0
1457 : Isibaar 1906 #define VBV_UNDERFLOW 1 /* video buffer runs empty */
1458 :     #define VBV_OVERFLOW 2 /* doesn't exist for VBR encoding */
1459 :     #define VBV_PEAKRATE 4 /* peak bitrate (within 1s) violated */
1460 : chl 1470
1461 : edgomez 1473 static int
1462 :     check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)
1463 : chl 1470 {
1464 : edgomez 1473 /* We do all calculations in float, for higher accuracy,
1465 :     * and in bytes for convenience.
1466 :     *
1467 : Isibaar 1906 * typical values from e.g. Home profile:
1468 : edgomez 1473 * vbv_size= 384*1024 (384kB)
1469 :     * vbv_initial= 288*1024 (75% fill)
1470 : suxen_drol 1607 * maxrate= 4854000 (4.854MBps)
1471 :     * peakrate= 8000000 (8MBps)
1472 : edgomez 1473 *
1473 : Isibaar 1906 * PAL: offset1s = 25 (1 second of 25fps)
1474 :     * NTSC: offset1s = 30 (1 second of 29.97fps) or 24 (1 second of 23.976fps)
1475 : edgomez 1473 */
1476 : chl 1470
1477 : edgomez 1473 const float vbv_size = (float)rc->param.vbv_size/8.f;
1478 :     float vbvfill = (float)rc->param.vbv_initial/8.f;
1479 :     float vbvmin;
1480 : chl 1470
1481 : edgomez 1473 const float maxrate = (float)rc->param.vbv_maxrate;
1482 :     const float peakrate = (float)rc->param.vbv_peakrate;
1483 :     const float r0 = (int)(maxrate/fps+0.5)/8.f;
1484 : chl 1470
1485 : Isibaar 1906 int bytes1s = 0;
1486 :     int offset1s = (int)(1.f*fps+0.5);
1487 : edgomez 1473 int i;
1488 : chl 1470
1489 : edgomez 1473 /* 1Gbit should be enough to inuitialize the vbvmin
1490 :     * an arbitrary high value */
1491 :     vbvmin = 1000*1000*1000;
1492 : chl 1470
1493 : edgomez 1473 for (i=0; i<rc->num_frames; i++) {
1494 : Isibaar 1906 /* DivX 1s peak bitrate check */
1495 :     bytes1s += rc->stats[i].scaled_length;
1496 :     if (i>=offset1s)
1497 :     bytes1s -= rc->stats[i-offset1s].scaled_length;
1498 : chl 1470
1499 : suxen_drol 1607 /* ignore peakrate constraint if peakrate is <= 0.f */
1500 : Isibaar 1906 if (peakrate>0.f && 8.f*bytes1s > peakrate)
1501 : edgomez 1473 return(VBV_PEAKRATE);
1502 :    
1503 :     /* update vbv fill level */
1504 :     vbvfill += r0 - rc->stats[i].scaled_length;
1505 :    
1506 :     /* this check is _NOT_ an "overflow"! only reading from disk stops then */
1507 :     if (vbvfill > vbv_size)
1508 :     vbvfill = vbv_size;
1509 :    
1510 :     /* but THIS would be an underflow. report it! */
1511 :     if (vbvfill < 0)
1512 :     return(VBV_UNDERFLOW);
1513 :    
1514 :     /* Store the minimum buffer filling */
1515 :     if (vbvfill < vbvmin)
1516 :     vbvmin = vbvfill;
1517 :     }
1518 :    
1519 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] Minimum buffer fill: %f bytes\n", vbvmin);
1520 :    
1521 :     return(VBV_COMPLIANT);
1522 : chl 1470 }
1523 :    
1524 :    
1525 : edgomez 1473 static int
1526 :     scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)
1527 : chl 1470 {
1528 : edgomez 1473 /* correct any VBV violations. Peak bitrate violations disappears
1529 :     * by this automatically
1530 :     *
1531 :     * This implementation follows
1532 :     *
1533 :     * Westerink, Rajagopalan, Gonzales "Two-pass MPEG-2 variable-bitrate encoding"
1534 :     * IBM J. RES. DEVELOP. VOL 43, No. 4, July 1999, p.471--488
1535 :     *
1536 :     * Thanks, guys! This paper rocks!!! */
1537 : chl 1470
1538 : edgomez 1473 /* For each scene of len N, we have to check up to N^2 possible buffer fills.
1539 :     * This works well with MPEG-2 where N==12 or so, but for MPEG-4 it's a
1540 :     * little slow...
1541 :     *
1542 :     * TODO: Better control on VBVfill between scenes */
1543 : chl 1470
1544 : edgomez 1473 const float vbv_size = (float)rc->param.vbv_size/8.f;
1545 :     const float vbv_initial = (float)rc->param.vbv_initial/8.f;
1546 : chl 1470
1547 : Isibaar 1928 const float maxrate = 0.9f*rc->param.vbv_maxrate;
1548 : edgomez 1473 const float vbv_low = 0.10f*vbv_size;
1549 :     const float r0 = (int)(maxrate/fps+0.5)/8.f;
1550 : chl 1470
1551 : edgomez 1473 int i,k,l,n,violation = 0;
1552 :     float *scenefactor;
1553 :     int *scenestart;
1554 :     int *scenelength;
1555 : chl 1470
1556 : edgomez 1473 /* first step: determine how many "scenes" there are and store their
1557 :     * boundaries we could get all this from existing keyframe_positions,
1558 :     * somehow, but there we don't have a min_scenelength, and it's no big
1559 :     * deal to get it again. */
1560 : chl 1470
1561 : edgomez 1473 const int min_scenelength = (int)(fps+0.5);
1562 :     int num_scenes = 0;
1563 :     int last_scene = -999;
1564 :     for (i=0; i<rc->num_frames; i++) {
1565 :     if ((rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength)) {
1566 :     last_scene = i;
1567 :     num_scenes++;
1568 :     }
1569 :     }
1570 : chl 1470
1571 : edgomez 1473 scenefactor = (float*)malloc(num_scenes*sizeof(float));
1572 :     scenestart = (int*)malloc(num_scenes*sizeof(int));
1573 :     scenelength = (int*)malloc(num_scenes*sizeof(int));
1574 : chl 1470
1575 : edgomez 1473 if ((!scenefactor) || (!scenestart) || (!scenelength) ) {
1576 :     free(scenefactor);
1577 :     free(scenestart);
1578 :     free(scenelength);
1579 :     /* remember: free(0) is valid and does exactly nothing. */
1580 :     return(-1);
1581 :     }
1582 : chl 1470
1583 : edgomez 1473 /* count again and safe the length/position */
1584 : chl 1470
1585 : edgomez 1473 num_scenes = 0;
1586 :     last_scene = -999;
1587 :     for (i=0; i<rc->num_frames; i++) {
1588 :     if ((rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength)) {
1589 :     if (num_scenes>0) {
1590 :     scenelength[num_scenes-1]=i-last_scene;
1591 :     }
1592 :     scenestart[num_scenes]=i;
1593 :     num_scenes++;
1594 :     last_scene = i;
1595 :     }
1596 :     }
1597 :     scenelength[num_scenes-1]=i-last_scene;
1598 : chl 1470
1599 : edgomez 1473 /* second step: check for each scene, how much we can scale its frames up or
1600 :     * down such that the VBV restriction is just fulfilled */
1601 :     #define R(k,n) (((n)+1-(k))*r0) /* how much enters the buffer between frame k and n */
1602 :     for (l=0; l<num_scenes;l++) {
1603 :     const int start = scenestart[l];
1604 :     const int length = scenelength[l];
1605 :     twopass_stat_t * frames = &rc->stats[start];
1606 : chl 1470
1607 : edgomez 1473 float S0n,Skn;
1608 :     float f,minf = 99999.f;
1609 : chl 1470
1610 : edgomez 1473 S0n=0.;
1611 :     for (n=0;n<=length-1;n++) {
1612 :     S0n += frames[n].scaled_length;
1613 : chl 1470
1614 : edgomez 1473 k = 0;
1615 :     Skn = S0n;
1616 :     f = (R(k,n-1) + (vbv_initial - vbv_low)) / Skn;
1617 :     if (f < minf)
1618 :     minf = f;
1619 : chl 1470
1620 : edgomez 1473 for (k=1;k<=n;k++) {
1621 :     Skn -= frames[k].scaled_length;
1622 : chl 1470
1623 : edgomez 1473 f = (R(k,n-1) + (vbv_size - vbv_low)) / Skn;
1624 :     if (f < minf)
1625 :     minf = f;
1626 :     }
1627 :     }
1628 : chl 1470
1629 : edgomez 1473 /* special case: at the end, fill buffer up to vbv_initial again
1630 :     *
1631 :     * TODO: Allow other values for buffer fill between scenes
1632 :     * e.g. if n=N is smallest f-value, then check for better value */
1633 : chl 1470
1634 : edgomez 1473 n=length;
1635 :     k=0;
1636 :     Skn = S0n;
1637 :     f = R(k,n-1)/Skn;
1638 :     if (f < minf)
1639 :     minf = f;
1640 : chl 1470
1641 : edgomez 1473 for (k=1;k<=n-1;k++) {
1642 :     Skn -= frames[k].scaled_length;
1643 :    
1644 :     f = (R(k,n-1) + (vbv_initial - vbv_low)) / Skn;
1645 :     if (f < minf)
1646 :     minf = f;
1647 :     }
1648 :    
1649 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] Scene %d (Frames %d-%d): VBVfactor %f\n",
1650 :     l, start, start+length-1 , minf);
1651 :    
1652 :     scenefactor[l] = minf;
1653 :     }
1654 : chl 1470 #undef R
1655 :    
1656 : edgomez 1473 /* last step: now we know of any scene how much it can be scaled up or down
1657 :     * without violating VBV. Next, distribute bits from the evil scenes to the
1658 :     * good ones */
1659 :     do {
1660 :     float S_red = 0.f; /* how much to redistribute */
1661 :     float S_elig = 0.f; /* sum of bit for those scenes you can still swallow something*/
1662 :     float f_red;
1663 :     int l;
1664 : chl 1470
1665 : edgomez 1473 /* check how much is wrong */
1666 :     for (l=0;l<num_scenes;l++) {
1667 :     const int start = scenestart[l];
1668 :     const int length = scenelength[l];
1669 :     twopass_stat_t * frames = &rc->stats[start];
1670 : chl 1470
1671 : edgomez 1473 /* exactly 1 means "don't touch this anymore!" */
1672 :     if (scenefactor[l] == 1.)
1673 :     continue;
1674 : chl 1470
1675 : edgomez 1473 /* within limits */
1676 :     if (scenefactor[l] > 1.) {
1677 :     for (n= 0; n < length; n++)
1678 :     S_elig += frames[n].scaled_length;
1679 :     } else {
1680 :     /* underflowing segment */
1681 :     for (n= 0; n < length; n++) {
1682 :     float newbytes = (float)frames[n].scaled_length * scenefactor[l];
1683 :     S_red += (float)frames[n].scaled_length - (float)newbytes;
1684 :     frames[n].scaled_length =(int)newbytes;
1685 :     }
1686 :     scenefactor[l] = 1.f;
1687 :     }
1688 :     }
1689 : chl 1470
1690 : edgomez 1473 /* no more underflows */
1691 :     if (S_red < 1.f)
1692 :     break;
1693 : chl 1470
1694 : edgomez 1473 if (S_elig < 1.f) {
1695 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] Everything underflowing.\n");
1696 :     free(scenefactor);
1697 :     free(scenestart);
1698 :     free(scenelength);
1699 :     return(-2);
1700 :     }
1701 : chl 1470
1702 : edgomez 1473 f_red = (1.f + S_red/S_elig);
1703 : chl 1470
1704 : edgomez 1473 DPRINTF(XVID_DEBUG_RC, "[xvid rc] Moving %.0f kB to avoid buffer underflow, correction factor: %.5f\n",
1705 :     S_red/1024.f, f_red);
1706 : chl 1470
1707 : edgomez 1473 violation=0;
1708 :     /* scale remaining scenes up to meet total size */
1709 :     for (l=0; l<num_scenes; l++) {
1710 :     const int start = scenestart[l];
1711 :     const int length = scenelength[l];
1712 :     twopass_stat_t * frames = &rc->stats[start];
1713 : chl 1470
1714 : edgomez 1473 if (scenefactor[l] == 1.)
1715 :     continue;
1716 : chl 1470
1717 : edgomez 1473 /* there shouldn't be any segments with factor<1 left, so all the rest is >1 */
1718 :     for (n= 0; n < length; n++) {
1719 :     frames[n].scaled_length = (int)(frames[n].scaled_length * f_red + 0.5);
1720 :     }
1721 : chl 1470
1722 : edgomez 1473 scenefactor[l] /= f_red;
1723 :     if (scenefactor[l] < 1.f)
1724 :     violation=1;
1725 :     }
1726 :    
1727 :     } while (violation);
1728 :    
1729 :     free(scenefactor);
1730 :     free(scenestart);
1731 :     free(scenelength);
1732 :     return(0);
1733 : chl 1470 }
1734 :    
1735 :    
1736 :     /*****************************************************************************
1737 : edgomez 1382 * Still more low level stuff (nothing to do with stats treatment)
1738 :     ****************************************************************************/
1739 :    
1740 :     /* This function returns an allocated string containing a complete line read
1741 :     * from the file starting at the current position */
1742 :     static char *
1743 :     readline(FILE *f)
1744 :     {
1745 :     char *buffer = NULL;
1746 :     int buffer_size = 0;
1747 :     int pos = 0;
1748 :    
1749 :     do {
1750 :     int c;
1751 :    
1752 :     /* Read a character from the stream */
1753 :     c = fgetc(f);
1754 :    
1755 :     /* Is that EOF or new line ? */
1756 :     if(c == EOF || c == '\n')
1757 :     break;
1758 :    
1759 :     /* Do we have to update buffer ? */
1760 :     if(pos >= buffer_size - 1) {
1761 :     buffer_size += BUF_SZ;
1762 :     buffer = (char*)realloc(buffer, buffer_size);
1763 :     if (buffer == NULL)
1764 :     return(NULL);
1765 :     }
1766 :    
1767 :     buffer[pos] = c;
1768 :     pos++;
1769 :     } while(1);
1770 :    
1771 :     /* Read \n or EOF */
1772 :     if (buffer == NULL) {
1773 :     /* EOF, so we reached the end of the file, return NULL */
1774 :     if(feof(f))
1775 :     return(NULL);
1776 :    
1777 :     /* Just an empty line with just a newline, allocate a 1 byte buffer to
1778 :     * store a zero length string */
1779 :     buffer = (char*)malloc(1);
1780 :     if(buffer == NULL)
1781 :     return(NULL);
1782 :     }
1783 :    
1784 :     /* Zero terminated string */
1785 :     buffer[pos] = '\0';
1786 :    
1787 :     return(buffer);
1788 :     }
1789 :    
1790 :     /* This function returns a pointer to the first non space char in the given
1791 :     * string */
1792 :     static char *
1793 :     skipspaces(char *string)
1794 :     {
1795 :     const char spaces[] =
1796 :     {
1797 :     ' ','\t','\0'
1798 :     };
1799 :     const char *spacechar = spaces;
1800 :    
1801 :     if (string == NULL) return(NULL);
1802 :    
1803 :     while (*string != '\0') {
1804 :     /* Test against space chars */
1805 :     while (*spacechar != '\0') {
1806 :     if (*string == *spacechar) {
1807 :     string++;
1808 :     spacechar = spaces;
1809 :     break;
1810 :     }
1811 :     spacechar++;
1812 :     }
1813 :    
1814 :     /* No space char */
1815 :     if (*spacechar == '\0') return(string);
1816 :     }
1817 :    
1818 :     return(string);
1819 :     }
1820 :    
1821 :     /* This function returns a boolean that tells if the string is only a
1822 :     * comment */
1823 :     static int
1824 :     iscomment(char *string)
1825 :     {
1826 :     const char comments[] =
1827 :     {
1828 :     '#',';', '%', '\0'
1829 :     };
1830 :     const char *cmtchar = comments;
1831 :     int iscomment = 0;
1832 :    
1833 :     if (string == NULL) return(1);
1834 :    
1835 :     string = skipspaces(string);
1836 :    
1837 :     while(*cmtchar != '\0') {
1838 :     if(*string == *cmtchar) {
1839 :     iscomment = 1;
1840 :     break;
1841 :     }
1842 :     cmtchar++;
1843 :     }
1844 :    
1845 :     return(iscomment);
1846 :     }
1847 :    
1848 :     #if 0
1849 :     static void
1850 :     stats_print(rc_2pass2_t * rc)
1851 :     {
1852 :     int i;
1853 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
1854 :    
1855 :     for (i=0; i<rc->num_frames; i++) {
1856 :     twopass_stat_t *s = &rc->stats[i];
1857 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- frame:%d type:%c quant:%d stats:%d scaled:%d desired:%d actual:%d overflow(%c):%.2f\n",
1858 :     i, frame_type[s->type-1], -1, s->length, s->scaled_length,
1859 :     s->desired_length, -1, frame_type[s->type-1], -1.0f);
1860 :     }
1861 :     }
1862 :     #endif

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