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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.3 - (view) (download)

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

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