[svn] / branches / dev-api-4 / xvidcore / src / plugins / plugin_2pass2.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/src/plugins/plugin_2pass2.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1267 - (view) (download)

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

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