[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.1.2.37 - (view) (download)

1 : suxen_drol 1.1.2.1 /******************************************************************************
2 :     *
3 : edgomez 1.1.2.20 * XviD Bit Rate Controller Library
4 :     * - VBR 2 pass bitrate controller implementation -
5 : suxen_drol 1.1.2.1 *
6 : edgomez 1.1.2.20 * 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 : suxen_drol 1.1.2.1 *
28 : syskin 1.1.2.37 * $Id: plugin_2pass2.c,v 1.1.2.36 2004/01/22 20:54:31 edgomez Exp $
29 : suxen_drol 1.1.2.1 *
30 :     *****************************************************************************/
31 :    
32 : edgomez 1.1.2.31 #define BQUANT_PRESCALE
33 : edgomez 1.1.2.24 #undef COMPENSATE_FORMULA
34 :    
35 : syskin 1.1.2.32 /* forces second pass not to be bigger than first */
36 :     #undef PASS_SMALLER
37 :    
38 : syskin 1.1.2.37 /* 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 : suxen_drol 1.1.2.1 #include <stdio.h>
43 :     #include <math.h>
44 : edgomez 1.1.2.9 #include <limits.h>
45 : suxen_drol 1.1.2.1
46 : edgomez 1.1.2.11 #include "../xvid.h"
47 :     #include "../image/image.h"
48 :    
49 :     /*****************************************************************************
50 : edgomez 1.1.2.31 * Some default settings
51 : edgomez 1.1.2.11 ****************************************************************************/
52 :    
53 :     #define DEFAULT_KEYFRAME_BOOST 0
54 : edgomez 1.1.2.24 #define DEFAULT_OVERFLOW_CONTROL_STRENGTH 10
55 : edgomez 1.1.2.11 #define DEFAULT_CURVE_COMPRESSION_HIGH 0
56 :     #define DEFAULT_CURVE_COMPRESSION_LOW 0
57 : edgomez 1.1.2.31 #define DEFAULT_MAX_OVERFLOW_IMPROVEMENT 10
58 :     #define DEFAULT_MAX_OVERFLOW_DEGRADATION 10
59 : edgomez 1.1.2.11
60 :     /* Keyframe settings */
61 :     #define DEFAULT_KFREDUCTION 20
62 : edgomez 1.1.2.28 #define DEFAULT_KFTHRESHOLD 1
63 : edgomez 1.1.2.11
64 :     /*****************************************************************************
65 : edgomez 1.1.2.31 * 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 : edgomez 1.1.2.11 * Structures
76 :     ****************************************************************************/
77 : suxen_drol 1.1.2.1
78 : edgomez 1.1.2.11 /* Statistics */
79 : suxen_drol 1.1.2.1 typedef struct {
80 : edgomez 1.1.2.22 int type; /* first pass type */
81 :     int quant; /* first pass quant */
82 : edgomez 1.1.2.31 int blks[3]; /* k,m,y blks */
83 : edgomez 1.1.2.22 int length; /* first pass length */
84 : edgomez 1.1.2.31 int invariant; /* what we assume as being invariant between the two passes, it's a sub part of header + MV bits */
85 : edgomez 1.1.2.22 int scaled_length; /* scaled length */
86 : edgomez 1.1.2.24 int desired_length; /* desired length; calculated during encoding */
87 :     int error;
88 : suxen_drol 1.1.2.4
89 : edgomez 1.1.2.22 int zone_mode; /* XVID_ZONE_xxx */
90 :     double weight;
91 : edgomez 1.1.2.24 } twopass_stat_t;
92 : suxen_drol 1.1.2.1
93 : edgomez 1.1.2.11 /* Context struct */
94 : suxen_drol 1.1.2.1 typedef struct
95 :     {
96 : edgomez 1.1.2.22 xvid_plugin_2pass2_t param;
97 : suxen_drol 1.1.2.1
98 : edgomez 1.1.2.24 /*----------------------------------
99 :     * constant statistical data
100 :     *--------------------------------*/
101 :    
102 :     /* Number of frames of the sequence */
103 : suxen_drol 1.1.2.2 int num_frames;
104 : edgomez 1.1.2.24
105 :     /* Number of Intra frames of the sequence */
106 : edgomez 1.1.2.15 int num_keyframes;
107 : suxen_drol 1.1.2.4
108 : edgomez 1.1.2.24 /* Target filesize to reach */
109 :     uint64_t target;
110 :    
111 :     /* Count of each frame types */
112 :     int count[3];
113 : edgomez 1.1.2.15
114 : edgomez 1.1.2.24 /* Total length of each frame types (1st pass) */
115 :     uint64_t tot_length[3];
116 : edgomez 1.1.2.31 uint64_t tot_invariant[3];
117 : edgomez 1.1.2.24
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 : edgomez 1.1.2.31 uint64_t tot_quant;
141 :     uint64_t tot_quant_invariant;
142 : edgomez 1.1.2.24
143 : edgomez 1.1.2.34 /* Holds the total amount of frame bytes, zone weighted (only scalable
144 :     * part of frame bytes) */
145 :     uint64_t tot_weighted;
146 :    
147 : edgomez 1.1.2.24 /*----------------------------------
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 : edgomez 1.1.2.15 double quant_error[3][32];
187 : edgomez 1.1.2.24
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 : edgomez 1.1.2.15 int last_quant[3];
196 : suxen_drol 1.1.2.4
197 : edgomez 1.1.2.24 /*----------------------------------
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 : edgomez 1.1.2.15
211 : edgomez 1.1.2.24 /* Unknown ???
212 :     * ToDo: description */
213 : edgomez 1.1.2.15 double fq_error;
214 : edgomez 1.1.2.24
215 : syskin 1.1.2.37 int min_quant; /* internal minimal quant, prevents wrong quants from being used */
216 :    
217 : edgomez 1.1.2.24 /*----------------------------------
218 :     * Debug
219 :     *--------------------------------*/
220 :     double desired_total;
221 :     double real_total;
222 : suxen_drol 1.1.2.1 } rc_2pass2_t;
223 :    
224 :    
225 : edgomez 1.1.2.11 /*****************************************************************************
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 : suxen_drol 1.1.2.1
238 : edgomez 1.1.2.11 int
239 :     xvid_plugin_2pass2(void * handle, int opt, void * param1, void * param2)
240 : suxen_drol 1.1.2.1 {
241 : edgomez 1.1.2.22 switch(opt) {
242 :     case XVID_PLG_INFO :
243 : edgomez 1.1.2.27 case XVID_PLG_FRAME :
244 : edgomez 1.1.2.22 return 0;
245 : suxen_drol 1.1.2.1
246 : edgomez 1.1.2.22 case XVID_PLG_CREATE :
247 :     return rc_2pass2_create((xvid_plg_create_t*)param1, param2);
248 : suxen_drol 1.1.2.1
249 : edgomez 1.1.2.22 case XVID_PLG_DESTROY :
250 :     return rc_2pass2_destroy((rc_2pass2_t*)handle, (xvid_plg_destroy_t*)param1);
251 : suxen_drol 1.1.2.1
252 : edgomez 1.1.2.22 case XVID_PLG_BEFORE :
253 :     return rc_2pass2_before((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
254 : suxen_drol 1.1.2.1
255 : edgomez 1.1.2.22 case XVID_PLG_AFTER :
256 :     return rc_2pass2_after((rc_2pass2_t*)handle, (xvid_plg_data_t*)param1);
257 :     }
258 : suxen_drol 1.1.2.1
259 : edgomez 1.1.2.22 return XVID_ERR_FAIL;
260 : suxen_drol 1.1.2.1 }
261 :    
262 : edgomez 1.1.2.11 /*****************************************************************************
263 :     * Sub plugin functions definitions
264 :     ****************************************************************************/
265 :    
266 :     /* First a few local helping function prototypes */
267 : edgomez 1.1.2.24 static int statsfile_count_frames(rc_2pass2_t * rc, char * filename);
268 :     static int statsfile_load(rc_2pass2_t *rc, char * filename);
269 : edgomez 1.1.2.11 static void zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create);
270 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1
277 : edgomez 1.1.2.11 /*----------------------------------------------------------------------------
278 :     *--------------------------------------------------------------------------*/
279 : suxen_drol 1.1.2.1
280 : edgomez 1.1.2.11 static int
281 :     rc_2pass2_create(xvid_plg_create_t * create, rc_2pass2_t **handle)
282 : suxen_drol 1.1.2.2 {
283 : edgomez 1.1.2.22 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 : edgomez 1.1.2.23 if (rc == NULL)
289 : edgomez 1.1.2.22 return XVID_ERR_MEMORY;
290 : suxen_drol 1.1.2.2
291 : edgomez 1.1.2.22 rc->param = *param;
292 : suxen_drol 1.1.2.2
293 : edgomez 1.1.2.24 /* Initialize all defaults */
294 : edgomez 1.1.2.11 #define _INIT(a, b) if((a) <= 0) (a) = (b)
295 : edgomez 1.1.2.22 /* Let's set our defaults if needed */
296 : edgomez 1.1.2.11 _INIT(rc->param.keyframe_boost, DEFAULT_KEYFRAME_BOOST);
297 : edgomez 1.1.2.24 _INIT(rc->param.overflow_control_strength, DEFAULT_OVERFLOW_CONTROL_STRENGTH);
298 : edgomez 1.1.2.22 _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 : edgomez 1.1.2.11
303 : edgomez 1.1.2.22 /* Keyframe settings */
304 :     _INIT(rc->param.kfreduction, DEFAULT_KFREDUCTION);
305 : edgomez 1.1.2.28 _INIT(rc->param.kfthreshold, DEFAULT_KFTHRESHOLD);
306 : edgomez 1.1.2.11 #undef _INIT
307 : suxen_drol 1.1.2.2
308 : edgomez 1.1.2.15 /* Initialize some stuff to zero */
309 :     for(i=0; i<3; i++) {
310 :     int j;
311 : edgomez 1.1.2.24 for (j=0; j<32; j++) {
312 : edgomez 1.1.2.15 rc->quant_error[i][j] = 0;
313 : edgomez 1.1.2.24 rc->quant_count[i][j] = 0;
314 :     }
315 : edgomez 1.1.2.15 }
316 :    
317 : edgomez 1.1.2.24 for (i=0; i<3; i++) rc->last_quant[i] = 0;
318 : edgomez 1.1.2.15
319 :     rc->fq_error = 0;
320 : syskin 1.1.2.37 rc->min_quant = 1;
321 : edgomez 1.1.2.15
322 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.15 free(rc);
327 : edgomez 1.1.2.24 return(XVID_ERR_FAIL);
328 : edgomez 1.1.2.15 }
329 : edgomez 1.1.2.7
330 : edgomez 1.1.2.22 /* Allocate the stats' memory */
331 : edgomez 1.1.2.24 if ((rc->stats = malloc(rc->num_frames * sizeof(twopass_stat_t))) == NULL) {
332 : edgomez 1.1.2.22 free(rc);
333 : edgomez 1.1.2.24 return(XVID_ERR_MEMORY);
334 : edgomez 1.1.2.22 }
335 : edgomez 1.1.2.7
336 : edgomez 1.1.2.24 /* Allocate keyframes location's memory
337 :     * PS: see comment in pre_process0 for the +1 location requirement */
338 : edgomez 1.1.2.15 rc->keyframe_locations = malloc((rc->num_keyframes + 1) * sizeof(int));
339 :     if (rc->keyframe_locations == NULL) {
340 :     free(rc->stats);
341 :     free(rc);
342 : edgomez 1.1.2.24 return(XVID_ERR_MEMORY);
343 : edgomez 1.1.2.15 }
344 :    
345 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.15 free(rc->keyframe_locations);
349 :     free(rc->stats);
350 :     free(rc);
351 :     return XVID_ERR_FAIL;
352 :     }
353 : suxen_drol 1.1.2.2
354 : edgomez 1.1.2.15 /* Compute the target filesize */
355 : edgomez 1.1.2.22 if (rc->param.bitrate<0) {
356 :     /* if negative, bitrate equals the target (in kbytes) */
357 : edgomez 1.1.2.29 rc->target = ((uint64_t)(-rc->param.bitrate)) * 1024;
358 : edgomez 1.1.2.22 } else if (rc->num_frames < create->fbase/create->fincr) {
359 : edgomez 1.1.2.15 /* Source sequence is less than 1s long, we do as if it was 1s long */
360 :     rc->target = rc->param.bitrate / 8;
361 : edgomez 1.1.2.11 } else {
362 : edgomez 1.1.2.15 /* Target filesize = bitrate/8 * numframes / framerate */
363 : edgomez 1.1.2.23 rc->target =
364 : edgomez 1.1.2.15 ((uint64_t)rc->param.bitrate * (uint64_t)rc->num_frames * \
365 :     (uint64_t)create->fincr) / \
366 : edgomez 1.1.2.11 ((uint64_t)create->fbase * 8);
367 :     }
368 : suxen_drol 1.1.2.2
369 : edgomez 1.1.2.24 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Frame rate: %d/%d (%ffps)\n",
370 : edgomez 1.1.2.15 create->fbase, create->fincr,
371 :     (double)create->fbase/(double)create->fincr);
372 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1
377 : edgomez 1.1.2.15 /* Compensate the average frame overhead caused by the container */
378 : edgomez 1.1.2.11 rc->target -= rc->num_frames*rc->param.container_frame_overhead;
379 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1
383 : edgomez 1.1.2.34 /* 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 : edgomez 1.1.2.24 /* Gathers some information about first pass stats:
405 : edgomez 1.1.2.15 * - 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 : edgomez 1.1.2.31 * rc->tot_length[]
413 :     * - total bytes considered invariant between the 2 passes
414 : edgomez 1.1.2.15 * - store keyframe location
415 :     * rc->keyframe_locations[]
416 :     */
417 : edgomez 1.1.2.24 first_pass_stats_prepare_data(rc);
418 : suxen_drol 1.1.2.1
419 : edgomez 1.1.2.34 /* If we have a user bitrate, it means it's an internal curve scaling */
420 : edgomez 1.1.2.11 if (rc->param.bitrate) {
421 : edgomez 1.1.2.24 /* Perform internal curve scaling */
422 :     first_pass_scale_curve_internal(rc);
423 : edgomez 1.1.2.15 }
424 : suxen_drol 1.1.2.1
425 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.9
429 : edgomez 1.1.2.15 *handle = rc;
430 : edgomez 1.1.2.11 return(0);
431 :     }
432 : suxen_drol 1.1.2.1
433 : edgomez 1.1.2.11 /*----------------------------------------------------------------------------
434 :     *--------------------------------------------------------------------------*/
435 : suxen_drol 1.1.2.1
436 : edgomez 1.1.2.11 static int
437 :     rc_2pass2_destroy(rc_2pass2_t * rc, xvid_plg_destroy_t * destroy)
438 :     {
439 : edgomez 1.1.2.24 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 : edgomez 1.1.2.22 free(rc->keyframe_locations);
447 :     free(rc->stats);
448 : edgomez 1.1.2.11 free(rc);
449 :     return(0);
450 :     }
451 : suxen_drol 1.1.2.1
452 : edgomez 1.1.2.11 /*----------------------------------------------------------------------------
453 :     *--------------------------------------------------------------------------*/
454 :    
455 :     static int
456 :     rc_2pass2_before(rc_2pass2_t * rc, xvid_plg_data_t * data)
457 :     {
458 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[data->frame_num];
459 : edgomez 1.1.2.15 double dbytes;
460 :     double scaled_quant;
461 : edgomez 1.1.2.24 double overflow;
462 : edgomez 1.1.2.15 int capped_to_max_framesize = 0;
463 : edgomez 1.1.2.7
464 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.9
467 : edgomez 1.1.2.11 /* First case: Another plugin has already set a quantizer */
468 : edgomez 1.1.2.22 if (data->quant > 0)
469 : edgomez 1.1.2.11 return(0);
470 : suxen_drol 1.1.2.2
471 : edgomez 1.1.2.33 /* Second case: insufficent stats data
472 :     * We can't guess much what we should do, let core decide all alone */
473 : syskin 1.1.2.30 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 : edgomez 1.1.2.33 /* 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 : edgomez 1.1.2.11 if (s->zone_mode == XVID_ZONE_QUANT) {
483 : edgomez 1.1.2.33 /* Quant stuff */
484 : edgomez 1.1.2.11 rc->fq_error += s->weight;
485 :     data->quant = (int)rc->fq_error;
486 :     rc->fq_error -= data->quant;
487 : edgomez 1.1.2.22
488 : edgomez 1.1.2.33 /* 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 : edgomez 1.1.2.11 s->desired_length = s->length;
494 : suxen_drol 1.1.2.4
495 : edgomez 1.1.2.11 return(0);
496 :     }
497 : suxen_drol 1.1.2.4
498 :    
499 : edgomez 1.1.2.24 /*************************************************************************/
500 :     /*************************************************************************/
501 :     /*************************************************************************/
502 : suxen_drol 1.1.2.4
503 : edgomez 1.1.2.24 /*-------------------------------------------------------------------------
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 : suxen_drol 1.1.2.4
510 : edgomez 1.1.2.24 /* Set desired to what we are wanting to obtain for this frame */
511 :     dbytes = (double)s->scaled_length;
512 : suxen_drol 1.1.2.4
513 : edgomez 1.1.2.24 /* 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 : suxen_drol 1.1.2.4
518 : edgomez 1.1.2.28 #if 0 /* ToDo: decide how to apply kfthresholding */
519 :     #endif
520 : edgomez 1.1.2.11 } else {
521 : suxen_drol 1.1.2.4
522 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.11 }
544 :     }
545 : suxen_drol 1.1.2.2
546 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22
552 : edgomez 1.1.2.24 /*------------------------------------------------------------------------
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 : syskin 1.1.2.32 if (s->type != XVID_TYPE_IVOP || rc->overflow > 0) {
562 : edgomez 1.1.2.24 double frametype_factor;
563 :     double framesize_factor;
564 : suxen_drol 1.1.2.2
565 : edgomez 1.1.2.24 /* Take only the desired part of overflow */
566 :     overflow = rc->overflow;
567 : suxen_drol 1.1.2.2
568 : edgomez 1.1.2.24 /* 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 : suxen_drol 1.1.2.1
582 : edgomez 1.1.2.24 /* 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 : suxen_drol 1.1.2.1
589 : edgomez 1.1.2.24 /* Apply the overflow strength imposed by the user */
590 :     overflow *= (rc->param.overflow_control_strength/100.0f);
591 :     } else {
592 : syskin 1.1.2.32 /* no negative overflow applied in IFrames because:
593 : edgomez 1.1.2.24 * - 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 : edgomez 1.1.2.11 }
599 : suxen_drol 1.1.2.1
600 : edgomez 1.1.2.24 /* Make sure we are not trying to compensate more overflow than we even have */
601 :     if (fabs(overflow) > fabs(rc->overflow))
602 : edgomez 1.1.2.11 overflow = rc->overflow;
603 : suxen_drol 1.1.2.1
604 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.11 } else {
614 : edgomez 1.1.2.24 dbytes += overflow;
615 : edgomez 1.1.2.11 }
616 : suxen_drol 1.1.2.1
617 : edgomez 1.1.2.24 /*-------------------------------------------------------------------------
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 : syskin 1.1.2.32 #ifdef PASS_SMALLER
625 : edgomez 1.1.2.24 if (dbytes > s->length) {
626 :     dbytes = s->length;
627 : edgomez 1.1.2.11 }
628 : syskin 1.1.2.35 #endif
629 : edgomez 1.1.2.36
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 : edgomez 1.1.2.24 /*------------------------------------------------------------------------
636 :     * Desired frame length <-> quantizer mapping
637 :     *-----------------------------------------------------------------------*/
638 :    
639 : edgomez 1.1.2.31 #ifdef BQUANT_PRESCALE
640 :     /* For bframes we prescale the quantizer to avoid too high quant scaling */
641 : edgomez 1.1.2.24 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 : edgomez 1.1.2.26 s->quant = 2*(100*s->quant - data->bquant_offset);
651 : edgomez 1.1.2.31 s->quant += data->bquant_ratio - 1; /* to avoid rounding issues */
652 : edgomez 1.1.2.24 s->quant = s->quant/data->bquant_ratio - b_ref->quant;
653 :     }
654 : edgomez 1.1.2.31 #endif
655 : edgomez 1.1.2.24
656 : edgomez 1.1.2.31 /* Don't laugh at this very 'simple' quant<->size relationship, it
657 : edgomez 1.1.2.24 * 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 : edgomez 1.1.2.11 }
677 : edgomez 1.1.2.24 #endif
678 : suxen_drol 1.1.2.1
679 : edgomez 1.1.2.24 /* Quantizer has been scaled using floating point operations/results, we
680 :     * must cast it to integer */
681 : edgomez 1.1.2.15 data->quant = (int)scaled_quant;
682 : suxen_drol 1.1.2.1
683 : edgomez 1.1.2.11 /* 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 : edgomez 1.1.2.24 } else {
689 : suxen_drol 1.1.2.1
690 : edgomez 1.1.2.24 /* The frame quantizer has not been clipped, this appears to be a good
691 : edgomez 1.1.2.15 * computed quantizer, do not loose quantizer decimal part that we
692 : edgomez 1.1.2.24 * accumulate for later reuse when its sum represents a complete
693 :     * unit. */
694 : edgomez 1.1.2.15 rc->quant_error[s->type-1][data->quant] += scaled_quant - (double)data->quant;
695 : suxen_drol 1.1.2.1
696 : edgomez 1.1.2.15 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 : edgomez 1.1.2.11 }
703 :     }
704 : suxen_drol 1.1.2.1
705 : edgomez 1.1.2.24 /* Now we have a computed quant that is in the right quante range, with a
706 : edgomez 1.1.2.11 * 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 : edgomez 1.1.2.24 * that's why we don't perform this clipping earlier. */
711 : edgomez 1.1.2.11 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 : suxen_drol 1.1.2.1
717 : syskin 1.1.2.37 if (data->quant < rc->min_quant) data->quant = rc->min_quant;
718 :    
719 : edgomez 1.1.2.24 /* To avoid big quality jumps from frame to frame, we apply a "security"
720 : edgomez 1.1.2.11 * rule that makes |last_quant - new_quant| <= 2. This rule only applies
721 : edgomez 1.1.2.24 * to predicted frames (P and B) */
722 : edgomez 1.1.2.11 if (s->type != XVID_TYPE_IVOP && rc->last_quant[s->type-1] && capped_to_max_framesize == 0) {
723 : suxen_drol 1.1.2.1
724 : edgomez 1.1.2.11 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 : edgomez 1.1.2.24 "[xvid rc] -- frame %d p/b-frame quantizer prevented from rising too steeply\n",
728 : edgomez 1.1.2.11 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 : edgomez 1.1.2.24 "[xvid rc] -- frame:%d p/b-frame quantizer prevented from falling too steeply\n",
734 : edgomez 1.1.2.11 data->frame_num);
735 :     }
736 :     }
737 : suxen_drol 1.1.2.1
738 : edgomez 1.1.2.24 /* We don't want to pollute the RC histerisis when our computed quant has
739 :     * been computed from a capped frame size */
740 : edgomez 1.1.2.13 if (capped_to_max_framesize == 0)
741 : edgomez 1.1.2.11 rc->last_quant[s->type-1] = data->quant;
742 : edgomez 1.1.2.17
743 : edgomez 1.1.2.24 /* Don't forget to force 1st pass frame type ;-) */
744 : edgomez 1.1.2.17 data->type = s->type;
745 : suxen_drol 1.1.2.1
746 : edgomez 1.1.2.11 return 0;
747 :     }
748 : suxen_drol 1.1.2.1
749 : edgomez 1.1.2.11 /*----------------------------------------------------------------------------
750 :     *--------------------------------------------------------------------------*/
751 : suxen_drol 1.1.2.1
752 : edgomez 1.1.2.11 static int
753 :     rc_2pass2_after(rc_2pass2_t * rc, xvid_plg_data_t * data)
754 :     {
755 : edgomez 1.1.2.12 const char frame_type[4] = { 'i', 'p', 'b', 's'};
756 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[data->frame_num];
757 : suxen_drol 1.1.2.1
758 : edgomez 1.1.2.11 /* Insufficent stats data */
759 : edgomez 1.1.2.22 if (data->frame_num >= rc->num_frames)
760 :     return 0;
761 :    
762 : edgomez 1.1.2.24 /* Update the quantizer counter */
763 :     rc->quant_count[s->type-1][data->quant]++;
764 : suxen_drol 1.1.2.1
765 : edgomez 1.1.2.24 /* Update the frame type overflow */
766 : edgomez 1.1.2.22 if (data->type == XVID_TYPE_IVOP) {
767 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1
774 : edgomez 1.1.2.24 /* Flush Keyframe overflow accumulator */
775 : edgomez 1.1.2.22 rc->overflow += rc->KFoverflow;
776 : edgomez 1.1.2.24
777 :     /* Store the frame overflow to the keyframe accumulator */
778 : edgomez 1.1.2.22 rc->KFoverflow = s->desired_length - data->length;
779 : suxen_drol 1.1.2.1
780 : edgomez 1.1.2.24 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 : edgomez 1.1.2.22 rc->KFoverflow_partial = rc->KFoverflow / (kfdiff - 1);
786 : edgomez 1.1.2.24 } else {
787 :     /* Consecutive keyframes case:
788 :     * Flush immediatly the keyframe overflow and reset keyframe
789 :     * overflow */
790 : edgomez 1.1.2.11 rc->overflow += rc->KFoverflow;
791 :     rc->KFoverflow = 0;
792 :     rc->KFoverflow_partial = 0;
793 : edgomez 1.1.2.22 }
794 :     rc->KF_idx++;
795 :     } else {
796 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22 rc->KFoverflow -= rc->KFoverflow_partial;
805 :     }
806 : suxen_drol 1.1.2.1
807 : edgomez 1.1.2.31 rc->overflow += (s->error = s->desired_length - data->length);
808 : edgomez 1.1.2.24 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 : edgomez 1.1.2.11 data->frame_num,
812 : edgomez 1.1.2.12 frame_type[data->type-1],
813 : edgomez 1.1.2.11 data->quant,
814 :     s->length,
815 :     s->scaled_length,
816 : edgomez 1.1.2.15 s->desired_length,
817 : edgomez 1.1.2.24 s->desired_length - s->error,
818 :     -s->error,
819 : edgomez 1.1.2.11 rc->overflow);
820 : suxen_drol 1.1.2.1
821 : edgomez 1.1.2.22 return(0);
822 : suxen_drol 1.1.2.1 }
823 :    
824 : edgomez 1.1.2.11 /*****************************************************************************
825 :     * Helper functions definition
826 :     ****************************************************************************/
827 : suxen_drol 1.1.2.1
828 : edgomez 1.1.2.24 /* Default buffer size for reading lines */
829 : edgomez 1.1.2.11 #define BUF_SZ 1024
830 : suxen_drol 1.1.2.1
831 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.11 static int
839 : edgomez 1.1.2.24 statsfile_count_frames(rc_2pass2_t * rc, char * filename)
840 : suxen_drol 1.1.2.1 {
841 : edgomez 1.1.2.22 FILE * f;
842 : edgomez 1.1.2.24 char *line;
843 :     int lines;
844 : suxen_drol 1.1.2.1
845 : edgomez 1.1.2.22 rc->num_frames = 0;
846 :     rc->num_keyframes = 0;
847 : suxen_drol 1.1.2.1
848 : edgomez 1.1.2.24 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 : edgomez 1.1.2.25 int fields;
857 : edgomez 1.1.2.24
858 :     lines++;
859 :    
860 :     /* We skip spaces */
861 :     ptr = skipspaces(line);
862 : edgomez 1.1.2.22
863 : edgomez 1.1.2.25 /* Skip coment lines or empty lines */
864 :     if(iscomment(ptr) || *ptr == '\0') {
865 : edgomez 1.1.2.24 free(line);
866 :     continue;
867 :     }
868 :    
869 :     /* Read the stat line from buffer */
870 : edgomez 1.1.2.25 fields = sscanf(ptr, "%c", &type);
871 : edgomez 1.1.2.24
872 : edgomez 1.1.2.31 /* Valid stats files have at least 7 fields */
873 : edgomez 1.1.2.25 if (fields == 1) {
874 : edgomez 1.1.2.24 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 : edgomez 1.1.2.31 lines, 7-fields);
895 : edgomez 1.1.2.22 }
896 : edgomez 1.1.2.24
897 :     /* Free the line buffer */
898 :     free(line);
899 : edgomez 1.1.2.22 }
900 :    
901 : edgomez 1.1.2.24 /* We are done with the file */
902 : edgomez 1.1.2.22 fclose(f);
903 :    
904 : edgomez 1.1.2.24 return(0);
905 : edgomez 1.1.2.11 }
906 : suxen_drol 1.1.2.2
907 : edgomez 1.1.2.11 /* open stats file(s) and read into rc->stats array */
908 :     static int
909 : edgomez 1.1.2.24 statsfile_load(rc_2pass2_t *rc, char * filename)
910 : edgomez 1.1.2.11 {
911 : edgomez 1.1.2.22 FILE * f;
912 : edgomez 1.1.2.24 int processed_entries;
913 : edgomez 1.1.2.22
914 : edgomez 1.1.2.24 /* Opens the file */
915 :     if ((f = fopen(filename, "rb"))==NULL)
916 :     return(-1);
917 : edgomez 1.1.2.22
918 : edgomez 1.1.2.24 processed_entries = 0;
919 :     while(processed_entries < rc->num_frames) {
920 : edgomez 1.1.2.22 char type;
921 : edgomez 1.1.2.24 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 : edgomez 1.1.2.25 /* Skip comment lines or empty lines */
933 :     if(iscomment(ptr) || *ptr == '\0') {
934 : edgomez 1.1.2.24 free(line);
935 :     continue;
936 :     }
937 : suxen_drol 1.1.2.2
938 : edgomez 1.1.2.24 /* Reset this field that is optional */
939 : edgomez 1.1.2.11 s->scaled_length = 0;
940 : edgomez 1.1.2.6
941 : edgomez 1.1.2.24 /* Convert the fields */
942 :     fields = sscanf(ptr,
943 : edgomez 1.1.2.31 "%c %d %d %d %d %d %d %d\n",
944 : edgomez 1.1.2.24 &type,
945 :     &s->quant,
946 :     &s->blks[0], &s->blks[1], &s->blks[2],
947 : edgomez 1.1.2.31 &s->length, &s->invariant /* not really yet */,
948 : edgomez 1.1.2.24 &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 : edgomez 1.1.2.31 if(fields != 7 && fields != 8)
956 : edgomez 1.1.2.24 continue;
957 :    
958 : edgomez 1.1.2.31 /* Convert frame type and compute the invariant length part */
959 : edgomez 1.1.2.24 switch(type) {
960 :     case 'i':
961 :     case 'I':
962 : edgomez 1.1.2.22 s->type = XVID_TYPE_IVOP;
963 : edgomez 1.1.2.31 s->invariant /= INVARIANT_HEADER_PART_IVOP;
964 : edgomez 1.1.2.24 break;
965 :     case 'p':
966 :     case 'P':
967 :     case 's':
968 :     case 'S':
969 : edgomez 1.1.2.22 s->type = XVID_TYPE_PVOP;
970 : edgomez 1.1.2.31 s->invariant /= INVARIANT_HEADER_PART_PVOP;
971 : edgomez 1.1.2.24 break;
972 :     case 'b':
973 :     case 'B':
974 : edgomez 1.1.2.22 s->type = XVID_TYPE_BVOP;
975 : edgomez 1.1.2.31 s->invariant /= INVARIANT_HEADER_PART_BVOP;
976 : edgomez 1.1.2.24 break;
977 :     default:
978 :     /* Same as before, fail silently */
979 :     continue;
980 : edgomez 1.1.2.22 }
981 : suxen_drol 1.1.2.4
982 : edgomez 1.1.2.24 /* Ok it seems it's been processed correctly */
983 :     processed_entries++;
984 : edgomez 1.1.2.22 }
985 : suxen_drol 1.1.2.4
986 : edgomez 1.1.2.24 /* Close the file */
987 : edgomez 1.1.2.11 fclose(f);
988 : suxen_drol 1.1.2.1
989 : edgomez 1.1.2.24 return(0);
990 : suxen_drol 1.1.2.1 }
991 :    
992 : edgomez 1.1.2.23 /* pre-process the statistics data
993 : edgomez 1.1.2.24 * - for each type, count, tot_length, min_length, max_length
994 : edgomez 1.1.2.34 * - set keyframes_locations, tot_prescaled */
995 : edgomez 1.1.2.11 static void
996 : edgomez 1.1.2.24 first_pass_stats_prepare_data(rc_2pass2_t * rc)
997 : suxen_drol 1.1.2.1 {
998 : edgomez 1.1.2.22 int i,j;
999 : edgomez 1.1.2.7
1000 : edgomez 1.1.2.24 /* *rc fields initialization
1001 : edgomez 1.1.2.15 * NB: INT_MAX and INT_MIN are used in order to be immediately replaced
1002 : edgomez 1.1.2.24 * with real values of the 1pass */
1003 : edgomez 1.1.2.22 for (i=0; i<3; i++) {
1004 : edgomez 1.1.2.15 rc->count[i]=0;
1005 :     rc->tot_length[i] = 0;
1006 : edgomez 1.1.2.31 rc->tot_invariant[i] = 0;
1007 : edgomez 1.1.2.11 rc->min_length[i] = INT_MAX;
1008 : edgomez 1.1.2.22 }
1009 : edgomez 1.1.2.7
1010 : edgomez 1.1.2.11 rc->max_length = INT_MIN;
1011 : edgomez 1.1.2.34 rc->tot_weighted = 0;
1012 : edgomez 1.1.2.7
1013 : edgomez 1.1.2.24 /* Loop through all frames and find/compute all the stuff this function
1014 :     * is supposed to do */
1015 : edgomez 1.1.2.15 for (i=j=0; i<rc->num_frames; i++) {
1016 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[i];
1017 : suxen_drol 1.1.2.1
1018 : edgomez 1.1.2.15 rc->count[s->type-1]++;
1019 :     rc->tot_length[s->type-1] += s->length;
1020 : edgomez 1.1.2.31 rc->tot_invariant[s->type-1] += s->invariant;
1021 : edgomez 1.1.2.34 if (s->zone_mode != XVID_ZONE_QUANT)
1022 :     rc->tot_weighted += (int)(s->weight*(s->length - s->invariant));
1023 : suxen_drol 1.1.2.1
1024 : edgomez 1.1.2.15 if (s->length < rc->min_length[s->type-1]) {
1025 :     rc->min_length[s->type-1] = s->length;
1026 :     }
1027 : suxen_drol 1.1.2.1
1028 : edgomez 1.1.2.15 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 : edgomez 1.1.2.7
1038 : edgomez 1.1.2.24 /* NB:
1039 : edgomez 1.1.2.11 * 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 : edgomez 1.1.2.24 * frame to appear in the keyframe locations array. */
1043 : edgomez 1.1.2.22 rc->keyframe_locations[j] = i;
1044 : edgomez 1.1.2.7
1045 : edgomez 1.1.2.24 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 : edgomez 1.1.2.11 }
1049 : edgomez 1.1.2.22
1050 : edgomez 1.1.2.11 /* calculate zone weight "center" */
1051 :     static void
1052 :     zone_process(rc_2pass2_t *rc, const xvid_plg_create_t * create)
1053 :     {
1054 : edgomez 1.1.2.22 int i,j;
1055 :     int n = 0;
1056 :    
1057 :     rc->tot_quant = 0;
1058 : edgomez 1.1.2.31 rc->tot_quant_invariant = 0;
1059 : suxen_drol 1.1.2.5
1060 : edgomez 1.1.2.22 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 : suxen_drol 1.1.2.1
1073 : edgomez 1.1.2.34 /* 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 : edgomez 1.1.2.22 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 : suxen_drol 1.1.2.1
1086 : edgomez 1.1.2.22 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 : edgomez 1.1.2.31 } else{ /* XVID_ZONE_QUANT */
1094 : edgomez 1.1.2.22 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 : edgomez 1.1.2.31 rc->tot_quant_invariant += rc->stats[j].invariant;
1099 : edgomez 1.1.2.22 }
1100 :     }
1101 :     }
1102 : edgomez 1.1.2.11 }
1103 : suxen_drol 1.1.2.1
1104 :    
1105 : edgomez 1.1.2.11 /* scale the curve */
1106 :     static void
1107 : edgomez 1.1.2.24 first_pass_scale_curve_internal(rc_2pass2_t *rc)
1108 : edgomez 1.1.2.11 {
1109 : edgomez 1.1.2.24 int64_t target;
1110 : edgomez 1.1.2.31 int64_t total_invariant;
1111 : edgomez 1.1.2.11 double scaler;
1112 : edgomez 1.1.2.14 int i, num_MBs;
1113 : suxen_drol 1.1.2.1
1114 : edgomez 1.1.2.31 /* 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 : edgomez 1.1.2.24
1128 : edgomez 1.1.2.11 /* Let's compute a linear scaler in order to perform curve scaling */
1129 : edgomez 1.1.2.34 scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1130 : syskin 1.1.2.37
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 : edgomez 1.1.2.33
1145 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.16 *
1149 :     * We compare these hardcoded values with observed values in first pass
1150 : edgomez 1.1.2.24 * (determined in pre_process0).Then we keep the real minimum. */
1151 : edgomez 1.1.2.16
1152 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.16
1169 : edgomez 1.1.2.24 /* Perform an initial scale pass.
1170 :     *
1171 : edgomez 1.1.2.11 * 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 : edgomez 1.1.2.24 * frame length from the original and target total lengths */
1174 : edgomez 1.1.2.11 for (i=0; i<rc->num_frames; i++) {
1175 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[i];
1176 : edgomez 1.1.2.11 int len;
1177 : suxen_drol 1.1.2.1
1178 : edgomez 1.1.2.24 /* No need to scale frame length for which a specific quantizer is
1179 :     * specified thanks to zones */
1180 : edgomez 1.1.2.22 if (s->zone_mode == XVID_ZONE_QUANT) {
1181 :     s->scaled_length = s->length;
1182 : edgomez 1.1.2.11 continue;
1183 : edgomez 1.1.2.7 }
1184 : suxen_drol 1.1.2.1
1185 : edgomez 1.1.2.31 /* Compute the scaled length -- only non invariant data length is scaled */
1186 : edgomez 1.1.2.34 len = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1187 : edgomez 1.1.2.7
1188 : edgomez 1.1.2.11 /* Compare with the computed minimum */
1189 : edgomez 1.1.2.16 if (len < rc->min_length[s->type-1]) {
1190 : edgomez 1.1.2.24 /* This is a 'forced size' frame, set its frame size to the
1191 :     * computed minimum */
1192 : edgomez 1.1.2.16 s->scaled_length = rc->min_length[s->type-1];
1193 : edgomez 1.1.2.24
1194 :     /* Remove both scaled and original size from their respective
1195 :     * total counters, as we prepare a second pass for 'regular'
1196 :     * frames */
1197 : edgomez 1.1.2.11 target -= s->scaled_length;
1198 :     } else {
1199 :     /* Do nothing for now, we'll scale this later */
1200 :     s->scaled_length = 0;
1201 : edgomez 1.1.2.7 }
1202 :     }
1203 : suxen_drol 1.1.2.1
1204 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.34 scaler = (double)(target - total_invariant) / (double)(rc->tot_weighted);
1209 : suxen_drol 1.1.2.1
1210 : edgomez 1.1.2.11 /* Do another pass with the new scaler */
1211 :     for (i=0; i<rc->num_frames; i++) {
1212 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[i];
1213 : suxen_drol 1.1.2.4
1214 : edgomez 1.1.2.11 /* Ignore frame with forced frame sizes */
1215 :     if (s->scaled_length == 0)
1216 : edgomez 1.1.2.34 s->scaled_length = s->invariant + (int)((double)(s->length-s->invariant) * scaler * s->weight);
1217 : edgomez 1.1.2.11 }
1218 : edgomez 1.1.2.24
1219 :     /* Job done */
1220 :     return;
1221 : edgomez 1.1.2.11 }
1222 : suxen_drol 1.1.2.1
1223 : edgomez 1.1.2.24 /* Apply all user settings to the scaled curve
1224 :     * This implies:
1225 :     * keyframe boosting
1226 :     * high/low compression */
1227 : edgomez 1.1.2.11 static void
1228 : edgomez 1.1.2.24 scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc)
1229 : edgomez 1.1.2.11 {
1230 : edgomez 1.1.2.22 int i;
1231 : edgomez 1.1.2.28 int64_t ivop_boost_total;
1232 : edgomez 1.1.2.22
1233 : edgomez 1.1.2.24 /* Reset the rate controller (per frame type) total byte counters */
1234 :     for (i=0; i<3; i++) rc->tot_scaled_length[i] = 0;
1235 : edgomez 1.1.2.22
1236 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22 }
1241 :    
1242 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22 for (i=0; i<rc->num_frames; i++) {
1250 : edgomez 1.1.2.24 twopass_stat_t * s = &rc->stats[i];
1251 : edgomez 1.1.2.22
1252 : edgomez 1.1.2.24 /* Some more work is needed for I frames */
1253 : edgomez 1.1.2.22 if (s->type == XVID_TYPE_IVOP) {
1254 : edgomez 1.1.2.24 int ivop_boost;
1255 :    
1256 :     /* Accumulate bytes needed for keyframe boosting */
1257 :     ivop_boost = s->scaled_length*rc->param.keyframe_boost/100;
1258 :    
1259 : edgomez 1.1.2.28 #if 0 /* ToDo: decide how to apply kfthresholding */
1260 :     #endif
1261 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22 }
1271 :     }
1272 :    
1273 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.28 * <=> taxed_total = tax.sum(0, n, scaled_length)
1291 : edgomez 1.1.2.24 * <=> 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 : edgomez 1.1.2.22
1296 : edgomez 1.1.2.24 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 : edgomez 1.1.2.22 for(i=0; i<3; i++) {
1301 : edgomez 1.1.2.24 /* Special case for missing type or weird case */
1302 :     if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1303 : edgomez 1.1.2.22 rc->avg_length[i] = 1;
1304 : edgomez 1.1.2.24 } else {
1305 :     rc->avg_length[i] = rc->tot_scaled_length[i];
1306 :    
1307 : edgomez 1.1.2.25 if (i == (XVID_TYPE_IVOP-1)) {
1308 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22 }
1318 :     }
1319 :    
1320 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22
1369 : edgomez 1.1.2.24 DPRINTF(XVID_DEBUG_RC, "[xvid rc] -- Assymetric tax ratio:%.2f\n", rc->assymetric_tax_ratio);
1370 : edgomez 1.1.2.22
1371 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.22
1379 : edgomez 1.1.2.24 /* Job done */
1380 :     return;
1381 :     }
1382 : edgomez 1.1.2.22
1383 : edgomez 1.1.2.24 /*****************************************************************************
1384 :     * Still more low level stuff (nothing to do with stats treatment)
1385 :     ****************************************************************************/
1386 : suxen_drol 1.1.2.1
1387 : edgomez 1.1.2.24 /* 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 : edgomez 1.1.2.13 }
1458 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1
1482 : edgomez 1.1.2.24 string = skipspaces(string);
1483 : edgomez 1.1.2.18
1484 : edgomez 1.1.2.24 while(*cmtchar != '\0') {
1485 :     if(*string == *cmtchar) {
1486 :     iscomment = 1;
1487 :     break;
1488 : edgomez 1.1.2.22 }
1489 : edgomez 1.1.2.24 cmtchar++;
1490 : edgomez 1.1.2.22 }
1491 : suxen_drol 1.1.2.1
1492 : edgomez 1.1.2.24 return(iscomment);
1493 :     }
1494 : suxen_drol 1.1.2.1
1495 : edgomez 1.1.2.24 #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 : suxen_drol 1.1.2.1
1502 : edgomez 1.1.2.24 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 : suxen_drol 1.1.2.1 }
1509 : edgomez 1.1.2.24 #endif

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