[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.2 - (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 :     * $Id$
29 :     *
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 :     * Histerysis helpers
181 :     *--------------------------------*/
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 :     #if 0
274 :     static void stats_print(rc_2pass2_t * rc);
275 :     #endif
276 :    
277 :     /*----------------------------------------------------------------------------
278 :     *--------------------------------------------------------------------------*/
279 :    
280 :     static int
281 :     rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t **handle)
282 :     {
283 :     xvid_plugin_2pass2_t * param = (xvid_plugin_2pass2_t *)create->param;
284 :     rc_2pass2_t * rc;
285 :     int i;
286 :    
287 :     rc = malloc(sizeof(rc_2pass2_t));
288 :     if (rc == NULL)
289 :     return XVID_ERR_MEMORY;
290 :    
291 :     rc->param = *param;
292 :    
293 :     /* Initialize all defaults */
294 :     #define _INIT(a, b) if((a) <= 0) (a) = (b)
295 :     /* Let's set our defaults if needed */
296 :     _INIT(rc->param.keyframe_boost, DEFAULT_KEYFRAME_BOOST);
297 :     _INIT(rc->param.overflow_control_strength, DEFAULT_OVERFLOW_CONTROL_STRENGTH);
298 :     _INIT(rc->param.curve_compression_high, DEFAULT_CURVE_COMPRESSION_HIGH);
299 :     _INIT(rc->param.curve_compression_low, DEFAULT_CURVE_COMPRESSION_LOW);
300 :     _INIT(rc->param.max_overflow_improvement, DEFAULT_MAX_OVERFLOW_IMPROVEMENT);
301 :     _INIT(rc->param.max_overflow_degradation, DEFAULT_MAX_OVERFLOW_DEGRADATION);
302 :    
303 :     /* Keyframe settings */
304 :     _INIT(rc->param.kfreduction, DEFAULT_KFREDUCTION);
305 :     _INIT(rc->param.kfthreshold, DEFAULT_KFTHRESHOLD);
306 :     #undef _INIT
307 :    
308 :     /* Initialize some stuff to zero */
309 :     for(i=0; i<3; i++) {
310 :     int j;
311 :     for (j=0; j<32; j++) {
312 :     rc->quant_error[i][j] = 0;
313 :     rc->quant_count[i][j] = 0;
314 :     }
315 :     }
316 :    
317 :     for (i=0; i<3; i++) rc->last_quant[i] = 0;
318 :    
319 :     rc->fq_error = 0;
320 :     rc->min_quant = 1;
321 :    
322 :     /* Count frames (and intra frames) in the stats file, store the result into
323 :     * the rc structure */
324 :     if (statsfile_count_frames(rc, param->filename) == -1) {
325 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
326 :     free(rc);
327 :     return(XVID_ERR_FAIL);
328 :     }
329 :    
330 :     /* Allocate the stats' memory */
331 :     if ((rc->stats = malloc(rc->num_frames * sizeof(twopass_stat_t))) == NULL) {
332 :     free(rc);
333 :     return(XVID_ERR_MEMORY);
334 :     }
335 :    
336 :     /* Allocate keyframes location's memory
337 :     * PS: see comment in pre_process0 for the +1 location requirement */
338 :     rc->keyframe_locations = malloc((rc->num_keyframes + 1) * sizeof(int));
339 :     if (rc->keyframe_locations == NULL) {
340 :     free(rc->stats);
341 :     free(rc);
342 :     return(XVID_ERR_MEMORY);
343 :     }
344 :    
345 :     /* Load the first pass stats */
346 :     if (statsfile_load(rc, param->filename) == -1) {
347 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- ERROR: fopen %s failed\n", param->filename);
348 :     free(rc->keyframe_locations);
349 :     free(rc->stats);
350 :     free(rc);
351 :     return XVID_ERR_FAIL;
352 :     }
353 :    
354 :     /* Compute the target filesize */
355 :     if (rc->param.bitrate<0) {
356 :     /* if negative, bitrate equals the target (in kbytes) */
357 :     rc->target = ((uint64_t)(-rc->param.bitrate)) * 1024;
358 :     } else if (rc->num_frames < create->fbase/create->fincr) {
359 :     /* Source sequence is less than 1s long, we do as if it was 1s long */
360 :     rc->target = rc->param.bitrate / 8;
361 :     } else {
362 :     /* Target filesize = bitrate/8 * numframes / framerate */
363 :     rc->target =
364 :     ((uint64_t)rc->param.bitrate * (uint64_t)rc->num_frames * \
365 :     (uint64_t)create->fincr) / \
366 :     ((uint64_t)create->fbase * 8);
367 :     }
368 :    
369 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Frame rate: %d/%d (%ffps)\n",
370 :     create->fbase, create->fincr,
371 :     (double)create->fbase/(double)create->fincr);
372 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Number of frames: %d\n", rc->num_frames);
373 :     if(rc->param.bitrate>=0)
374 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target bitrate: %ld\n", rc->param.bitrate);
375 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Target filesize: %lld\n", rc->target);
376 :    
377 :     /* Compensate the average frame overhead caused by the container */
378 :     rc->target -= rc->num_frames*rc->param.container_frame_overhead;
379 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Container Frame overhead: %d\n", rc->param.container_frame_overhead);
380 :     if(rc->param.container_frame_overhead)
381 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- New target filesize after container compensation: %lld\n", rc->target);
382 :    
383 :     /* When bitrate is not given it means it has been scaled by an external
384 :     * application */
385 :     if (rc->param.bitrate) {
386 :     /* Apply zone settings
387 :     * - set rc->tot_quant which represents the total num of bytes spent in
388 :     * fixed quant zones
389 :     * - set rc->tot_weighted which represents the total amount of bytes
390 :     * spent in normal or weighted zones in first pass (normal zones can
391 :     * be considered weight=1)
392 :     * - set rc->tot_quant_invariant which represents the total num of bytes
393 :     * spent in fixed quant zones for headers */
394 :     zone_process(rc, create);
395 :     } else {
396 :     /* External scaling -- zones are ignored */
397 :     for (i=0;i<rc->num_frames;i++) {
398 :     rc->stats[i].zone_mode = XVID_ZONE_WEIGHT;
399 :     rc->stats[i].weight = 1.0;
400 :     }
401 :     rc->tot_quant = 0;
402 :     }
403 :    
404 :     /* Gathers some information about first pass stats:
405 :     * - finds the minimum frame length for each frame type during 1st pass.
406 :     * rc->min_size[]
407 :     * - determines the maximum frame length observed (no frame type distinction).
408 :     * rc->max_size
409 :     * - count how many times each frame type has been used.
410 :     * rc->count[]
411 :     * - total bytes used per frame type
412 :     * rc->tot_length[]
413 :     * - total bytes considered invariant between the 2 passes
414 :     * - store keyframe location
415 :     * rc->keyframe_locations[]
416 :     */
417 :     first_pass_stats_prepare_data(rc);
418 :    
419 :     /* If we have a user bitrate, it means it's an internal curve scaling */
420 :     if (rc->param.bitrate) {
421 :     /* Perform internal curve scaling */
422 :     first_pass_scale_curve_internal(rc);
423 :     }
424 :    
425 :     /* Apply advanced curve options, and compute some parameters in order to
426 :     * shape the curve in the BEFORE/AFTER pair of functions */
427 :     scaled_curve_apply_advanced_parameters(rc);
428 :    
429 :     *handle = rc;
430 :     return(0);
431 :     }
432 :    
433 :     /*----------------------------------------------------------------------------
434 :     *--------------------------------------------------------------------------*/
435 :    
436 :     static int
437 :     rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy)
438 :     {
439 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- target_total:%lld desired_total:%.2f (%.2f%%) actual_total:%.2f (%.2f%%)\n",
440 :     rc->target,
441 :     rc->desired_total,
442 :     100*rc->desired_total/(double)rc->target,
443 :     rc->real_total,
444 :     100*rc->real_total/(double)rc->target);
445 :    
446 :     free(rc->keyframe_locations);
447 :     free(rc->stats);
448 :     free(rc);
449 :     return(0);
450 :     }
451 :    
452 :     /*----------------------------------------------------------------------------
453 :     *--------------------------------------------------------------------------*/
454 :    
455 :     static int
456 :     rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data)
457 :     {
458 :     twopass_stat_t * s = &rc->stats[data->frame_num];
459 :     double dbytes;
460 :     double scaled_quant;
461 :     double overflow;
462 :     int capped_to_max_framesize = 0;
463 :    
464 :     /* This function is quite long but easy to understand. In order to simplify
465 :     * the code path (a bit), we treat 3 cases that can return immediatly. */
466 :    
467 :     /* First case: Another plugin has already set a quantizer */
468 :     if (data->quant > 0)
469 :     return(0);
470 :    
471 :     /* Second case: insufficent stats data
472 :     * We can't guess much what we should do, let core decide all alone */
473 :     if (data->frame_num >= rc->num_frames) {
474 :     DPRINTF(XVID_DEBUG_RC,"[xvid rc] -- stats file too short (now processing frame %d)",
475 :     data->frame_num);
476 :     return(0);
477 :     }
478 :    
479 :     /* Third case: We are in a Quant zone
480 :     * Quant zones must just ensure we use the same settings as first pass
481 :     * So set the quantizer and the type */
482 :     if (s->zone_mode == XVID_ZONE_QUANT) {
483 :     /* Quant stuff */
484 :     rc->fq_error += s->weight;
485 :     data->quant = (int)rc->fq_error;
486 :     rc->fq_error -= data->quant;
487 :    
488 :     /* The type stuff */
489 :     data->type = s->type;
490 :    
491 :     /* The only required data for AFTER step is this one for the overflow
492 :     * control */
493 :     s->desired_length = s->length;
494 :    
495 :     return(0);
496 :     }
497 :    
498 :    
499 :     /*************************************************************************/
500 :     /*************************************************************************/
501 :     /*************************************************************************/
502 :    
503 :     /*-------------------------------------------------------------------------
504 :     * Frame bit allocation first part
505 :     *
506 :     * First steps apply user settings, just like it is done in the theoritical
507 :     * scaled_curve_apply_advanced_parameters
508 :     *-----------------------------------------------------------------------*/
509 :    
510 :     /* Set desired to what we are wanting to obtain for this frame */
511 :     dbytes = (double)s->scaled_length;
512 :    
513 :     /* IFrame user settings*/
514 :     if (s->type == XVID_TYPE_IVOP) {
515 :     /* Keyframe boosting -- All keyframes benefit from it */
516 :     dbytes += dbytes*rc->param.keyframe_boost / 100;
517 :    
518 :     #if 0 /* ToDo: decide how to apply kfthresholding */
519 :     #endif
520 :     } else {
521 :    
522 :     /* P/S/B frames must reserve some bits for iframe boosting */
523 :     dbytes *= rc->pb_iboost_tax_ratio;
524 :    
525 :     /* Apply assymetric curve compression */
526 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
527 :     double assymetric_delta;
528 :    
529 :     /* Compute the assymetric delta, this is computed before applying
530 :     * the tax, as done in the pre_process function */
531 :     if (dbytes > rc->avg_length[s->type-1])
532 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_high / 100.0;
533 :     else
534 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * rc->param.curve_compression_low / 100.0;
535 :    
536 :     /* Now we must apply the assymetric tax, else our curve compression
537 :     * would not give a theoritical target size equal to what it is
538 :     * expected */
539 :     dbytes *= rc->assymetric_tax_ratio;
540 :    
541 :     /* Now we can add the assymetric delta */
542 :     dbytes += assymetric_delta;
543 :     }
544 :     }
545 :    
546 :     /* That is what we would like to have -- Don't put that chunk after
547 :     * overflow control, otherwise, overflow is counted twice and you obtain
548 :     * half sized bitrate sequences */
549 :     s->desired_length = (int)dbytes;
550 :     rc->desired_total += dbytes;
551 :    
552 :     /*------------------------------------------------------------------------
553 :     * Frame bit allocation: overflow control part.
554 :     *
555 :     * Unlike the theoritical scaled_curve_apply_advanced_parameters, here
556 :     * it's real encoding and we need to make sure we don't go so far from
557 :     * what is our ideal scaled curve.
558 :     *-----------------------------------------------------------------------*/
559 :    
560 :     /* Compute the overflow we should compensate */
561 :     if (s->type != XVID_TYPE_IVOP || rc->overflow > 0) {
562 :     double frametype_factor;
563 :     double framesize_factor;
564 :    
565 :     /* Take only the desired part of overflow */
566 :     overflow = rc->overflow;
567 :    
568 :     /* Factor that will take care to decrease the overflow applied
569 :     * according to the importance of this frame type in term of
570 :     * overall size */
571 :     frametype_factor = rc->count[XVID_TYPE_IVOP-1]*rc->avg_length[XVID_TYPE_IVOP-1];
572 :     frametype_factor += rc->count[XVID_TYPE_PVOP-1]*rc->avg_length[XVID_TYPE_PVOP-1];
573 :     frametype_factor += rc->count[XVID_TYPE_BVOP-1]*rc->avg_length[XVID_TYPE_BVOP-1];
574 :     frametype_factor /= rc->count[s->type-1]*rc->avg_length[s->type-1];
575 :     frametype_factor = 1/frametype_factor;
576 :    
577 :     /* Factor that will take care not to compensate too much for this frame
578 :     * size */
579 :     framesize_factor = dbytes;
580 :     framesize_factor /= rc->avg_length[s->type-1];
581 :    
582 :     /* Treat only the overflow part concerned by this frame type and size */
583 :     overflow *= frametype_factor;
584 :     #if 0
585 :     /* Leave this one alone, as it impacts badly on quality */
586 :     overflow *= framesize_factor;
587 :     #endif
588 :    
589 :     /* Apply the overflow strength imposed by the user */
590 :     overflow *= (rc->param.overflow_control_strength/100.0f);
591 :     } else {
592 :     /* no negative overflow applied in IFrames because:
593 :     * - their role is important as they're references for P/BFrames.
594 :     * - there aren't much in typical sequences, so if an IFrame overflows too
595 :     * much, this overflow may impact the next IFrame too much and generate
596 :     * a sequence of poor quality frames */
597 :     overflow = 0;
598 :     }
599 :    
600 :     /* Make sure we are not trying to compensate more overflow than we even have */
601 :     if (fabs(overflow) > fabs(rc->overflow))
602 :     overflow = rc->overflow;
603 :    
604 :     /* Make sure the overflow doesn't make the frame size to get out of the range
605 :     * [-max_degradation..+max_improvment] */
606 :     if (overflow > dbytes*rc->param.max_overflow_improvement / 100) {
607 :     if(overflow <= dbytes)
608 :     dbytes += dbytes * rc->param.max_overflow_improvement / 100;
609 :     else
610 :     dbytes += overflow * rc->param.max_overflow_improvement / 100;
611 :     } else if (overflow < - dbytes * rc->param.max_overflow_degradation / 100) {
612 :     dbytes -= dbytes * rc->param.max_overflow_degradation / 100;
613 :     } else {
614 :     dbytes += overflow;
615 :     }
616 :    
617 :     /*-------------------------------------------------------------------------
618 :     * Frame bit allocation last part:
619 :     *
620 :     * Cap frame length so we don't reach neither bigger frame sizes than first
621 :     * pass nor smaller than the allowed minimum.
622 :     *-----------------------------------------------------------------------*/
623 :    
624 :     #ifdef PASS_SMALLER
625 :     if (dbytes > s->length) {
626 :     dbytes = s->length;
627 :     }
628 :     #endif
629 :    
630 :     /* Prevent stupid desired sizes under logical values */
631 :     if (dbytes < rc->min_length[s->type-1]) {
632 :     dbytes = rc->min_length[s->type-1];
633 :     }
634 :    
635 :     /*------------------------------------------------------------------------
636 :     * Desired frame length <-> quantizer mapping
637 :     *-----------------------------------------------------------------------*/
638 :    
639 :     #ifdef BQUANT_PRESCALE
640 :     /* For bframes we prescale the quantizer to avoid too high quant scaling */
641 :     if(s->type == XVID_TYPE_BVOP) {
642 :    
643 :     twopass_stat_t *b_ref = s;
644 :    
645 :     /* Find the reference frame */
646 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
647 :     b_ref--;
648 :    
649 :     /* Compute the original quant */
650 :     s->quant = 2*(100*s->quant - data->bquant_offset);
651 :     s->quant += data->bquant_ratio - 1; /* to avoid rounding issues */
652 :     s->quant = s->quant/data->bquant_ratio - b_ref->quant;
653 :     }
654 :     #endif
655 :    
656 :     /* Don't laugh at this very 'simple' quant<->size relationship, it
657 :     * proves to be acurate enough for our algorithm */
658 :     scaled_quant = (double)s->quant*(double)s->length/(double)dbytes;
659 :    
660 :     #ifdef COMPENSATE_FORMULA
661 :     /* We know xvidcore will apply the bframe formula again, so we compensate
662 :     * it right now to make sure we would not apply it twice */
663 :     if(s->type == XVID_TYPE_BVOP) {
664 :    
665 :     twopass_stat_t *b_ref = s;
666 :    
667 :     /* Find the reference frame */
668 :     while(b_ref != &rc->stats[0] && b_ref->type == XVID_TYPE_BVOP)
669 :     b_ref--;
670 :    
671 :     /* Compute the quant it would be if the core did not apply the bframe
672 :     * formula */
673 :     scaled_quant = 100*scaled_quant - data->bquant_offset;
674 :     scaled_quant += data->bquant_ratio - 1; /* to avoid rouding issues */
675 :     scaled_quant /= data->bquant_ratio;
676 :     }
677 :     #endif
678 :    
679 :     /* Quantizer has been scaled using floating point operations/results, we
680 :     * must cast it to integer */
681 :     data->quant = (int)scaled_quant;
682 :    
683 :     /* Let's clip the computed quantizer, if needed */
684 :     if (data->quant < 1) {
685 :     data->quant = 1;
686 :     } else if (data->quant > 31) {
687 :     data->quant = 31;
688 :     } else {
689 :    
690 :     /* The frame quantizer has not been clipped, this appears to be a good
691 :     * computed quantizer, do not loose quantizer decimal part that we
692 :     * accumulate for later reuse when its sum represents a complete
693 :     * unit. */
694 :     rc->quant_error[s->type-1][data->quant] += scaled_quant - (double)data->quant;
695 :    
696 :     if (rc->quant_error[s->type-1][data->quant] >= 1.0) {
697 :     rc->quant_error[s->type-1][data->quant] -= 1.0;
698 :     data->quant++;
699 :     } else if (rc->quant_error[s->type-1][data->quant] <= -1.0) {
700 :     rc->quant_error[s->type-1][data->quant] += 1.0;
701 :     data->quant--;
702 :     }
703 :     }
704 :    
705 :     /* Now we have a computed quant that is in the right quante range, with a
706 :     * possible +1 correction due to cumulated error. We can now safely clip
707 :     * the quantizer again with user's quant ranges. "Safely" means the Rate
708 :     * Control could learn more about this quantizer, this knowledge is useful
709 :     * for future frames even if it this quantizer won't be really used atm,
710 :     * that's why we don't perform this clipping earlier. */
711 :     if (data->quant < data->min_quant[s->type-1]) {
712 :     data->quant = data->min_quant[s->type-1];
713 :     } else if (data->quant > data->max_quant[s->type-1]) {
714 :     data->quant = data->max_quant[s->type-1];
715 :     }
716 :    
717 :     if (data->quant < rc->min_quant) data->quant = rc->min_quant;
718 :    
719 :     /* To avoid big quality jumps from frame to frame, we apply a "security"
720 :     * rule that makes |last_quant - new_quant| <= 2. This rule only applies
721 :     * to predicted frames (P and B) */
722 :     if (s->type != XVID_TYPE_IVOP && rc->last_quant[s->type-1] && capped_to_max_framesize == 0) {
723 :    
724 :     if (data->quant > rc->last_quant[s->type-1] + 2) {
725 :     data->quant = rc->last_quant[s->type-1] + 2;
726 :     DPRINTF(XVID_DEBUG_RC,
727 :     "[xvid rc] -- frame %d p/b-frame quantizer prevented from rising too steeply\n",
728 :     data->frame_num);
729 :     }
730 :     if (data->quant < rc->last_quant[s->type-1] - 2) {
731 :     data->quant = rc->last_quant[s->type-1] - 2;
732 :     DPRINTF(XVID_DEBUG_RC,
733 :     "[xvid rc] -- frame:%d p/b-frame quantizer prevented from falling too steeply\n",
734 :     data->frame_num);
735 :     }
736 :     }
737 :    
738 :     /* We don't want to pollute the RC histerisis when our computed quant has
739 :     * been computed from a capped frame size */
740 :     if (capped_to_max_framesize == 0)
741 :     rc->last_quant[s->type-1] = data->quant;
742 :    
743 :     /* Don't forget to force 1st pass frame type ;-) */
744 :     data->type = s->type;
745 :    
746 :     return 0;
747 :     }
748 :    
749 :     /*----------------------------------------------------------------------------
750 :     *--------------------------------------------------------------------------*/
751 :    
752 :     static int
753 :     rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data)
754 :     {
755 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
756 :     twopass_stat_t * s = &rc->stats[data->frame_num];
757 :    
758 :     /* Insufficent stats data */
759 :     if (data->frame_num >= rc->num_frames)
760 :     return 0;
761 :    
762 :     /* Update the quantizer counter */
763 :     rc->quant_count[s->type-1][data->quant]++;
764 :    
765 :     /* Update the frame type overflow */
766 :     if (data->type == XVID_TYPE_IVOP) {
767 :     int kfdiff = 0;
768 :    
769 :     if(rc->KF_idx != rc->num_frames -1) {
770 :     kfdiff = rc->keyframe_locations[rc->KF_idx+1];
771 :     kfdiff -= rc->keyframe_locations[rc->KF_idx];
772 :     }
773 :    
774 :     /* Flush Keyframe overflow accumulator */
775 :     rc->overflow += rc->KFoverflow;
776 :    
777 :     /* Store the frame overflow to the keyframe accumulator */
778 :     rc->KFoverflow = s->desired_length - data->length;
779 :    
780 :     if (kfdiff > 1) {
781 :     /* Non-consecutive keyframes case:
782 :     * We can then divide this total keyframe overflow into equal parts
783 :     * that we will distribute into regular overflow at each frame
784 :     * between the sequence bounded by two IFrames */
785 :     rc->KFoverflow_partial = rc->KFoverflow / (kfdiff - 1);
786 :     } else {
787 :     /* Consecutive keyframes case:
788 :     * Flush immediatly the keyframe overflow and reset keyframe
789 :     * overflow */
790 :     rc->overflow += rc->KFoverflow;
791 :     rc->KFoverflow = 0;
792 :     rc->KFoverflow_partial = 0;
793 :     }
794 :     rc->KF_idx++;
795 :     } else {
796 :     /* Accumulate the frame overflow */
797 :     rc->overflow += s->desired_length - data->length;
798 :    
799 :     /* Distribute part of the keyframe overflow */
800 :     rc->overflow += rc->KFoverflow_partial;
801 :    
802 :     /* Don't forget to substract that same amount from the total keyframe
803 :     * overflow */
804 :     rc->KFoverflow -= rc->KFoverflow_partial;
805 :     }
806 :    
807 :     rc->overflow += (s->error = s->desired_length - data->length);
808 :     rc->real_total += data->length;
809 :    
810 :     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",
811 :     data->frame_num,
812 :     frame_type[data->type-1],
813 :     data->quant,
814 :     s->length,
815 :     s->scaled_length,
816 :     s->desired_length,
817 :     s->desired_length - s->error,
818 :     -s->error,
819 :     rc->overflow);
820 :    
821 :     return(0);
822 :     }
823 :    
824 :     /*****************************************************************************
825 :     * Helper functions definition
826 :     ****************************************************************************/
827 :    
828 :     /* Default buffer size for reading lines */
829 :     #define BUF_SZ 1024
830 :    
831 :     /* Helper functions for reading/parsing the stats file */
832 :     static char *skipspaces(char *string);
833 :     static int iscomment(char *string);
834 :     static char *readline(FILE *f);
835 :    
836 :     /* This function counts the number of frame entries in the stats file
837 :     * It also counts the number of I Frames */
838 :     static int
839 :     statsfile_count_frames(rc_2pass2_t * rc, char * filename)
840 :     {
841 :     FILE * f;
842 :     char *line;
843 :     int lines;
844 :    
845 :     rc->num_frames = 0;
846 :     rc->num_keyframes = 0;
847 :    
848 :     if ((f = fopen(filename, "rb")) == NULL)
849 :     return(-1);
850 :    
851 :     lines = 0;
852 :     while ((line = readline(f)) != NULL) {
853 :    
854 :     char *ptr;
855 :     char type;
856 :     int fields;
857 :    
858 :     lines++;
859 :    
860 :     /* We skip spaces */
861 :     ptr = skipspaces(line);
862 :    
863 :     /* Skip coment lines or empty lines */
864 :     if(iscomment(ptr) || *ptr == '\0') {
865 :     free(line);
866 :     continue;
867 :     }
868 :    
869 :     /* Read the stat line from buffer */
870 :     fields = sscanf(ptr, "%c", &type);
871 :    
872 :     /* Valid stats files have at least 7 fields */
873 :     if (fields == 1) {
874 :     switch(type) {
875 :     case 'i':
876 :     case 'I':
877 :     rc->num_keyframes++;
878 :     case 'p':
879 :     case 'P':
880 :     case 'b':
881 :     case 'B':
882 :     case 's':
883 :     case 'S':
884 :     rc->num_frames++;
885 :     break;
886 :     default:
887 :     DPRINTF(XVID_DEBUG_RC,
888 :     "[xvid rc] -- WARNING: L%d unknown frame type used (%c).\n",
889 :     lines, type);
890 :     }
891 :     } else {
892 :     DPRINTF(XVID_DEBUG_RC,
893 :     "[xvid rc] -- WARNING: L%d misses some stat fields (%d).\n",
894 :     lines, 7-fields);
895 :     }
896 :    
897 :     /* Free the line buffer */
898 :     free(line);
899 :     }
900 :    
901 :     /* We are done with the file */
902 :     fclose(f);
903 :    
904 :     return(0);
905 :     }
906 :    
907 :     /* open stats file(s) and read into rc->stats array */
908 :     static int
909 :     statsfile_load(rc_2pass2_t *rc, char * filename)
910 :     {
911 :     FILE * f;
912 :     int processed_entries;
913 :    
914 :     /* Opens the file */
915 :     if ((f = fopen(filename, "rb"))==NULL)
916 :     return(-1);
917 :    
918 :     processed_entries = 0;
919 :     while(processed_entries < rc->num_frames) {
920 :     char type;
921 :     int fields;
922 :     twopass_stat_t * s = &rc->stats[processed_entries];
923 :     char *line, *ptr;
924 :    
925 :     /* Read the line from the file */
926 :     if((line = readline(f)) == NULL)
927 :     break;
928 :    
929 :     /* We skip spaces */
930 :     ptr = skipspaces(line);
931 :    
932 :     /* Skip comment lines or empty lines */
933 :     if(iscomment(ptr) || *ptr == '\0') {
934 :     free(line);
935 :     continue;
936 :     }
937 :    
938 :     /* Reset this field that is optional */
939 :     s->scaled_length = 0;
940 :    
941 :     /* Convert the fields */
942 :     fields = sscanf(ptr,
943 :     "%c %d %d %d %d %d %d %d\n",
944 :     &type,
945 :     &s->quant,
946 :     &s->blks[0], &s->blks[1], &s->blks[2],
947 :     &s->length, &s->invariant /* not really yet */,
948 :     &s->scaled_length);
949 :    
950 :     /* Free line buffer, we don't need it anymore */
951 :     free(line);
952 :    
953 :     /* Fail silently, this has probably been warned in
954 :     * statsfile_count_frames */
955 :     if(fields != 7 && fields != 8)
956 :     continue;
957 :    
958 :     /* Convert frame type and compute the invariant length part */
959 :     switch(type) {
960 :     case 'i':
961 :     case 'I':
962 :     s->type = XVID_TYPE_IVOP;
963 :     s->invariant /= INVARIANT_HEADER_PART_IVOP;
964 :     break;
965 :     case 'p':
966 :     case 'P':
967 :     case 's':
968 :     case 'S':
969 :     s->type = XVID_TYPE_PVOP;
970 :     s->invariant /= INVARIANT_HEADER_PART_PVOP;
971 :     break;
972 :     case 'b':
973 :     case 'B':
974 :     s->type = XVID_TYPE_BVOP;
975 :     s->invariant /= INVARIANT_HEADER_PART_BVOP;
976 :     break;
977 :     default:
978 :     /* Same as before, fail silently */
979 :     continue;
980 :     }
981 :    
982 :     /* Ok it seems it's been processed correctly */
983 :     processed_entries++;
984 :     }
985 :    
986 :     /* Close the file */
987 :     fclose(f);
988 :    
989 :     return(0);
990 :     }
991 :    
992 :     /* pre-process the statistics data
993 :     * - for each type, count, tot_length, min_length, max_length
994 :     * - set keyframes_locations, tot_prescaled */
995 :     static void
996 :     first_pass_stats_prepare_data(rc_2pass2_t * rc)
997 :     {
998 :     int i,j;
999 :    
1000 :     /* *rc fields initialization
1001 :     * NB: INT_MAX and INT_MIN are used in order to be immediately replaced
1002 :     * with real values of the 1pass */
1003 :     for (i=0; i<3; i++) {
1004 :     rc->count[i]=0;
1005 :     rc->tot_length[i] = 0;
1006 :     rc->tot_invariant[i] = 0;
1007 :     rc->min_length[i] = INT_MAX;
1008 :     }
1009 :    
1010 :     rc->max_length = INT_MIN;
1011 :     rc->tot_weighted = 0;
1012 :    
1013 :     /* Loop through all frames and find/compute all the stuff this function
1014 :     * is supposed to do */
1015 :     for (i=j=0; i<rc->num_frames; i++) {
1016 :     twopass_stat_t * s = &rc->stats[i];
1017 :    
1018 :     rc->count[s->type-1]++;
1019 :     rc->tot_length[s->type-1] += s->length;
1020 :     rc->tot_invariant[s->type-1] += s->invariant;
1021 :     if (s->zone_mode != XVID_ZONE_QUANT)
1022 :     rc->tot_weighted += (int)(s->weight*(s->length - s->invariant));
1023 :    
1024 :     if (s->length < rc->min_length[s->type-1]) {
1025 :     rc->min_length[s->type-1] = s->length;
1026 :     }
1027 :    
1028 :     if (s->length > rc->max_length) {
1029 :     rc->max_length = s->length;
1030 :     }
1031 :    
1032 :     if (s->type == XVID_TYPE_IVOP) {
1033 :     rc->keyframe_locations[j] = i;
1034 :     j++;
1035 :     }
1036 :     }
1037 :    
1038 :     /* NB:
1039 :     * The "per sequence" overflow system considers a natural sequence to be
1040 :     * formed by all frames between two iframes, so if we want to make sure
1041 :     * the system does not go nuts during last sequence, we force the last
1042 :     * frame to appear in the keyframe locations array. */
1043 :     rc->keyframe_locations[j] = i;
1044 :    
1045 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass IFrame length: %d\n", rc->min_length[0]);
1046 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass PFrame length: %d\n", rc->min_length[1]);
1047 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Min 1st pass BFrame length: %d\n", rc->min_length[2]);
1048 :     }
1049 :    
1050 :     /* calculate zone weight "center" */
1051 :     static void
1052 :     zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create)
1053 :     {
1054 :     int i,j;
1055 :     int n = 0;
1056 :    
1057 :     rc->tot_quant = 0;
1058 :     rc->tot_quant_invariant = 0;
1059 :    
1060 :     if (create->num_zones == 0) {
1061 :     for (j = 0; j < rc->num_frames; j++) {
1062 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1063 :     rc->stats[j].weight = 1.0;
1064 :     }
1065 :     n += rc->num_frames;
1066 :     }
1067 :    
1068 :    
1069 :     for(i=0; i < create->num_zones; i++) {
1070 :    
1071 :     int next = (i+1<create->num_zones) ? create->zones[i+1].frame : rc->num_frames;
1072 :    
1073 :     /* Zero weight make no sense */
1074 :     if (create->zones[i].increment == 0) create->zones[i].increment = 1;
1075 :     /* And obviously an undetermined infinite makes even less sense */
1076 :     if (create->zones[i].base == 0) create->zones[i].base = 1;
1077 :    
1078 :     if (i==0 && create->zones[i].frame > 0) {
1079 :     for (j = 0; j < create->zones[i].frame && j < rc->num_frames; j++) {
1080 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1081 :     rc->stats[j].weight = 1.0;
1082 :     }
1083 :     n += create->zones[i].frame;
1084 :     }
1085 :    
1086 :     if (create->zones[i].mode == XVID_ZONE_WEIGHT) {
1087 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1088 :     rc->stats[j].zone_mode = XVID_ZONE_WEIGHT;
1089 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1090 :     }
1091 :     next -= create->zones[i].frame;
1092 :     n += next;
1093 :     } else{ /* XVID_ZONE_QUANT */
1094 :     for (j = create->zones[i].frame; j < next && j < rc->num_frames; j++ ) {
1095 :     rc->stats[j].zone_mode = XVID_ZONE_QUANT;
1096 :     rc->stats[j].weight = (double)create->zones[i].increment / (double)create->zones[i].base;
1097 :     rc->tot_quant += rc->stats[j].length;
1098 :     rc->tot_quant_invariant += rc->stats[j].invariant;
1099 :     }
1100 :     }
1101 :     }
1102 :     }
1103 :    
1104 :    
1105 :     /* scale the curve */
1106 :     static void
1107 :     first_pass_scale_curve_internal(rc_2pass2_t *rc)
1108 :     {
1109 :     int64_t target;
1110 :     int64_t total_invariant;
1111 :     double scaler;
1112 :     int i, num_MBs;
1113 :    
1114 :     /* We only scale texture data ! */
1115 :     total_invariant = rc->tot_invariant[XVID_TYPE_IVOP-1];
1116 :     total_invariant += rc->tot_invariant[XVID_TYPE_PVOP-1];
1117 :     total_invariant += rc->tot_invariant[XVID_TYPE_BVOP-1];
1118 :     /* don't forget to substract header bytes used in quant zones, otherwise we
1119 :     * counting them twice */
1120 :     total_invariant -= rc->tot_quant_invariant;
1121 :    
1122 :     /* We remove the bytes used by the fixed quantizer zones during first pass
1123 :     * with the same quants, so we know very precisely how much that
1124 :     * represents */
1125 :     target = rc->target;
1126 :     target -= rc->tot_quant;
1127 :    
1128 :     /* Let's compute a linear scaler in order to perform curve scaling */
1129 :     scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1130 :    
1131 :     #ifdef SMART_OVERFLOW_SETTING
1132 :     if (scaler > 0.9) {
1133 :     rc->param.max_overflow_degradation *= 5;
1134 :     rc->param.max_overflow_improvement *= 5;
1135 :     rc->param.overflow_control_strength *= 3;
1136 :     } else if (scaler > 0.6) {
1137 :     rc->param.max_overflow_degradation *= 2;
1138 :     rc->param.max_overflow_improvement *= 2;
1139 :     rc->param.overflow_control_strength *= 2;
1140 :     } else {
1141 :     rc->min_quant = 2;
1142 :     }
1143 :     #endif
1144 :    
1145 :     /* Compute min frame lengths (for each frame type) according to the number
1146 :     * of MBs. We sum all block type counters of frame 0, this gives us the
1147 :     * number of MBs.
1148 :     *
1149 :     * We compare these hardcoded values with observed values in first pass
1150 :     * (determined in pre_process0).Then we keep the real minimum. */
1151 :    
1152 :     /* Number of MBs */
1153 :     num_MBs = rc->stats[0].blks[0];
1154 :     num_MBs += rc->stats[0].blks[1];
1155 :     num_MBs += rc->stats[0].blks[2];
1156 :    
1157 :     /* Minimum for I frames */
1158 :     if(rc->min_length[XVID_TYPE_IVOP-1] > ((num_MBs*22) + 240) / 8)
1159 :     rc->min_length[XVID_TYPE_IVOP-1] = ((num_MBs*22) + 240) / 8;
1160 :    
1161 :     /* Minimum for P/S frames */
1162 :     if(rc->min_length[XVID_TYPE_PVOP-1] > ((num_MBs) + 88) / 8)
1163 :     rc->min_length[XVID_TYPE_PVOP-1] = ((num_MBs) + 88) / 8;
1164 :    
1165 :     /* Minimum for B frames */
1166 :     if(rc->min_length[XVID_TYPE_BVOP-1] > 8)
1167 :     rc->min_length[XVID_TYPE_BVOP-1] = 8;
1168 :    
1169 :     /* Perform an initial scale pass.
1170 :     *
1171 :     * If a frame size is scaled underneath our hardcoded minimums, then we
1172 :     * force the frame size to the minimum, and deduct the original & scaled
1173 :     * frame length from the original and target total lengths */
1174 :     for (i=0; i<rc->num_frames; i++) {
1175 :     twopass_stat_t * s = &rc->stats[i];
1176 :     int len;
1177 :    
1178 :     /* No need to scale frame length for which a specific quantizer is
1179 :     * specified thanks to zones */
1180 :     if (s->zone_mode == XVID_ZONE_QUANT) {
1181 :     s->scaled_length = s->length;
1182 :     continue;
1183 :     }
1184 :    
1185 :     /* Compute the scaled length -- only non invariant data length is scaled */
1186 :     len = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1187 :    
1188 :     /* Compare with the computed minimum */
1189 :     if (len < rc->min_length[s->type-1]) {
1190 :     /* This is a 'forced size' frame, set its frame size to the
1191 :     * computed minimum */
1192 :     s->scaled_length = rc->min_length[s->type-1];
1193 :    
1194 :     /* Remove both scaled and original size from their respective
1195 :     * total counters, as we prepare a second pass for 'regular'
1196 :     * frames */
1197 :     target -= s->scaled_length;
1198 :     } else {
1199 :     /* Do nothing for now, we'll scale this later */
1200 :     s->scaled_length = 0;
1201 :     }
1202 :     }
1203 :    
1204 :     /* The first pass on data substracted all 'forced size' frames from the
1205 :     * total counters. Now, it's possible to scale the 'regular' frames. */
1206 :    
1207 :     /* Scaling factor for 'regular' frames */
1208 :     scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1209 :    
1210 :     /* Do another pass with the new scaler */
1211 :     for (i=0; i<rc->num_frames; i++) {
1212 :     twopass_stat_t * s = &rc->stats[i];
1213 :    
1214 :     /* Ignore frame with forced frame sizes */
1215 :     if (s->scaled_length == 0)
1216 :     s->scaled_length = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1217 :     }
1218 :    
1219 :     /* Job done */
1220 :     return;
1221 :     }
1222 :    
1223 :     /* Apply all user settings to the scaled curve
1224 :     * This implies:
1225 :     * keyframe boosting
1226 :     * high/low compression */
1227 :     static void
1228 :     scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc)
1229 :     {
1230 :     int i;
1231 :     int64_t ivop_boost_total;
1232 :    
1233 :     /* Reset the rate controller (per frame type) total byte counters */
1234 :     for (i=0; i<3; i++) rc->tot_scaled_length[i] = 0;
1235 :    
1236 :     /* Compute total bytes for each frame type */
1237 :     for (i=0; i<rc->num_frames;i++) {
1238 :     twopass_stat_t *s = &rc->stats[i];
1239 :     rc->tot_scaled_length[s->type-1] += s->scaled_length;
1240 :     }
1241 :    
1242 :     /* First we compute the total amount of bits needed, as being described by
1243 :     * the scaled distribution. During this pass over the complete stats data,
1244 :     * we see how much bits two user settings will get/give from/to p&b frames:
1245 :     * - keyframe boosting
1246 :     * - keyframe distance penalty */
1247 :     rc->KF_idx = 0;
1248 :     ivop_boost_total = 0;
1249 :     for (i=0; i<rc->num_frames; i++) {
1250 :     twopass_stat_t * s = &rc->stats[i];
1251 :    
1252 :     /* Some more work is needed for I frames */
1253 :     if (s->type == XVID_TYPE_IVOP) {
1254 :     int ivop_boost;
1255 :    
1256 :     /* Accumulate bytes needed for keyframe boosting */
1257 :     ivop_boost = s->scaled_length*rc->param.keyframe_boost/100;
1258 :    
1259 :     #if 0 /* ToDo: decide how to apply kfthresholding */
1260 :     #endif
1261 :     /* If the frame size drops under the minimum length, then cap ivop_boost */
1262 :     if (ivop_boost + s->scaled_length < rc->min_length[XVID_TYPE_IVOP-1])
1263 :     ivop_boost = rc->min_length[XVID_TYPE_IVOP-1] - s->scaled_length;
1264 :    
1265 :     /* Accumulate the ivop boost */
1266 :     ivop_boost_total += ivop_boost;
1267 :    
1268 :     /* Don't forget to update the keyframe index */
1269 :     rc->KF_idx++;
1270 :     }
1271 :     }
1272 :    
1273 :     /* Initialize the IBoost tax ratio for P/S/B frames
1274 :     *
1275 :     * This ratio has to be applied to p/b/s frames in order to reserve
1276 :     * additional bits for keyframes (keyframe boosting) or if too much
1277 :     * keyframe distance is applied, bits retrieved from the keyframes.
1278 :     *
1279 :     * ie pb_length *= rc->pb_iboost_tax_ratio;
1280 :     *
1281 :     * gives the ideal length of a p/b frame */
1282 :    
1283 :     /* Compute the total length of p/b/s frames (temporary storage into
1284 :     * movie_curve) */
1285 :     rc->pb_iboost_tax_ratio = (double)rc->tot_scaled_length[XVID_TYPE_PVOP-1];
1286 :     rc->pb_iboost_tax_ratio += (double)rc->tot_scaled_length[XVID_TYPE_BVOP-1];
1287 :    
1288 :     /* Compute the ratio described above
1289 :     * taxed_total = sum(0, n, tax*scaled_length)
1290 :     * <=> taxed_total = tax.sum(0, n, scaled_length)
1291 :     * <=> tax = taxed_total / original_total */
1292 :     rc->pb_iboost_tax_ratio =
1293 :     (rc->pb_iboost_tax_ratio - ivop_boost_total) /
1294 :     rc->pb_iboost_tax_ratio;
1295 :    
1296 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- IFrame boost tax ratio:%.2f\n",
1297 :     rc->pb_iboost_tax_ratio);
1298 :    
1299 :     /* Compute the average size of frames per frame type */
1300 :     for(i=0; i<3; i++) {
1301 :     /* Special case for missing type or weird case */
1302 :     if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1303 :     rc->avg_length[i] = 1;
1304 :     } else {
1305 :     rc->avg_length[i] = rc->tot_scaled_length[i];
1306 :    
1307 :     if (i == (XVID_TYPE_IVOP-1)) {
1308 :     /* I Frames total has to be added the boost total */
1309 :     rc->avg_length[i] += ivop_boost_total;
1310 :     } else {
1311 :     /* P/B frames has to taxed */
1312 :     rc->avg_length[i] *= rc->pb_iboost_tax_ratio;
1313 :     }
1314 :    
1315 :     /* Finally compute the average frame size */
1316 :     rc->avg_length[i] /= (double)rc->count[i];
1317 :     }
1318 :     }
1319 :    
1320 :     /* Assymetric curve compression */
1321 :     if (rc->param.curve_compression_high || rc->param.curve_compression_low) {
1322 :     double symetric_total;
1323 :     double assymetric_delta_total;
1324 :    
1325 :     /* Like I frame boosting, assymetric curve compression modifies the total
1326 :     * amount of needed bits, we must compute the ratio so we can prescale
1327 :     lengths */
1328 :     symetric_total = 0;
1329 :     assymetric_delta_total = 0;
1330 :     for (i=0; i<rc->num_frames; i++) {
1331 :     double assymetric_delta;
1332 :     double dbytes;
1333 :     twopass_stat_t * s = &rc->stats[i];
1334 :    
1335 :     /* I Frames are not concerned by assymetric scaling */
1336 :     if (s->type == XVID_TYPE_IVOP)
1337 :     continue;
1338 :    
1339 :     /* During the real run, we would have to apply the iboost tax */
1340 :     dbytes = s->scaled_length * rc->pb_iboost_tax_ratio;
1341 :    
1342 :     /* Update the symmetric curve compression total */
1343 :     symetric_total += dbytes;
1344 :    
1345 :     /* Apply assymetric curve compression */
1346 :     if (dbytes > rc->avg_length[s->type-1])
1347 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_high / 100.0f;
1348 :     else
1349 :     assymetric_delta = (rc->avg_length[s->type-1] - dbytes) * (double)rc->param.curve_compression_low / 100.0f;
1350 :    
1351 :     /* Cap to the minimum frame size if needed */
1352 :     if (dbytes + assymetric_delta < rc->min_length[s->type-1])
1353 :     assymetric_delta = rc->min_length[s->type-1] - dbytes;
1354 :    
1355 :     /* Accumulate after assymetric curve compression */
1356 :     assymetric_delta_total += assymetric_delta;
1357 :     }
1358 :    
1359 :     /* Compute the tax that all p/b frames have to pay in order to respect the
1360 :     * bit distribution changes that the assymetric compression curve imposes
1361 :     * We want assymetric_total = sum(0, n-1, tax.scaled_length)
1362 :     * ie assymetric_total = ratio.sum(0, n-1, scaled_length)
1363 :     * ratio = assymetric_total / symmetric_total */
1364 :     rc->assymetric_tax_ratio = ((double)symetric_total - (double)assymetric_delta_total) / (double)symetric_total;
1365 :     } else {
1366 :     rc->assymetric_tax_ratio = 1.0f;
1367 :     }
1368 :    
1369 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Assymetric tax ratio:%.2f\n", rc->assymetric_tax_ratio);
1370 :    
1371 :     /* Last bits that need to be reset */
1372 :     rc->overflow = 0;
1373 :     rc->KFoverflow = 0;
1374 :     rc->KFoverflow_partial = 0;
1375 :     rc->KF_idx = 0;
1376 :     rc->desired_total = 0;
1377 :     rc->real_total = 0;
1378 :    
1379 :     /* Job done */
1380 :     return;
1381 :     }
1382 :    
1383 :     /*****************************************************************************
1384 :     * Still more low level stuff (nothing to do with stats treatment)
1385 :     ****************************************************************************/
1386 :    
1387 :     /* This function returns an allocated string containing a complete line read
1388 :     * from the file starting at the current position */
1389 :     static char *
1390 :     readline(FILE *f)
1391 :     {
1392 :     char *buffer = NULL;
1393 :     int buffer_size = 0;
1394 :     int pos = 0;
1395 :    
1396 :     do {
1397 :     int c;
1398 :    
1399 :     /* Read a character from the stream */
1400 :     c = fgetc(f);
1401 :    
1402 :     /* Is that EOF or new line ? */
1403 :     if(c == EOF || c == '\n')
1404 :     break;
1405 :    
1406 :     /* Do we have to update buffer ? */
1407 :     if(pos >= buffer_size - 1) {
1408 :     buffer_size += BUF_SZ;
1409 :     buffer = (char*)realloc(buffer, buffer_size);
1410 :     if (buffer == NULL)
1411 :     return(NULL);
1412 :     }
1413 :    
1414 :     buffer[pos] = c;
1415 :     pos++;
1416 :     } while(1);
1417 :    
1418 :     /* Read \n or EOF */
1419 :     if (buffer == NULL) {
1420 :     /* EOF, so we reached the end of the file, return NULL */
1421 :     if(feof(f))
1422 :     return(NULL);
1423 :    
1424 :     /* Just an empty line with just a newline, allocate a 1 byte buffer to
1425 :     * store a zero length string */
1426 :     buffer = (char*)malloc(1);
1427 :     if(buffer == NULL)
1428 :     return(NULL);
1429 :     }
1430 :    
1431 :     /* Zero terminated string */
1432 :     buffer[pos] = '\0';
1433 :    
1434 :     return(buffer);
1435 :     }
1436 :    
1437 :     /* This function returns a pointer to the first non space char in the given
1438 :     * string */
1439 :     static char *
1440 :     skipspaces(char *string)
1441 :     {
1442 :     const char spaces[] =
1443 :     {
1444 :     ' ','\t','\0'
1445 :     };
1446 :     const char *spacechar = spaces;
1447 :    
1448 :     if (string == NULL) return(NULL);
1449 :    
1450 :     while (*string != '\0') {
1451 :     /* Test against space chars */
1452 :     while (*spacechar != '\0') {
1453 :     if (*string == *spacechar) {
1454 :     string++;
1455 :     spacechar = spaces;
1456 :     break;
1457 :     }
1458 :     spacechar++;
1459 :     }
1460 :    
1461 :     /* No space char */
1462 :     if (*spacechar == '\0') return(string);
1463 :     }
1464 :    
1465 :     return(string);
1466 :     }
1467 :    
1468 :     /* This function returns a boolean that tells if the string is only a
1469 :     * comment */
1470 :     static int
1471 :     iscomment(char *string)
1472 :     {
1473 :     const char comments[] =
1474 :     {
1475 :     '#',';', '%', '\0'
1476 :     };
1477 :     const char *cmtchar = comments;
1478 :     int iscomment = 0;
1479 :    
1480 :     if (string == NULL) return(1);
1481 :    
1482 :     string = skipspaces(string);
1483 :    
1484 :     while(*cmtchar != '\0') {
1485 :     if(*string == *cmtchar) {
1486 :     iscomment = 1;
1487 :     break;
1488 :     }
1489 :     cmtchar++;
1490 :     }
1491 :    
1492 :     return(iscomment);
1493 :     }
1494 :    
1495 :     #if 0
1496 :     static void
1497 :     stats_print(rc_2pass2_t * rc)
1498 :     {
1499 :     int i;
1500 :     const char frame_type[4] = { 'i', 'p', 'b', 's'};
1501 :    
1502 :     for (i=0; i<rc->num_frames; i++) {
1503 :     twopass_stat_t *s = &rc->stats[i];
1504 :     DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- frame:%d type:%c quant:%d stats:%d scaled:%d desired:%d actual:%d overflow(%c):%.2f\n",
1505 :     i, frame_type[s->type-1], -1, s->length, s->scaled_length,
1506 :     s->desired_length, -1, frame_type[s->type-1], -1.0f);
1507 :     }
1508 :     }
1509 :     #endif

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