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

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