ratectl.c
上传用户:hkgotone
上传日期:2013-02-17
资源大小:293k
文件大小:13k
源码类别:

Windows Mobile

开发平台:

C/C++

  1. /* ratectl.c, bitrate control routines (linear quantization only currently) */
  2. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  3. /*
  4.  * Disclaimer of Warranty
  5.  *
  6.  * These software programs are available to the user without any license fee or
  7.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  8.  * any and all warranties, whether express, implied, or statuary, including any
  9.  * implied warranties or merchantability or of fitness for a particular
  10.  * purpose.  In no event shall the copyright-holder be liable for any
  11.  * incidental, punitive, or consequential damages of any kind whatsoever
  12.  * arising from the use of these programs.
  13.  *
  14.  * This disclaimer of warranty extends to the user of these programs and user's
  15.  * customers, employees, agents, transferees, successors, and assigns.
  16.  *
  17.  * The MPEG Software Simulation Group does not represent or warrant that the
  18.  * programs furnished hereunder are free of infringement of any third-party
  19.  * patents.
  20.  *
  21.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  22.  * are subject to royalty fees to patent holders.  Many of these patents are
  23.  * general enough such that they are unavoidable regardless of implementation
  24.  * design.
  25.  *
  26.  */
  27. #include <stdio.h>
  28. #include <math.h>
  29. #include "config.h"
  30. #include "global.h"
  31. /* private prototypes */
  32. static void calc_actj _ANSI_ARGS_((unsigned char *frame));
  33. static double var_sblk _ANSI_ARGS_((unsigned char *p, int lx));
  34. /* rate control variables */
  35. int Xi, Xp, Xb, r, d0i, d0p, d0b;
  36. double avg_act;
  37. static int R, T, d;
  38. static double actsum;
  39. static int Np, Nb, S, Q;
  40. static int prev_mquant;
  41. void rc_init_seq()
  42. {
  43.   /* reaction parameter (constant) */
  44.   if (r==0)  r = (int)floor(2.0*bit_rate/frame_rate + 0.5);
  45.   /* average activity */
  46.   if (avg_act==0.0)  avg_act = 400.0;
  47.   /* remaining # of bits in GOP */
  48.   R = 0;
  49.   /* global complexity measure */
  50.   if (Xi==0) Xi = (int)floor(160.0*bit_rate/115.0 + 0.5);
  51.   if (Xp==0) Xp = (int)floor( 60.0*bit_rate/115.0 + 0.5);
  52.   if (Xb==0) Xb = (int)floor( 42.0*bit_rate/115.0 + 0.5);
  53.   /* virtual buffer fullness */
  54.   if (d0i==0) d0i = (int)floor(10.0*r/31.0 + 0.5);
  55.   if (d0p==0) d0p = (int)floor(10.0*r/31.0 + 0.5);
  56.   if (d0b==0) d0b = (int)floor(1.4*10.0*r/31.0 + 0.5);
  57. /*
  58.   if (d0i==0) d0i = (int)floor(10.0*r/(qscale_tab[0] ? 56.0 : 31.0) + 0.5);
  59.   if (d0p==0) d0p = (int)floor(10.0*r/(qscale_tab[1] ? 56.0 : 31.0) + 0.5);
  60.   if (d0b==0) d0b = (int)floor(1.4*10.0*r/(qscale_tab[2] ? 56.0 : 31.0) + 0.5);
  61. */
  62.   fprintf(statfile,"nrate control: sequence initializationn");
  63.   fprintf(statfile,
  64.     " initial global complexity measures (I,P,B): Xi=%d, Xp=%d, Xb=%dn",
  65.     Xi, Xp, Xb);
  66.   fprintf(statfile," reaction parameter: r=%dn", r);
  67.   fprintf(statfile,
  68.     " initial virtual buffer fullness (I,P,B): d0i=%d, d0p=%d, d0b=%dn",
  69.     d0i, d0p, d0b);
  70.   fprintf(statfile," initial average activity: avg_act=%.1fn", avg_act);
  71. }
  72. void rc_init_GOP(np,nb)
  73. int np,nb;
  74. {
  75.   R += (int) floor((1 + np + nb) * bit_rate / frame_rate + 0.5);
  76.   Np = fieldpic ? 2*np+1 : np;
  77.   Nb = fieldpic ? 2*nb : nb;
  78.   fprintf(statfile,"nrate control: new group of pictures (GOP)n");
  79.   fprintf(statfile," target number of bits for GOP: R=%dn",R);
  80.   fprintf(statfile," number of P pictures in GOP: Np=%dn",Np);
  81.   fprintf(statfile," number of B pictures in GOP: Nb=%dn",Nb);
  82. }
  83. /* Note: we need to substitute K for the 1.4 and 1.0 constants -- this can
  84.    be modified to fit image content */
  85. /* Step 1: compute target bits for current picture being coded */
  86. void rc_init_pict(frame)
  87. unsigned char *frame;
  88. {
  89.   double Tmin;
  90.   switch (pict_type)
  91.   {
  92.   case I_TYPE:
  93.     T = (int) floor(R/(1.0+Np*Xp/(Xi*1.0)+Nb*Xb/(Xi*1.4)) + 0.5);
  94.     d = d0i;
  95.     break;
  96.   case P_TYPE:
  97.     T = (int) floor(R/(Np+Nb*1.0*Xb/(1.4*Xp)) + 0.5);
  98.     d = d0p;
  99.     break;
  100.   case B_TYPE:
  101.     T = (int) floor(R/(Nb+Np*1.4*Xp/(1.0*Xb)) + 0.5);
  102.     d = d0b;
  103.     break;
  104.   }
  105.   Tmin = (int) floor(bit_rate/(8.0*frame_rate) + 0.5);
  106.   if (T<Tmin)
  107.     T = Tmin;
  108.   S = bitcount();
  109.   Q = 0;
  110.   calc_actj(frame);
  111.   actsum = 0.0;
  112.   fprintf(statfile,"nrate control: start of picturen");
  113.   fprintf(statfile," target number of bits: T=%dn",T);
  114. }
  115. static void calc_actj(frame)
  116. unsigned char *frame;
  117. {
  118.   int i,j,k;
  119.   unsigned char *p;
  120.   double actj,var;
  121.   k = 0;
  122.   for (j=0; j<height2; j+=16)
  123.     for (i=0; i<width; i+=16)
  124.     {
  125.       p = frame + ((pict_struct==BOTTOM_FIELD)?width:0) + i + width2*j;
  126.       /* take minimum spatial activity measure of luminance blocks */
  127.       actj = var_sblk(p,width2);
  128.       var = var_sblk(p+8,width2);
  129.       if (var<actj) actj = var;
  130.       var = var_sblk(p+8*width2,width2);
  131.       if (var<actj) actj = var;
  132.       var = var_sblk(p+8*width2+8,width2);
  133.       if (var<actj) actj = var;
  134.       if (!fieldpic && !prog_seq)
  135.       {
  136.         /* field */
  137.         var = var_sblk(p,width<<1);
  138.         if (var<actj) actj = var;
  139.         var = var_sblk(p+8,width<<1);
  140.         if (var<actj) actj = var;
  141.         var = var_sblk(p+width,width<<1);
  142.         if (var<actj) actj = var;
  143.         var = var_sblk(p+width+8,width<<1);
  144.         if (var<actj) actj = var;
  145.       }
  146.       actj+= 1.0;
  147.       mbinfo[k++].act = actj;
  148.     }
  149. }
  150. void rc_update_pict()
  151. {
  152.   double X;
  153.   S = bitcount() - S; /* total # of bits in picture */
  154.   R-= S; /* remaining # of bits in GOP */
  155.   X = (int) floor(S*((0.5*(double)Q)/(mb_width*mb_height2)) + 0.5);
  156.   d+= S - T;
  157.   avg_act = actsum/(mb_width*mb_height2);
  158.   switch (pict_type)
  159.   {
  160.   case I_TYPE:
  161.     Xi = X;
  162.     d0i = d;
  163.     break;
  164.   case P_TYPE:
  165.     Xp = X;
  166.     d0p = d;
  167.     Np--;
  168.     break;
  169.   case B_TYPE:
  170.     Xb = X;
  171.     d0b = d;
  172.     Nb--;
  173.     break;
  174.   }
  175.   fprintf(statfile,"nrate control: end of picturen");
  176.   fprintf(statfile," actual number of bits: S=%dn",S);
  177.   fprintf(statfile," average quantization parameter Q=%.1fn",
  178.     (double)Q/(mb_width*mb_height2));
  179.   fprintf(statfile," remaining number of bits in GOP: R=%dn",R);
  180.   fprintf(statfile,
  181.     " global complexity measures (I,P,B): Xi=%d, Xp=%d, Xb=%dn",
  182.     Xi, Xp, Xb);
  183.   fprintf(statfile,
  184.     " virtual buffer fullness (I,P,B): d0i=%d, d0p=%d, d0b=%dn",
  185.     d0i, d0p, d0b);
  186.   fprintf(statfile," remaining number of P pictures in GOP: Np=%dn",Np);
  187.   fprintf(statfile," remaining number of B pictures in GOP: Nb=%dn",Nb);
  188.   fprintf(statfile," average activity: avg_act=%.1fn", avg_act);
  189. }
  190. /* compute initial quantization stepsize (at the beginning of picture) */
  191. int rc_start_mb()
  192. {
  193.   int mquant;
  194.   if (q_scale_type)
  195.   {
  196.     mquant = (int) floor(2.0*d*31.0/r + 0.5);
  197.     /* clip mquant to legal (linear) range */
  198.     if (mquant<1)
  199.       mquant = 1;
  200.     if (mquant>112)
  201.       mquant = 112;
  202.     /* map to legal quantization level */
  203.     mquant = non_linear_mquant_table[map_non_linear_mquant[mquant]];
  204.   }
  205.   else
  206.   {
  207.     mquant = (int) floor(d*31.0/r + 0.5);
  208.     mquant <<= 1;
  209.     /* clip mquant to legal (linear) range */
  210.     if (mquant<2)
  211.       mquant = 2;
  212.     if (mquant>62)
  213.       mquant = 62;
  214.     prev_mquant = mquant;
  215.   }
  216. /*
  217.   fprintf(statfile,"rc_start_mb:n");
  218.   fprintf(statfile,"mquant=%dn",mquant);
  219. */
  220.   return mquant;
  221. }
  222. /* Step 2: measure virtual buffer - estimated buffer discrepancy */
  223. int rc_calc_mquant(j)
  224. int j;
  225. {
  226.   int mquant;
  227.   double dj, Qj, actj, N_actj;
  228.   /* measure virtual buffer discrepancy from uniform distribution model */
  229.   dj = d + (bitcount()-S) - j*(T/(mb_width*mb_height2));
  230.   /* scale against dynamic range of mquant and the bits/picture count */
  231.   Qj = dj*31.0/r;
  232. /*Qj = dj*(q_scale_type ? 56.0 : 31.0)/r;  */
  233.   actj = mbinfo[j].act;
  234.   actsum+= actj;
  235.   /* compute normalized activity */
  236.   N_actj = (2.0*actj+avg_act)/(actj+2.0*avg_act);
  237.   if (q_scale_type)
  238.   {
  239.     /* modulate mquant with combined buffer and local activity measures */
  240.     mquant = (int) floor(2.0*Qj*N_actj + 0.5);
  241.     /* clip mquant to legal (linear) range */
  242.     if (mquant<1)
  243.       mquant = 1;
  244.     if (mquant>112)
  245.       mquant = 112;
  246.     /* map to legal quantization level */
  247.     mquant = non_linear_mquant_table[map_non_linear_mquant[mquant]];
  248.   }
  249.   else
  250.   {
  251.     /* modulate mquant with combined buffer and local activity measures */
  252.     mquant = (int) floor(Qj*N_actj + 0.5);
  253.     mquant <<= 1;
  254.     /* clip mquant to legal (linear) range */
  255.     if (mquant<2)
  256.       mquant = 2;
  257.     if (mquant>62)
  258.       mquant = 62;
  259.     /* ignore small changes in mquant */
  260.     if (mquant>=8 && (mquant-prev_mquant)>=-4 && (mquant-prev_mquant)<=4)
  261.       mquant = prev_mquant;
  262.     prev_mquant = mquant;
  263.   }
  264.   Q+= mquant; /* for calculation of average mquant */
  265. /*
  266.   fprintf(statfile,"rc_calc_mquant(%d): ",j);
  267.   fprintf(statfile,"bitcount=%d, dj=%f, Qj=%f, actj=%f, N_actj=%f, mquant=%dn",
  268.     bitcount(),dj,Qj,actj,N_actj,mquant);
  269. */
  270.   return mquant;
  271. }
  272. /* compute variance of 8x8 block */
  273. static double var_sblk(p,lx)
  274. unsigned char *p;
  275. int lx;
  276. {
  277.   int i, j;
  278.   unsigned int v, s, s2;
  279.   s = s2 = 0;
  280.   for (j=0; j<8; j++)
  281.   {
  282.     for (i=0; i<8; i++)
  283.     {
  284.       v = *p++;
  285.       s+= v;
  286.       s2+= v*v;
  287.     }
  288.     p+= lx - 8;
  289.   }
  290.   return s2/64.0 - (s/64.0)*(s/64.0);
  291. }
  292. /* VBV calculations
  293.  *
  294.  * generates warnings if underflow or overflow occurs
  295.  */
  296. /* vbv_end_of_picture
  297.  *
  298.  * - has to be called directly after writing picture_data()
  299.  * - needed for accurate VBV buffer overflow calculation
  300.  * - assumes there is no byte stuffing prior to the next start code
  301.  */
  302. static int bitcnt_EOP;
  303. void vbv_end_of_picture()
  304. {
  305.   bitcnt_EOP = bitcount();
  306.   bitcnt_EOP = (bitcnt_EOP + 7) & ~7; /* account for bit stuffing */
  307. }
  308. /* calc_vbv_delay
  309.  *
  310.  * has to be called directly after writing the picture start code, the
  311.  * reference point for vbv_delay
  312.  */
  313. void calc_vbv_delay()
  314. {
  315.   double picture_delay;
  316.   static double next_ip_delay; /* due to frame reordering delay */
  317.   static double decoding_time;
  318.   /* number of 1/90000 s ticks until next picture is to be decoded */
  319.   if (pict_type == B_TYPE)
  320.   {
  321.     if (prog_seq)
  322.     {
  323.       if (!repeatfirst)
  324.         picture_delay = 90000.0/frame_rate; /* 1 frame */
  325.       else
  326.       {
  327.         if (!topfirst)
  328.           picture_delay = 90000.0*2.0/frame_rate; /* 2 frames */
  329.         else
  330.           picture_delay = 90000.0*3.0/frame_rate; /* 3 frames */
  331.       }
  332.     }
  333.     else
  334.     {
  335.       /* interlaced */
  336.       if (fieldpic)
  337.         picture_delay = 90000.0/(2.0*frame_rate); /* 1 field */
  338.       else
  339.       {
  340.         if (!repeatfirst)
  341.           picture_delay = 90000.0*2.0/(2.0*frame_rate); /* 2 flds */
  342.         else
  343.           picture_delay = 90000.0*3.0/(2.0*frame_rate); /* 3 flds */
  344.       }
  345.     }
  346.   }
  347.   else
  348.   {
  349.     /* I or P picture */
  350.     if (fieldpic)
  351.     {
  352.       if(topfirst==(pict_struct==TOP_FIELD))
  353.       {
  354.         /* first field */
  355.         picture_delay = 90000.0/(2.0*frame_rate);
  356.       }
  357.       else
  358.       {
  359.         /* second field */
  360.         /* take frame reordering delay into account */
  361.         picture_delay = next_ip_delay - 90000.0/(2.0*frame_rate);
  362.       }
  363.     }
  364.     else
  365.     {
  366.       /* frame picture */
  367.       /* take frame reordering delay into account*/
  368.       picture_delay = next_ip_delay;
  369.     }
  370.     if (!fieldpic || topfirst!=(pict_struct==TOP_FIELD))
  371.     {
  372.       /* frame picture or second field */
  373.       if (prog_seq)
  374.       {
  375.         if (!repeatfirst)
  376.           next_ip_delay = 90000.0/frame_rate;
  377.         else
  378.         {
  379.           if (!topfirst)
  380.             next_ip_delay = 90000.0*2.0/frame_rate;
  381.           else
  382.             next_ip_delay = 90000.0*3.0/frame_rate;
  383.         }
  384.       }
  385.       else
  386.       {
  387.         if (fieldpic)
  388.           next_ip_delay = 90000.0/(2.0*frame_rate);
  389.         else
  390.         {
  391.           if (!repeatfirst)
  392.             next_ip_delay = 90000.0*2.0/(2.0*frame_rate);
  393.           else
  394.             next_ip_delay = 90000.0*3.0/(2.0*frame_rate);
  395.         }
  396.       }
  397.     }
  398.   }
  399.   if (decoding_time==0.0)
  400.   {
  401.     /* first call of calc_vbv_delay */
  402.     /* we start with a 7/8 filled VBV buffer (12.5% back-off) */
  403.     picture_delay = ((vbv_buffer_size*16384*7)/8)*90000.0/bit_rate;
  404.     if (fieldpic)
  405.       next_ip_delay = (int)(90000.0/frame_rate+0.5);
  406.   }
  407.   /* VBV checks */
  408.   /* check for underflow (previous picture) */
  409.   if (!low_delay && (decoding_time < bitcnt_EOP*90000.0/bit_rate))
  410.   {
  411.     /* picture not completely in buffer at intended decoding time */
  412.     if (!quiet)
  413.       fprintf(stderr,"vbv_delay underflow! (decoding_time=%.1f, t_EOP=%.1fn)",
  414.         decoding_time, bitcnt_EOP*90000.0/bit_rate);
  415.   }
  416.   /* when to decode current frame */
  417.   decoding_time += picture_delay;
  418.   /* warning: bitcount() may overflow (e.g. after 9 min. at 8 Mbit/s */
  419.   vbv_delay = (int)(decoding_time - bitcount()*90000.0/bit_rate);
  420.   /* check for overflow (current picture) */
  421.   if ((decoding_time - bitcnt_EOP*90000.0/bit_rate)
  422.       > (vbv_buffer_size*16384)*90000.0/bit_rate)
  423.   {
  424.     if (!quiet)
  425.       fprintf(stderr,"vbv_delay overflow!n");
  426.   }
  427.   fprintf(statfile,
  428.     "nvbv_delay=%d (bitcount=%d, decoding_time=%.2f, bitcnt_EOP=%d)n",
  429.     vbv_delay,bitcount(),decoding_time,bitcnt_EOP);
  430.   if (vbv_delay<0)
  431.   {
  432.     if (!quiet)
  433.       fprintf(stderr,"vbv_delay underflow: %dn",vbv_delay);
  434.     vbv_delay = 0;
  435.   }
  436.   if (vbv_delay>65535)
  437.   {
  438.     if (!quiet)
  439.       fprintf(stderr,"vbv_delay overflow: %dn",vbv_delay);
  440.     vbv_delay = 65535;
  441.   }
  442. }