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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.2.38, Sun May 9 14:00:35 2004 UTC revision 1.11, Tue Dec 28 19:19:43 2010 UTC
# Line 1  Line 1 
1  /******************************************************************************  /******************************************************************************
2   *   *
3   *  XviD Bit Rate Controller Library   *  Xvid Bit Rate Controller Library
4   *  - VBR 2 pass bitrate controller implementation -   *  - VBR 2 pass bitrate controller implementation -
5   *   *
6   *  Copyright (C)      2002 Foxer <email?>   *  Copyright (C)      2002 Benjamin Lambert <foxer@hotmail.com>
7   *                     2002 Dirk Knop <dknop@gwdg.de>   *                     2002 Dirk Knop <dknop@gwdg.de>
8   *                2002-2003 Edouard Gomez <ed.gomez@free.fr>   *                2002-2003 Edouard Gomez <ed.gomez@free.fr>
9   *                     2003 Pete Ross <pross@xvid.org>   *                     2003 Pete Ross <pross@xvid.org>
10   *   *
11   *  This curve treatment algorithm is the one originally implemented by Foxer   *  This curve treatment algorithm is the one originally implemented by Foxer
12   *  and tuned by Dirk Knop for the XviD vfw frontend.   *  and tuned by Dirk Knop for the Xvid vfw frontend.
13   *   *
14   *  This program is free software; you can redistribute it and/or modify   *  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   *  it under the terms of the GNU General Public License as published by
# Line 35  Line 35 
35  /* forces second pass not to be bigger than first */  /* forces second pass not to be bigger than first */
36  #undef PASS_SMALLER  #undef PASS_SMALLER
37    
38  /* automtically alters overflow controls (strength and improvement/degradation)  /* automatically alters overflow controls (strength and improvement/degradation)
39          to fight most common problems without user's knowladge */          to fight most common problems without user's knowladge */
40  #define SMART_OVERFLOW_SETTING  #define SMART_OVERFLOW_SETTING
41    
# Line 219  Line 219 
219           *--------------------------------*/           *--------------------------------*/
220          double desired_total;          double desired_total;
221          double real_total;          double real_total;
222    
223            int scaled_frames;
224  } rc_2pass2_t;  } rc_2pass2_t;
225    
226    
# Line 270  Line 272 
272  static void first_pass_stats_prepare_data(rc_2pass2_t * rc);  static void first_pass_stats_prepare_data(rc_2pass2_t * rc);
273  static void first_pass_scale_curve_internal(rc_2pass2_t *rc);  static void first_pass_scale_curve_internal(rc_2pass2_t *rc);
274  static void scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc);  static void scaled_curve_apply_advanced_parameters(rc_2pass2_t * rc);
 #ifdef VBV  
275  static  int check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);  static  int check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);
276  static  int scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);  static  int scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps);
 #endif  
   
277  #if 0  #if 0
278  static void stats_print(rc_2pass2_t * rc);  static void stats_print(rc_2pass2_t * rc);
279  #endif  #endif
# Line 293  Line 292 
292          if (rc == NULL)          if (rc == NULL)
293                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
294    
295          rc->param = *param;          /* v1.0.x */
296            rc->param.version = param->version;
297            rc->param.bitrate = param->bitrate;
298            rc->param.filename = param->filename;
299            rc->param.keyframe_boost = param->keyframe_boost;
300            rc->param.curve_compression_high = param->curve_compression_high;
301            rc->param.curve_compression_low = param->curve_compression_low;
302            rc->param.overflow_control_strength = param->overflow_control_strength;
303            rc->param.max_overflow_improvement = param->max_overflow_improvement;
304            rc->param.max_overflow_degradation = param->max_overflow_degradation;
305            rc->param.kfreduction = param->kfreduction;
306            rc->param.kfthreshold = param->kfthreshold;
307            rc->param.container_frame_overhead = param->container_frame_overhead;
308    
309            if (XVID_VERSION_MINOR(param->version) >= 1) {
310                    rc->param.vbv_size = param->vbv_size;
311                    rc->param.vbv_initial = param->vbv_initial;
312                    rc->param.vbv_maxrate = param->vbv_maxrate;
313                    rc->param.vbv_peakrate = param->vbv_peakrate;
314            }else{
315                    rc->param.vbv_size =
316                    rc->param.vbv_initial =
317                    rc->param.vbv_maxrate =
318                    rc->param.vbv_peakrate = 0;
319            }
320    
321          /* Initialize all defaults */          /* Initialize all defaults */
322  #define _INIT(a, b) if((a) <= 0) (a) = (b)  #define _INIT(a, b) if((a) <= 0) (a) = (b)
# Line 323  Line 346 
346    
347          rc->fq_error = 0;          rc->fq_error = 0;
348          rc->min_quant = 1;          rc->min_quant = 1;
349            rc->scaled_frames = 0;
350    
351          /* Count frames (and intra frames) in the stats file, store the result into          /* Count frames (and intra frames) in the stats file, store the result into
352           * the rc structure */           * the rc structure */
# Line 431  Line 455 
455           * shape the curve in the BEFORE/AFTER pair of functions */           * shape the curve in the BEFORE/AFTER pair of functions */
456          scaled_curve_apply_advanced_parameters(rc);          scaled_curve_apply_advanced_parameters(rc);
457    
   
 #ifdef VBV  
458  /* Check curve for VBV compliancy and rescale if necessary */  /* Check curve for VBV compliancy and rescale if necessary */
   
   
459  #ifdef VBV_FORCE  #ifdef VBV_FORCE
460    if (rc->param.vbvsize==0)          if (rc->param.vbv_size==0) {
461    {                  rc->param.vbv_size      =  3145728;
462      rc->param.vbvsize      =  3145728;                  rc->param.vbv_initial   =  2359296;
463      rc->param.vbvinitial   =  2359296;                  rc->param.vbv_maxrate   =  4854000;
464      rc->param.vbv_maxrate  =  4000000;                  rc->param.vbv_peakrate  =  8000000;
     rc->param.vbv_peakrate = 10000000;  
465    }    }
466  #endif  #endif
467    
468    if (rc->param.vbvsize>0)    /* vbvsize==0 switches VBV check off */          /* vbv_size==0 switches VBV check off */
469    {          if (rc->param.vbv_size > 0)  {
470      const double fps = (double)create->fbase/(double)create->fincr;                  const float fps = (float) ((double)create->fbase/(double)create->fincr);
471      int status = check_curve_for_vbv_compliancy(rc, fps);      int status = check_curve_for_vbv_compliancy(rc, fps);
472  #ifdef VBV_DEBUG  
473      if (status)                  if (status) {
474        fprintf(stderr,"underflow detected\n Scaling Curve for compliancy... ");                          DPRINTF(XVID_DEBUG_RC, "[xvid rc] Underflow detected - Scaling Curve for compliancy.\n");
475  #endif                  }
476    
477          status = scale_curve_for_vbv_compliancy(rc, fps);          status = scale_curve_for_vbv_compliancy(rc, fps);
478    
479  #ifdef VBV_DEBUG                  if (status == 0) {
480        if (status==0)                          DPRINTF(XVID_DEBUG_RC, "[xvid rc] VBV compliant curve scaling done.\n");
481          fprintf(stderr,"done.\n");                  } else {
482        else                          DPRINTF(XVID_DEBUG_RC, "[xvid rc] VBV compliant curve scaling impossible.\n");
483          fprintf(stderr,"impossible.\n");                  }
 #endif  
484    }    }
 #endif  
   
485          *handle = rc;          *handle = rc;
486          return(0);          return(0);
487  }  }
# Line 781  Line 797 
797                  rc->last_quant[s->type-1] = data->quant;                  rc->last_quant[s->type-1] = data->quant;
798    
799          /* Don't forget to force 1st pass frame type ;-) */          /* Don't forget to force 1st pass frame type ;-) */
800            if (rc->scaled_frames)
801          data->type = s->type;          data->type = s->type;
802    
803            rc->scaled_frames++;
804          return 0;          return 0;
805  }  }
806    
# Line 844  Line 862 
862                  rc->KFoverflow -= rc->KFoverflow_partial;                  rc->KFoverflow -= rc->KFoverflow_partial;
863          }          }
864    
865          rc->overflow += (s->error = s->desired_length - data->length);          s->error = s->desired_length - data->length;
866          rc->real_total += data->length;          rc->real_total += data->length;
867    
868          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",          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",
# Line 941  Line 959 
959          /* We are done with the file */          /* We are done with the file */
960          fclose(f);          fclose(f);
961    
962          return(0);          if (!rc->num_keyframes) return (-1); /* No keyframes? Then something is wrong */
963            else return(0);
964  }  }
965    
966  /* open stats file(s) and read into rc->stats array */  /* open stats file(s) and read into rc->stats array */
# Line 1342  Line 1361 
1361                  if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {                  if (rc->count[i] == 0 || rc->pb_iboost_tax_ratio == 0) {
1362                          rc->avg_length[i] = 1;                          rc->avg_length[i] = 1;
1363                  } else {                  } else {
1364                          rc->avg_length[i] = rc->tot_scaled_length[i];                          rc->avg_length[i] = (double) rc->tot_scaled_length[i];
1365    
1366                          if (i == (XVID_TYPE_IVOP-1)) {                          if (i == (XVID_TYPE_IVOP-1)) {
1367                                  /* I Frames total has to be added the boost total */                                  /* I Frames total has to be added the boost total */
# Line 1420  Line 1439 
1439          return;          return;
1440  }  }
1441    
   
 #ifdef VBV  
   
1442  /*****************************************************************************  /*****************************************************************************
1443   * VBV compliancy check and scale   * VBV compliancy check and scale
1444   * MPEG-4 standard specifies certain restrictions for bitrate/framesize in VBR   * MPEG-4 standard specifies certain restrictions for bitrate/framesize in VBR
# Line 1430  Line 1446 
1446   * aren't...)   * aren't...)
1447   *   *
1448   * DivX profiles have 2 criteria: VBV as in MPEG standard   * DivX profiles have 2 criteria: VBV as in MPEG standard
1449   *                                a limit on peak bitrate for any 3 seconds   *                                a limit on peak bitrate for any 1 second
1450   *   *
1451   * But if VBV is fulfilled, peakrate is automatically fulfilled in any profile   * But if VBV is fulfilled, peakrate is automatically fulfilled in any profile
1452   * define so far, so we check for it (for completeness) but correct only VBV   * defined so far, so we check for it (for completeness) but correct only VBV
1453   *   *
1454   *****************************************************************************/   *****************************************************************************/
1455    
1456  #define VBV_COMPLIANT 0  #define VBV_COMPLIANT 0
1457  #define VBV_UNDERFLOW 1 /* video buffer runs empty */  #define VBV_UNDERFLOW 1 /* video buffer runs empty */
1458  #define VBV_OVERFLOW 2  /* doesn't exist for VBR encoding */  #define VBV_OVERFLOW 2  /* doesn't exist for VBR encoding */
1459  #define VBV_PEAKRATE 4  /* peak bitrate (within 3s) violated */  #define VBV_PEAKRATE  4  /* peak bitrate (within 1s) violated */
1460    
1461  static int check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)  static int
1462    check_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)
1463  {  {
1464  /* We do all calculations in float, for higher accuracy, and bytes for convenience          /* We do all calculations in float, for higher accuracy,
1465             * and in bytes for convenience.
1466     typical values from DivX Home Theater profile:           *
1467     vbvsize= 384*1024 (384kB), vbvinitial= 288*1024 (75% fill)           * typical values from e.g. Home profile:
1468     maxrate= 4000000 (4MBps), peakrate= 10000000 (10MBps)           *  vbv_size= 384*1024 (384kB)
1469             *  vbv_initial= 288*1024 (75% fill)
1470     PAL: offset3s = 75 (3 seconds of 25fps)           *  maxrate= 4854000 (4.854MBps)
1471     NTSC: offset3s = 90 (3 seconds of 29.97fps) or 72 (3 seconds of 23.976fps)           *  peakrate= 8000000 (8MBps)
1472             *
1473             *  PAL: offset1s = 25 (1 second of 25fps)
1474             *  NTSC: offset1s = 30 (1 second of 29.97fps) or 24 (1 second of 23.976fps)
1475  */  */
1476    
1477    const float vbvsize = (float)rc->param.vbvsize/8.f;          const float vbv_size = (float)rc->param.vbv_size/8.f;
1478    float vbvfill = (float)rc->param.vbvinitial/8.f;          float vbvfill = (float)rc->param.vbv_initial/8.f;
1479            float vbvmin;
1480    
1481    const float maxrate = (float)rc->param.vbv_maxrate;    const float maxrate = (float)rc->param.vbv_maxrate;
1482    const float peakrate = (float)rc->param.vbv_peakrate;    const float peakrate = (float)rc->param.vbv_peakrate;
1483    const float r0 = (int)(maxrate/fps+0.5)/8.f;    const float r0 = (int)(maxrate/fps+0.5)/8.f;
1484    
1485    int bytes3s = 0;          int bytes1s = 0;
1486    int offset3s = (int)(3.f*fps+0.5);          int offset1s = (int)(1.f*fps+0.5);
   
1487    int i;    int i;
   for (i=0; i<rc->num_frames; i++) {  
 /* DivX 3s peak bitrate check  */  
1488    
1489      bytes3s += rc->stats[i].scaled_length;          /* 1Gbit should be enough to inuitialize the vbvmin
1490      if (i>=offset3s)           *      an arbitrary high value */
1491        bytes3s -= rc->stats[i-offset3s].scaled_length;          vbvmin = 1000*1000*1000;
1492    
1493      if (8.f*bytes3s > 3*peakrate)          for (i=0; i<rc->num_frames; i++) {
1494        return VBV_PEAKRATE;                  /* DivX 1s peak bitrate check  */
1495                    bytes1s += rc->stats[i].scaled_length;
1496                    if (i>=offset1s)
1497                            bytes1s -= rc->stats[i-offset1s].scaled_length;
1498    
1499        /* ignore peakrate constraint if peakrate is <= 0.f */
1500                    if (peakrate>0.f && 8.f*bytes1s > peakrate)
1501                            return(VBV_PEAKRATE);
1502    
1503  /* update vbv fill level */  /* update vbv fill level */
   
1504      vbvfill += r0 - rc->stats[i].scaled_length;      vbvfill += r0 - rc->stats[i].scaled_length;
1505    
1506  /* this check is _NOT_ an "overflow"! only reading from disk stops then */  /* this check is _NOT_ an "overflow"! only reading from disk stops then */
1507      if (vbvfill > vbvsize)                  if (vbvfill > vbv_size)
1508        vbvfill = vbvsize;                          vbvfill = vbv_size;
1509    
1510  /* but THIS would be an underflow. report it! */  /* but THIS would be an underflow. report it! */
1511      if (vbvfill < 0)      if (vbvfill < 0)
1512        return VBV_UNDERFLOW;                          return(VBV_UNDERFLOW);
   }  
1513    
1514    return VBV_COMPLIANT;                  /* Store the minimum buffer filling */
1515                    if (vbvfill < vbvmin)
1516                            vbvmin = vbvfill;
1517  }  }
 /* idea: min(vbvfill) could be stored to print "minimum buffer fill" */  
1518    
1519            DPRINTF(XVID_DEBUG_RC, "[xvid rc] Minimum buffer fill: %f bytes\n", vbvmin);
1520    
1521            return(VBV_COMPLIANT);
1522    }
1523    
1524  static int scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)  
1525    static int
1526    scale_curve_for_vbv_compliancy(rc_2pass2_t * rc, const float fps)
1527  {  {
1528  /* correct any VBV violations. Peak bitrate violations disappears  /* correct any VBV violations. Peak bitrate violations disappears
1529     by this automatically           * by this automatically
1530             *
1531     This implementation follows           * This implementation follows
1532             *
1533     Westerink, Rajagopalan, Gonzales "Two-pass MPEG-2 variable-bitrate encoding"           * Westerink, Rajagopalan, Gonzales "Two-pass MPEG-2 variable-bitrate encoding"
1534     IBM J. RES. DEVELOP. VOL 43, No. 4, July 1999, p.471--488           * IBM J. RES. DEVELOP. VOL 43, No. 4, July 1999, p.471--488
1535             *
1536             * Thanks, guys! This paper rocks!!! */
1537    
1538     Thanks, guys! This paper rocks!!!          /* For each scene of len N, we have to check up to N^2 possible buffer fills.
1539  */           * This works well with MPEG-2 where N==12 or so, but for MPEG-4 it's a
1540             * little slow...
1541             *
1542             * TODO: Better control on VBVfill between scenes */
1543    
1544  /*          const float vbv_size = (float)rc->param.vbv_size/8.f;
1545      For each scene of len N, we have to check up to N^2 possible buffer fills.          const float vbv_initial = (float)rc->param.vbv_initial/8.f;
     This works well with MPEG-2 where N==12 or so, but for MPEG-4 it's a  
     little slow...  
 */  
   const float vbvsize = (float)rc->param.vbvsize/8.f;  
   const float vbvinitial = (float)rc->param.vbvinitial/8.f;  
1546    
1547    const float maxrate = 0.9*rc->param.vbv_maxrate;          const float maxrate = 0.9f*rc->param.vbv_maxrate;
1548    const float vbvlow = 0.10f*vbvsize;          const float vbv_low = 0.10f*vbv_size;
1549    const float r0 = (int)(maxrate/fps+0.5)/8.f;    const float r0 = (int)(maxrate/fps+0.5)/8.f;
1550    
1551    int i,k,l,n,violation = 0;    int i,k,l,n,violation = 0;
# Line 1524  Line 1553 
1553    int *scenestart;    int *scenestart;
1554    int *scenelength;    int *scenelength;
1555    
1556  /* first step: determine how many "scenes" there are and store their boundaries          /* first step: determine how many "scenes" there are and store their
1557     we could get all this from existing keyframe_positions, somehow, but there we           * boundaries we could get all this from existing keyframe_positions,
1558     don't have a min_scenelength, and it's no big deal to get it again.  */           * somehow, but there we don't have a min_scenelength, and it's no big
1559             * deal to get it again. */
1560    
1561    const int min_scenelength = 50;          const int min_scenelength = (int)(fps+0.5);
1562    int num_scenes = 0;    int num_scenes = 0;
1563    int last_scene = -999;    int last_scene = -999;
1564    for (i=0; i<rc->num_frames; i++) {    for (i=0; i<rc->num_frames; i++) {
1565      if ( (rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength) )                  if ((rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength)) {
     {  
1566        last_scene = i;        last_scene = i;
1567        num_scenes++;        num_scenes++;
1568      }      }
# Line 1543  Line 1572 
1572    scenestart = (int*)malloc( num_scenes*sizeof(int) );    scenestart = (int*)malloc( num_scenes*sizeof(int) );
1573    scenelength = (int*)malloc( num_scenes*sizeof(int) );    scenelength = (int*)malloc( num_scenes*sizeof(int) );
1574    
1575    if ((!scenefactor) || (!scenestart) || (!scenelength) )          if ((!scenefactor) || (!scenestart) || (!scenelength) ) {
   {  
1576      free(scenefactor);      free(scenefactor);
1577      free(scenestart);      free(scenestart);
1578      free(scenelength);      free(scenelength);
1579      /* remember: free(0) is valid and does exactly nothing. */      /* remember: free(0) is valid and does exactly nothing. */
1580      return -1;                  return(-1);
1581    }    }
1582    
1583  /* count again and safe the length/position */  /* count again and safe the length/position */
# Line 1557  Line 1585 
1585    num_scenes = 0;    num_scenes = 0;
1586    last_scene = -999;    last_scene = -999;
1587    for (i=0; i<rc->num_frames; i++) {    for (i=0; i<rc->num_frames; i++) {
1588      if ( (rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength) )                  if ((rc->stats[i].type == XVID_TYPE_IVOP) && (i-last_scene>min_scenelength)) {
1589      {                          if (num_scenes>0) {
       if (num_scenes>0)  
1590          scenelength[num_scenes-1]=i-last_scene;          scenelength[num_scenes-1]=i-last_scene;
1591                            }
1592        scenestart[num_scenes]=i;        scenestart[num_scenes]=i;
1593        num_scenes++;        num_scenes++;
1594        last_scene = i;        last_scene = i;
# Line 1568  Line 1596 
1596    }    }
1597    scenelength[num_scenes-1]=i-last_scene;    scenelength[num_scenes-1]=i-last_scene;
1598    
1599  /* second step: check for each scene, how much we can scale its frames up or down          /* second step: check for each scene, how much we can scale its frames up or
1600     such that the VBV restriction is just fulfilled           * down such that the VBV restriction is just fulfilled */
 */  
   
   
1601  #define R(k,n) (((n)+1-(k))*r0)     /* how much enters the buffer between frame k and n */  #define R(k,n) (((n)+1-(k))*r0)     /* how much enters the buffer between frame k and n */
1602    for (l=0; l<num_scenes;l++)          for (l=0; l<num_scenes;l++) {
   {  
1603      const int start = scenestart[l];      const int start = scenestart[l];
1604      const int length = scenelength[l];      const int length = scenelength[l];
1605      twopass_stat_t * frames = &rc->stats[start];      twopass_stat_t * frames = &rc->stats[start];
# Line 1584  Line 1608 
1608      float f,minf = 99999.f;      float f,minf = 99999.f;
1609    
1610      S0n=0.;      S0n=0.;
1611      for (n=0;n<=length-1;n++)                  for (n=0;n<=length-1;n++) {
     {  
1612        S0n += frames[n].scaled_length;        S0n += frames[n].scaled_length;
1613    
1614        k=0;        k=0;
1615        Skn = S0n;        Skn = S0n;
1616        f = (R(k,n-1) + (vbvinitial - vbvlow)) / Skn;                          f = (R(k,n-1) + (vbv_initial - vbv_low)) / Skn;
1617        if (f < minf)        if (f < minf)
1618          minf = f;          minf = f;
1619    
1620        for (k=1;k<=n;k++)                          for (k=1;k<=n;k++) {
       {  
1621          Skn -= frames[k].scaled_length;          Skn -= frames[k].scaled_length;
1622    
1623          f = (R(k,n-1) + (vbvsize - vbvlow)) / Skn;                                  f = (R(k,n-1) + (vbv_size - vbv_low)) / Skn;
1624          if (f < minf)          if (f < minf)
1625            minf = f;            minf = f;
1626        }        }
1627      }      }
1628    
1629      /* special case: at the end, fill buffer up to vbvinitial again                  /* special case: at the end, fill buffer up to vbv_initial again
1630         TODO: Allow other values for buffer fill between scenes                   *
1631         e.g. if n=N is smallest f-value, then check for better value */                   * TODO: Allow other values for buffer fill between scenes
1632                     * e.g. if n=N is smallest f-value, then check for better value */
1633    
1634      n=length;      n=length;
1635      k=0;      k=0;
# Line 1615  Line 1638 
1638      if (f < minf)      if (f < minf)
1639        minf = f;        minf = f;
1640    
1641      for (k=1;k<=n-1;k++)                  for (k=1;k<=n-1;k++) {
     {  
1642        Skn -= frames[k].scaled_length;        Skn -= frames[k].scaled_length;
1643    
1644        f = (R(k,n-1) + (vbvinitial - vbvlow)) / Skn;                          f = (R(k,n-1) + (vbv_initial - vbv_low)) / Skn;
1645        if (f < minf)        if (f < minf)
1646          minf = f;          minf = f;
1647      }      }
1648    
1649  #ifdef VBV_DEBUG                  DPRINTF(XVID_DEBUG_RC, "[xvid rc] Scene %d (Frames %d-%d): VBVfactor %f\n",
1650      printf("Scene %d (Frames %d-%d): VBVfactor %f\n", l, start, start+length-1 , minf);                                  l, start, start+length-1 , minf);
 #endif  
1651    
1652      scenefactor[l] = minf;      scenefactor[l] = minf;
1653    }    }
1654  #undef R  #undef R
1655    
1656  /* last step: now we know of any scene how much it can be scaled up or down without          /* last step: now we know of any scene how much it can be scaled up or down
1657     violating VBV. Next, distribute bits from the evil scenes to the good ones */           * without violating VBV. Next, distribute bits from the evil scenes to the
1658             * good ones */
1659    do          do {
   {  
1660      float S_red = 0.f;    /* how much to redistribute */      float S_red = 0.f;    /* how much to redistribute */
1661      float S_elig = 0.f;   /* sum of bit for those scenes you can still swallow something*/      float S_elig = 0.f;   /* sum of bit for those scenes you can still swallow something*/
1662                    float f_red;
1663      int l;      int l;
1664    
1665      for (l=0;l<num_scenes;l++)   /* check how much is wrong */                  /* check how much is wrong */
1666      {                  for (l=0;l<num_scenes;l++) {
1667      const int start = scenestart[l];      const int start = scenestart[l];
1668      const int length = scenelength[l];      const int length = scenelength[l];
1669      twopass_stat_t * frames = &rc->stats[start];      twopass_stat_t * frames = &rc->stats[start];
1670    
1671        if (scenefactor[l] == 1.) /* exactly 1 means "don't touch this anymore!" */                          /* exactly 1 means "don't touch this anymore!" */
1672                            if (scenefactor[l] == 1.)
1673          continue;          continue;
1674    
1675        if (scenefactor[l] > 1.) /* within limits */                          /* within limits */
1676        {                          if (scenefactor[l] > 1.) {
1677          for (n= 0; n < length; n++)          for (n= 0; n < length; n++)
1678            S_elig += frames[n].scaled_length;            S_elig += frames[n].scaled_length;
1679        }                          } else {
1680        else /* underflowing segment */                                  /* underflowing segment */
1681        {                                  for (n= 0; n < length; n++) {
         for (n= 0; n < length; n++)  
         {  
1682            float newbytes = (float)frames[n].scaled_length * scenefactor[l];            float newbytes = (float)frames[n].scaled_length * scenefactor[l];
1683            S_red += (float)frames[n].scaled_length - (float)newbytes;            S_red += (float)frames[n].scaled_length - (float)newbytes;
1684            frames[n].scaled_length =(int)newbytes;            frames[n].scaled_length =(int)newbytes;
# Line 1667  Line 1687 
1687        }        }
1688      }      }
1689    
1690      if (S_red < 1.f)   /* no more underflows */                  /* no more underflows */
1691                    if (S_red < 1.f)
1692        break;        break;
1693    
1694      if (S_elig < 1.f)                  if (S_elig < 1.f) {
1695      {                          DPRINTF(XVID_DEBUG_RC, "[xvid rc] Everything underflowing.\n");
 #ifdef VBV_DEBUG  
       fprintf(stderr,"Everything underflowing. \n");  
 #endif  
1696        free(scenefactor);        free(scenefactor);
1697        free(scenestart);        free(scenestart);
1698        free(scenelength);        free(scenelength);
1699        return -2;                          return(-2);
1700      }      }
1701    
1702      const float f_red = (1.f + S_red/S_elig);                  f_red = (1.f + S_red/S_elig);
1703    
1704  #ifdef VBV_DEBUG                  DPRINTF(XVID_DEBUG_RC, "[xvid rc] Moving %.0f kB to avoid buffer underflow, correction factor: %.5f\n",
1705      printf("Moving %.0f kB to avoid buffer underflow, correction factor: %.5f\n",S_red/1024.f,f_red);                                  S_red/1024.f, f_red);
 #endif  
1706    
1707      violation=0;      violation=0;
1708      for (l=0; l<num_scenes; l++)   /* scale remaining scenes up to meet total size */                  /* scale remaining scenes up to meet total size */
1709      {                  for (l=0; l<num_scenes; l++) {
1710        const int start = scenestart[l];        const int start = scenestart[l];
1711        const int length = scenelength[l];        const int length = scenelength[l];
1712        twopass_stat_t * frames = &rc->stats[start];        twopass_stat_t * frames = &rc->stats[start];
# Line 1698  Line 1715 
1715          continue;          continue;
1716    
1717        /* there shouldn't be any segments with factor<1 left, so all the rest is >1 */        /* there shouldn't be any segments with factor<1 left, so all the rest is >1 */
1718                            for (n= 0; n < length; n++) {
       for (n= 0; n < length; n++)  
       {  
1719          frames[n].scaled_length = (int)(frames[n].scaled_length * f_red + 0.5);          frames[n].scaled_length = (int)(frames[n].scaled_length * f_red + 0.5);
1720        }        }
1721    
# Line 1714  Line 1729 
1729    free(scenefactor);    free(scenefactor);
1730    free(scenestart);    free(scenestart);
1731    free(scenelength);    free(scenelength);
1732    return 0;          return(0);
1733  }  }
1734    
1735    
 #endif  
   
   
1736  /*****************************************************************************  /*****************************************************************************
1737   * Still more low level stuff (nothing to do with stats treatment)   * Still more low level stuff (nothing to do with stats treatment)
1738   ****************************************************************************/   ****************************************************************************/
Legend:
Removed from v.1.1.2.38  
changed lines
  Added in v.1.11
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4