开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
rc_quadratic.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：88k
源码类别：

Audio

开发平台：

Visual C++

rc_quadratic.c：源码内容
  2. /*!
  3.  ***************************************************************************
  4.  * file rc_quadratic.c
  5.  *
  6.  * brief
  7.  *    Rate Control algorithm
  8.  *
  9.  * author
  10.  *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11.  *     - Siwei Ma             <swma@jdl.ac.cn>
  12.  *     - Zhengguo LI          <ezgli@lit.a-star.edu.sg>
  13.  *     - Athanasios Leontaris <aleon@dolby.com>
  14.  *
  15.  * date
  16.  *   16 Jan. 2003
  17.  **************************************************************************
  18.  */
  20. #include <math.h>
  21. #include <limits.h>
  23. #include "global.h"
  24. #include "ratectl.h"
  27. static const float THETA = 1.3636F;
  28. static const float OMEGA = 0.9F;
  29. static const float MINVALUE = 4.0F;
  30. /*!
  31.  *************************************************************************************
  32.  * brief
  33.  *    Dynamically allocate memory needed for rate control
  34.  *
  35.  *************************************************************************************
  36.  */
  37. void rc_alloc_quadratic( rc_quadratic **prc )
  38. {
  39.   int rcBufSize = img->FrameSizeInMbs / params->basicunit;
  40.   rc_quadratic *lprc;
  42.   (*prc) = (rc_quadratic *) malloc ( sizeof( rc_quadratic ) );
  43.   if (NULL==(*prc))
  44.   {
  45.     no_mem_exit("init_global_buffers: (*prc)");
  46.   }
  47.   lprc = *prc;
  49.   lprc->PreviousFrameMAD = 1.0;
  50.   lprc->CurrentFrameMAD = 1.0;
  51.   lprc->Pprev_bits = 0;
  52.   lprc->Target = 0;
  53.   lprc->TargetField = 0;
  54.   lprc->LowerBound = 0;
  55.   lprc->UpperBound1 = INT_MAX;
  56.   lprc->UpperBound2 = INT_MAX;
  57.   lprc->Wp = 0.0;
  58.   lprc->Wb = 0.0;
  59.   lprc->AveWb = 0.0;
  60.   lprc->PAveFrameQP   = params->qp0;
  61.   lprc->m_Qc          = lprc->PAveFrameQP;
  62.   lprc->FieldQPBuffer = lprc->PAveFrameQP;
  63.   lprc->FrameQPBuffer = lprc->PAveFrameQP;
  64.   lprc->PAverageQp    = lprc->PAveFrameQP;
  65.   lprc->MyInitialQp   = lprc->PAveFrameQP;
  66.   lprc->AveWb         = 0.0;
  68.   lprc->BUPFMAD = (double*) calloc ((rcBufSize), sizeof (double));
  69.   if (NULL==lprc->BUPFMAD)
  70.   {
  71.     no_mem_exit("rc_alloc_quadratic: lprc->BUPFMAD");
  72.   }
  74.   lprc->BUCFMAD = (double*) calloc ((rcBufSize), sizeof (double));
  75.   if (NULL==lprc->BUCFMAD)
  76.   {
  77.     no_mem_exit("rc_alloc_quadratic: lprc->BUCFMAD");
  78.   }
  80.   lprc->FCBUCFMAD = (double*) calloc ((rcBufSize), sizeof (double));
  81.   if (NULL==lprc->FCBUCFMAD)
  82.   {
  83.     no_mem_exit("rc_alloc_quadratic: lprc->FCBUCFMAD");
  84.   }
  86.   lprc->FCBUPFMAD = (double*) calloc ((rcBufSize), sizeof (double));
  87.   if (NULL==lprc->FCBUPFMAD)
  88.   {
  89.     no_mem_exit("rc_alloc_quadratic: lprc->FCBUPFMAD");
  90.   }
  91. }
  93. /*!
  94.  *************************************************************************************
  95.  * brief
  96.  *    Copy JVT rate control objects
  97.  *
  98.  *************************************************************************************
  99.  */
  100. void rc_copy_quadratic( rc_quadratic *dst, rc_quadratic *src )
  101. {
  102.   int rcBufSize = img->FrameSizeInMbs / params->basicunit;
  103.   /* buffer original addresses for which memory has been allocated */
  104.   double   *tmpBUPFMAD = dst->BUPFMAD;
  105.   double   *tmpBUCFMAD = dst->BUCFMAD;
  106.   double *tmpFCBUPFMAD = dst->FCBUPFMAD;
  107.   double *tmpFCBUCFMAD = dst->FCBUCFMAD;
  109.   /* copy object */
  110.   memcpy( (void *)dst, (void *)src, sizeof(rc_quadratic) );
  112.   /* restore original addresses */
  113.   dst->BUPFMAD   = tmpBUPFMAD;
  114.   dst->BUCFMAD   = tmpBUCFMAD;
  115.   dst->FCBUPFMAD = tmpFCBUPFMAD;
  116.   dst->FCBUCFMAD = tmpFCBUCFMAD;
  118.   /* copy MADs */
  119.   memcpy( (void *)dst->BUPFMAD,   (void *)src->BUPFMAD,   (rcBufSize) * sizeof (double) );
  120.   memcpy( (void *)dst->BUCFMAD,   (void *)src->BUCFMAD,   (rcBufSize) * sizeof (double) );
  121.   memcpy( (void *)dst->FCBUPFMAD, (void *)src->FCBUPFMAD, (rcBufSize) * sizeof (double) );
  122.   memcpy( (void *)dst->FCBUCFMAD, (void *)src->FCBUCFMAD, (rcBufSize) * sizeof (double) );
  123. }
  125. /*!
  126.  *************************************************************************************
  127.  * brief
  128.  *    Free memory needed for rate control
  129.  *
  130.  *************************************************************************************
  131. */
  132. void rc_free_quadratic(rc_quadratic **prc)
  133. {
  134.   if (NULL!=(*prc)->BUPFMAD)
  135.   {
  136.     free ((*prc)->BUPFMAD);
  137.     (*prc)->BUPFMAD = NULL;
  138.   }
  139.   if (NULL!=(*prc)->BUCFMAD)
  140.   {
  141.     free ((*prc)->BUCFMAD);
  142.     (*prc)->BUCFMAD = NULL;
  143.   }
  144.   if (NULL!=(*prc)->FCBUCFMAD)
  145.   {
  146.     free ((*prc)->FCBUCFMAD);
  147.     (*prc)->FCBUCFMAD = NULL;
  148.   }
  149.   if (NULL!=(*prc)->FCBUPFMAD)
  150.   {
  151.     free ((*prc)->FCBUPFMAD);
  152.     (*prc)->FCBUPFMAD = NULL;
  153.   }
  154.   if (NULL!=(*prc))
  155.   {
  156.     free ((*prc));
  157.     (*prc) = NULL;
  158.   }
  159. }
  162. /*!
  163.  *************************************************************************************
  164.  * brief
  165.  *    Initialize rate control parameters
  166.  *
  167.  *************************************************************************************
  168. */
  169. void rc_init_seq(rc_quadratic *prc)
  170. {
  171.   double L1,L2,L3,bpp;
  172.   int qp, i;
  174.   switch ( params->RCUpdateMode )
  175.   {
  176.   case RC_MODE_0:
  177.     updateQP = updateQPRC0;
  178.     break;
  179.   case RC_MODE_1:
  180.     updateQP = updateQPRC1;
  181.     break;
  182.   case RC_MODE_2:
  183.     updateQP = updateQPRC2;
  184.     break;
  185.   case RC_MODE_3:
  186.     updateQP = updateQPRC3;
  187.     break;
  188.   default:
  189.     updateQP = updateQPRC0;
  190.     break;
  191.   }
  192.   // set function pointers
  193.   rc_update_pict_frame_ptr = rc_update_pict_frame;
  194.   rc_update_picture_ptr    = rc_update_picture;
  195.   rc_init_pict_ptr         = rc_init_pict;
  197.   prc->Xp=0;
  198.   prc->Xb=0;
  200.   prc->bit_rate = (float) params->bit_rate;
  201.   prc->frame_rate = (img->framerate *(float)(params->successive_Bframe + 1)) / (float) (params->jumpd + 1);
  202.   prc->PrevBitRate = prc->bit_rate;
  204.   /*compute the total number of MBs in a frame*/
  205.   if(params->basicunit > img->FrameSizeInMbs)
  206.     params->basicunit = img->FrameSizeInMbs;
  207.   if(params->basicunit < img->FrameSizeInMbs)
  208.     prc->TotalNumberofBasicUnit = img->FrameSizeInMbs/params->basicunit;
  209.   else
  210.     prc->TotalNumberofBasicUnit = 1;
  212.   /*initialize the parameters of fluid flow traffic model*/
  213.   generic_RC->CurrentBufferFullness = 0;
  214.   prc->GOPTargetBufferLevel = (double) generic_RC->CurrentBufferFullness;
  216.   /*initialize the previous window size*/
  217.   prc->m_windowSize    = 0;
  218.   prc->MADm_windowSize = 0;
  219.   generic_RC->NumberofCodedBFrame = 0;
  220.   prc->NumberofCodedPFrame = 0;
  221.   generic_RC->NumberofGOP         = 0;
  222.   /*remaining # of bits in GOP */
  223.   generic_RC->RemainingBits = 0;
  224.   /*control parameter */
  225.   if(params->successive_Bframe>0)
  226.   {
  227.     prc->GAMMAP=0.25;
  228.     prc->BETAP=0.9;
  229.   }
  230.   else
  231.   {
  232.     prc->GAMMAP=0.5;
  233.     prc->BETAP=0.5;
  234.   }
  236.   /*quadratic rate-distortion model*/
  237.   prc->PPreHeader=0;
  239.   prc->Pm_X1 = prc->bit_rate * 1.0;
  240.   prc->Pm_X2 = 0.0;
  241.   /* linear prediction model for P picture*/
  242.   prc->PMADPictureC1 = 1.0;
  243.   prc->PMADPictureC2 = 0.0;
  245.   // Initialize values
  246.   for(i=0;i<21;i++)
  247.   {
  248.     prc->Pm_rgQp[i] = 0;
  249.     prc->Pm_rgRp[i] = 0.0;
  250.     prc->PPictureMAD[i] = 0.0;
  251.   }
  253.   //Define the largest variation of quantization parameters
  254.   prc->PMaxQpChange = params->RCMaxQPChange;
  256.   /*basic unit layer rate control*/
  257.   prc->PAveHeaderBits1 = 0;
  258.   prc->PAveHeaderBits3 = 0;
  259.   prc->DDquant = (prc->TotalNumberofBasicUnit>=9 ? 1 : 2);
  261.   prc->MBPerRow = img->PicWidthInMbs;
  263.   /*adaptive field/frame coding*/
  264.   generic_RC->FieldControl=0;  
  266.   if (params->SeinitialQP==0)
  267.   {
  268.     /*compute the initial QP*/
  269.     bpp = 1.0*prc->bit_rate /(prc->frame_rate*img->size);
  271.     if (img->width == 176)
  272.     {
  273.       L1 = 0.1;
  274.       L2 = 0.3;
  275.       L3 = 0.6;
  276.     }
  277.     else if (img->width == 352)
  278.     {
  279.       L1 = 0.2;
  280.       L2 = 0.6;
  281.       L3 = 1.2;
  282.     }
  283.     else
  284.     {
  285.       L1 = 0.6;
  286.       L2 = 1.4;
  287.       L3 = 2.4;
  288.     }
  289.     if (bpp<= L1)
  290.       qp = 35;
  291.     else if(bpp<=L2)
  292.       qp = 25;
  293.     else if(bpp<=L3)
  294.       qp = 20;
  295.     else
  296.       qp = 10;
  297.     params->SeinitialQP = qp;
  298.   }
  299. }
  301. /*!
  302.  *************************************************************************************
  303.  * brief
  304.  *    Initialize one GOP
  305.  *
  306.  *************************************************************************************
  307. */
  308. void rc_init_GOP(rc_quadratic *prc, int np, int nb)
  309. {
  310.   Boolean Overum=FALSE;
  311.   int OverBits, OverDuantQp;
  312.   int GOPDquant;
  313.   int64 AllocatedBits;
  315.   // bit allocation for RC_MODE_3
  316.   switch( params->RCUpdateMode )
  317.   {
  318.   case RC_MODE_3:
  319.     {
  320.       int sum = 0, tmp, level, levels = 0, num_frames[RC_MAX_TEMPORAL_LEVELS];
  321.       float numer, denom;
  322.       int gop = params->successive_Bframe + 1;
  323.       memset( num_frames, 0, RC_MAX_TEMPORAL_LEVELS * sizeof(int) );
  324.       // are there any B frames?
  325.       if ( params->successive_Bframe )
  326.       {
  327.         if ( params->HierarchicalCoding == 1 ) // two layers: even/odd
  328.         {
  329.           levels = 2;
  330.           num_frames[0] = params->successive_Bframe >> 1;
  331.           num_frames[1] = (params->successive_Bframe - num_frames[0]) >= 0 ? (params->successive_Bframe - num_frames[0]) : 0;
  332.         }
  333.         else if ( params->HierarchicalCoding == 2 ) // binary hierarchical structure
  334.         {
  335.           // check if gop is power of two
  336.           tmp = gop;
  337.           while ( tmp )
  338.           {
  339.             sum += tmp & 1;
  340.             tmp >>= 1;
  341.           }
  342.           assert( sum == 1 );
  344.           // determine number of levels
  345.           levels = 0;
  346.           tmp = gop;
  347.           while ( tmp > 1 )
  348.           {
  349.             tmp >>= 1; // divide by 2          
  350.             num_frames[levels] = 1 << levels;
  351.             levels++;          
  352.           }
  353.           assert( levels >= 1 && levels <= RC_MAX_TEMPORAL_LEVELS );        
  354.         }
  355.         else if ( params->HierarchicalCoding == 3 )
  356.         {
  357.           fprintf(stderr, "n RCUpdateMode=3 and HierarchicalCoding == 3 are currently not supported"); // This error message should be moved elsewhere and have proper memory deallocation
  358.           exit(1);
  359.         }
  360.         else // all frames of the same priority - level
  361.         {
  362.           levels = 1;
  363.           num_frames[0] = params->successive_Bframe;
  364.         }
  365.         generic_RC->temporal_levels = levels;      
  366.       }
  367.       else
  368.       {
  369.         for ( level = 0; level < RC_MAX_TEMPORAL_LEVELS; level++ )
  370.         {
  371.           params->RCBSliceBitRatio[level] = 0.0F;
  372.         }
  373.         generic_RC->temporal_levels = 0;
  374.       }
  375.       // calculate allocated bits for each type of frame
  376.       numer = (float)(( (!params->intra_period ? 1 : params->intra_period) * gop) * ((double)params->bit_rate / params->FrameRate));
  377.       denom = 0.0F;
  379.       for ( level = 0; level < levels; level++ )
  380.       {
  381.         denom += (float)(num_frames[level] * params->RCBSliceBitRatio[level]);
  382.         generic_RC->hierNb[level] = num_frames[level] * np;
  383.       }
  384.       denom += 1.0F;
  385.       if ( params->intra_period >= 1 )
  386.       {
  387.         denom *= (float)params->intra_period;
  388.         denom += (float)params->RCISliceBitRatio - 1.0F;
  389.       }
  391.       // set bit targets for each type of frame
  392.       generic_RC->RCPSliceBits = (int) floor( numer / denom + 0.5F );
  393.       generic_RC->RCISliceBits = (params->intra_period) ? (int)(params->RCISliceBitRatio * generic_RC->RCPSliceBits + 0.5) : 0;
  395.       for ( level = 0; level < levels; level++ )
  396.       {
  397.         generic_RC->RCBSliceBits[level] = (int)floor(params->RCBSliceBitRatio[level] * generic_RC->RCPSliceBits + 0.5);
  398.       }
  400.       generic_RC->NISlice = (params->intra_period) ? ((params->no_frames - 1) / params->intra_period) : 0;
  401.       generic_RC->NPSlice = params->no_frames - 1 - generic_RC->NISlice;
  402.     }
  403.     break;
  404.   default:
  405.     break;
  406.   }
  408.   /* check if the last GOP over uses its budget. If yes, the initial QP of the I frame in
  409.   the coming  GOP will be increased.*/
  411.   if(generic_RC->RemainingBits<0)
  412.     Overum=TRUE;
  413.   OverBits=-(int)(generic_RC->RemainingBits);
  415.   /*initialize the lower bound and the upper bound for the target bits of each frame, HRD consideration*/
  416.   prc->LowerBound  = (int)(generic_RC->RemainingBits + prc->bit_rate / prc->frame_rate);
  417.   prc->UpperBound1 = (int)(generic_RC->RemainingBits + (prc->bit_rate * 2.048));
  419.   /*compute the total number of bits for the current GOP*/
  420.   AllocatedBits = (int64) floor((1 + np + nb) * prc->bit_rate / prc->frame_rate + 0.5);
  421.   generic_RC->RemainingBits += AllocatedBits;
  422.   prc->Np = np;
  423.   prc->Nb = nb;
  425.   OverDuantQp=(int)(8 * OverBits/AllocatedBits+0.5);
  426.   prc->GOPOverdue=FALSE;
  428.   /*field coding*/
  429.   //generic_RC->NoGranularFieldRC = ( params->PicInterlace || !params->MbInterlace || params->basicunit != img->FrameSizeInMbs );
  430.   if ( !params->PicInterlace && params->MbInterlace && params->basicunit == img->FrameSizeInMbs )
  431.     generic_RC->NoGranularFieldRC = 0;
  432.   else
  433.     generic_RC->NoGranularFieldRC = 1;
  435.   /*Compute InitialQp for each GOP*/
  436.   prc->TotalPFrame=np;
  437.   generic_RC->NumberofGOP++;
  438.   if(generic_RC->NumberofGOP==1)
  439.   {
  440.     prc->MyInitialQp = params->SeinitialQP;
  441.     prc->CurrLastQP = prc->MyInitialQp - 1; //recent change -0;
  442.     prc->QPLastGOP   = prc->MyInitialQp;
  444.     prc->PAveFrameQP   = prc->MyInitialQp;
  445.     prc->m_Qc          = prc->PAveFrameQP;
  446.     prc->FieldQPBuffer = prc->PAveFrameQP;
  447.     prc->FrameQPBuffer = prc->PAveFrameQP;
  448.     prc->PAverageQp    = prc->PAveFrameQP;
  449.   }
  450.   else
  451.   {
  452.     /*adaptive field/frame coding*/
  453.     if( params->PicInterlace == ADAPTIVE_CODING || params->MbInterlace )
  454.     {
  455.       if (generic_RC->FieldFrame == 1)
  456.       {
  457.         prc->TotalQpforPPicture += prc->FrameQPBuffer;
  458.         prc->QPLastPFrame = prc->FrameQPBuffer;
  459.       }
  460.       else
  461.       {
  462.         prc->TotalQpforPPicture += prc->FieldQPBuffer;
  463.         prc->QPLastPFrame = prc->FieldQPBuffer;
  464.       }
  465.     }
  466.     /*compute the average QP of P frames in the previous GOP*/
  467.     prc->PAverageQp=(int)(1.0 * prc->TotalQpforPPicture / prc->NumberofPPicture+0.5);
  469.     GOPDquant=(int)((1.0*(np+nb+1)/15.0) + 0.5);
  470.     if(GOPDquant>2)
  471.       GOPDquant=2;
  473.     prc->PAverageQp -= GOPDquant;
  475.     if (prc->PAverageQp > (prc->QPLastPFrame - 2))
  476.       prc->PAverageQp--;
  478.     // QP is constrained by QP of previous QP
  479.     prc->PAverageQp = iClip3(prc->QPLastGOP - 2, prc->QPLastGOP + 2, prc->PAverageQp);
  480.     // Also clipped within range.
  481.     prc->PAverageQp = iClip3(img->RCMinQP,  img->RCMaxQP,  prc->PAverageQp);
  483.     prc->MyInitialQp = prc->PAverageQp;
  484.     prc->Pm_Qp       = prc->PAverageQp;
  485.     prc->PAveFrameQP = prc->PAverageQp;
  486.     prc->QPLastGOP   = prc->MyInitialQp;
  487.     prc->PrevLastQP = prc->CurrLastQP;
  488.     prc->CurrLastQP = prc->MyInitialQp - 1;
  489.   }
  491.   prc->TotalQpforPPicture=0;
  492.   prc->NumberofPPicture=0;
  493.   prc->NumberofBFrames=0;
  494. }
  497. /*!
  498.  *************************************************************************************
  499.  * brief
  500.  *    Initialize one picture
  501.  *
  502.  *************************************************************************************
  503. */
  504. void rc_init_pict(rc_quadratic *prc, int fieldpic,int topfield,int targetcomputation, float mult)
  505. {
  506.   int tmp_T;
  508.   /* compute the total number of basic units in a frame */
  509.   if(params->MbInterlace)
  510.     prc->TotalNumberofBasicUnit = img->FrameSizeInMbs / img->BasicUnit;
  511.   else
  512.     prc->TotalNumberofBasicUnit = img->FrameSizeInMbs / params->basicunit;
  514.   img->NumberofCodedMacroBlocks = 0;
  516.   /* Normally, the bandwidth for the VBR case is estimated by
  517.      a congestion control algorithm. A bandwidth curve can be predefined if we only want to
  518.      test the proposed algorithm */
  519.   if(params->channel_type==1)
  520.   {
  521.     if(prc->NumberofCodedPFrame==58)
  522.       prc->bit_rate *= 1.5;
  523.     else if(prc->NumberofCodedPFrame==59)
  524.       prc->PrevBitRate = prc->bit_rate;
  525.   }
  527.   /* predefine a target buffer level for each frame */
  528.   if((fieldpic||topfield) && targetcomputation)
  529.   {
  530.     if ( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number !=0)) )
  531.     {
  532.       /* Since the available bandwidth may vary at any time, the total number of
  533.       bits is updated picture by picture*/
  534.       if(prc->PrevBitRate!=prc->bit_rate)
  535.         generic_RC->RemainingBits +=(int) floor((prc->bit_rate-prc->PrevBitRate)*(prc->Np + prc->Nb)/prc->frame_rate+0.5);
  537.       /* predefine the  target buffer level for each picture.
  538.       frame layer rate control */
  539.       if(img->BasicUnit == img->FrameSizeInMbs)
  540.       {
  541.         if(prc->NumberofPPicture==1)
  542.         {
  543.           prc->TargetBufferLevel = (double) generic_RC->CurrentBufferFullness;
  544.           prc->DeltaP = (generic_RC->CurrentBufferFullness - prc->GOPTargetBufferLevel) / (prc->TotalPFrame-1);
  545.           prc->TargetBufferLevel -= prc->DeltaP;
  546.         }
  547.         else if(prc->NumberofPPicture>1)
  548.           prc->TargetBufferLevel -= prc->DeltaP;
  549.       }
  550.       /* basic unit layer rate control */
  551.       else
  552.       {
  553.         if(prc->NumberofCodedPFrame>0)
  554.         {
  555.           /* adaptive frame/field coding */
  556.           if(((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))&&(generic_RC->FieldControl==1))
  557.             memcpy((void *)prc->FCBUPFMAD,(void *)prc->FCBUCFMAD, prc->TotalNumberofBasicUnit * sizeof(double));
  558.           else
  559.             memcpy((void *)prc->BUPFMAD,(void *)prc->BUCFMAD, prc->TotalNumberofBasicUnit * sizeof(double));
  560.         }
  562.         if(generic_RC->NumberofGOP==1)
  563.         {
  564.           if(prc->NumberofPPicture==1)
  565.           {
  566.             prc->TargetBufferLevel = (double) generic_RC->CurrentBufferFullness;
  567.             prc->DeltaP = (generic_RC->CurrentBufferFullness - prc->GOPTargetBufferLevel)/(prc->TotalPFrame - 1);
  568.             prc->TargetBufferLevel -= prc->DeltaP;
  569.           }
  570.           else if(prc->NumberofPPicture>1)
  571.             prc->TargetBufferLevel -= prc->DeltaP;
  572.         }
  573.         else if(generic_RC->NumberofGOP>1)
  574.         {
  575.           if(prc->NumberofPPicture==0)
  576.           {
  577.             prc->TargetBufferLevel = (double) generic_RC->CurrentBufferFullness;
  578.             prc->DeltaP = (generic_RC->CurrentBufferFullness - prc->GOPTargetBufferLevel) / prc->TotalPFrame;
  579.             prc->TargetBufferLevel -= prc->DeltaP;
  580.           }
  581.           else if(prc->NumberofPPicture>0)
  582.             prc->TargetBufferLevel -= prc->DeltaP;
  583.         }
  584.       }
  586.       if(prc->NumberofCodedPFrame==1)
  587.         prc->AveWp = prc->Wp;
  589.       if((prc->NumberofCodedPFrame<8)&&(prc->NumberofCodedPFrame>1))
  590.         prc->AveWp = (prc->AveWp + prc->Wp * (prc->NumberofCodedPFrame-1))/prc->NumberofCodedPFrame;
  591.       else if(prc->NumberofCodedPFrame>1)
  592.         prc->AveWp = (prc->Wp + 7 * prc->AveWp) / 8;
  594.       // compute the average complexity of B frames
  595.       if(params->successive_Bframe>0)
  596.       {
  597.         // compute the target buffer level
  598.         prc->TargetBufferLevel += (prc->AveWp * (params->successive_Bframe + 1)*prc->bit_rate
  599.           /(prc->frame_rate*(prc->AveWp+prc->AveWb*params->successive_Bframe))-prc->bit_rate/prc->frame_rate);
  600.       }
  601.     }
  602.     else if ( img->type == B_SLICE )
  603.     {
  604.       /* update the total number of bits if the bandwidth is changed*/
  605.       if(prc->PrevBitRate != prc->bit_rate)
  606.         generic_RC->RemainingBits +=(int) floor((prc->bit_rate-prc->PrevBitRate) * (prc->Np + prc->Nb) / prc->frame_rate+0.5);
  607.       if(generic_RC->NumberofCodedBFrame == 1)
  608.       {
  609.         if(prc->NumberofCodedPFrame == 1)
  610.         {
  611.           prc->AveWp = prc->Wp;
  612.         }
  613.         prc->AveWb = prc->Wb;
  614.       }
  615.       else if(generic_RC->NumberofCodedBFrame > 1)
  616.       {
  617.         //compute the average weight
  618.         if(generic_RC->NumberofCodedBFrame<8)
  619.           prc->AveWb = (prc->AveWb + prc->Wb*(generic_RC->NumberofCodedBFrame-1)) / generic_RC->NumberofCodedBFrame;
  620.         else
  621.           prc->AveWb = (prc->Wb + 7 * prc->AveWb) / 8;
  622.       }
  623.     }
  624.     /* Compute the target bit for each frame */
  625.     if( img->type == P_SLICE || ( (img->number != 0) && (params->RCUpdateMode == RC_MODE_1 || params->RCUpdateMode == RC_MODE_3 ) ) )
  626.     {
  627.       /* frame layer rate control */
  628.       if(img->BasicUnit == img->FrameSizeInMbs || (params->RCUpdateMode == RC_MODE_3) )
  629.       {
  630.         if(prc->NumberofCodedPFrame>0)
  631.         {
  632.           if (params->RCUpdateMode == RC_MODE_3)
  633.           {
  634.             int level_idx = (img->type == B_SLICE && params->HierarchicalCoding) ? (generic_RC->temporal_levels - 1 - gop_structure[img->b_frame_to_code-1].hierarchy_layer) : 0;
  635.             int bitrate = (img->type == B_SLICE) ? generic_RC->RCBSliceBits[ level_idx ]
  636.             : ( img->type == P_SLICE ? generic_RC->RCPSliceBits : generic_RC->RCISliceBits );
  637.             int level, denom = generic_RC->NISlice * generic_RC->RCISliceBits + generic_RC->NPSlice * generic_RC->RCPSliceBits;
  638.             if ( params->HierarchicalCoding )
  639.             {
  640.               for ( level = 0; level < generic_RC->temporal_levels; level++ )
  641.                 denom += generic_RC->hierNb[ level ] * generic_RC->RCBSliceBits[ level ];
  642.             }
  643.             else
  644.             {
  645.               denom += generic_RC->hierNb[0] * generic_RC->RCBSliceBits[0];
  646.             }
  647.             // target due to remaining bits
  648.             prc->Target = (int) floor( (float)(1.0 * bitrate * generic_RC->RemainingBits) / (float)denom + 0.5F );
  649.             // target given original taget rate and buffer considerations
  650.             tmp_T  = imax(0, (int) floor( (double)bitrate - prc->GAMMAP * (generic_RC->CurrentBufferFullness-prc->TargetBufferLevel) + 0.5) );
  651.             // translate Target rate from B or I "domain" to P domain since the P RC model is going to be used to select the QP
  652.             // for hierarchical coding adjust the target QP to account for different temporal levels
  653.             switch( img->type )
  654.             {
  655.             case B_SLICE:
  656.               prc->Target = (int) floor( (float)prc->Target / params->RCBoverPRatio + 0.5F);
  657.               break;
  658.             case I_SLICE:
  659.               prc->Target = (int) floor( (float)prc->Target / (params->RCIoverPRatio * 4.0) + 0.5F); // 4x accounts for the fact that header bits reduce the percentage of texture
  660.               break;
  661.             case P_SLICE:
  662.             default:
  663.               break;
  664.             }
  665.           }
  666.           else
  667.           {
  668.             prc->Target = (int) floor( prc->Wp * generic_RC->RemainingBits / (prc->Np * prc->Wp + prc->Nb * prc->Wb) + 0.5);
  669.             tmp_T  = imax(0, (int) floor(prc->bit_rate / prc->frame_rate - prc->GAMMAP * (generic_RC->CurrentBufferFullness-prc->TargetBufferLevel) + 0.5));
  670.             prc->Target = (int) floor(prc->BETAP * (prc->Target - tmp_T) + tmp_T + 0.5);
  671.           }
  672.         }
  673.       }
  674.       /* basic unit layer rate control */
  675.       else
  676.       {
  677.         if(((generic_RC->NumberofGOP == 1)&&(prc->NumberofCodedPFrame>0))
  678.           || (generic_RC->NumberofGOP > 1))
  679.         {
  680.           prc->Target = (int) (floor( prc->Wp * generic_RC->RemainingBits / (prc->Np * prc->Wp + prc->Nb * prc->Wb) + 0.5));
  681.           tmp_T  = imax(0, (int) (floor(prc->bit_rate / prc->frame_rate - prc->GAMMAP * (generic_RC->CurrentBufferFullness-prc->TargetBufferLevel) + 0.5)));
  682.           prc->Target = (int) (floor(prc->BETAP * (prc->Target - tmp_T) + tmp_T + 0.5));
  683.         }
  684.       }
  685.       prc->Target = (int)(mult * prc->Target);
  687.       /* HRD consideration */
  688.       if ( params->RCUpdateMode != RC_MODE_3 || img->type == P_SLICE )
  689.         prc->Target = iClip3(prc->LowerBound, prc->UpperBound2, prc->Target);
  690.       if((topfield) || (fieldpic && ((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))))
  691.         prc->TargetField=prc->Target;
  692.     }
  693.   }
  695.   if(fieldpic || topfield)
  696.   {
  697.     /* frame layer rate control */
  698.     generic_RC->NumberofHeaderBits  = 0;
  699.     generic_RC->NumberofTextureBits = 0;
  701.     /* basic unit layer rate control */
  702.     if(img->BasicUnit < img->FrameSizeInMbs)
  703.     {
  704.       prc->TotalFrameQP = 0;
  705.       generic_RC->NumberofBasicUnitHeaderBits  = 0;
  706.       generic_RC->NumberofBasicUnitTextureBits = 0;
  707.       generic_RC->TotalMADBasicUnit = 0;
  708.       if(generic_RC->FieldControl==0)
  709.         prc->NumberofBasicUnit = prc->TotalNumberofBasicUnit;
  710.       else
  711.         prc->NumberofBasicUnit = prc->TotalNumberofBasicUnit >> 1;
  712.     }
  713.   }
  715.   if( ( img->type==P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) ) && img->BasicUnit < img->FrameSizeInMbs && generic_RC->FieldControl == 1 )
  716.   {
  717.     /* top field at basic unit layer rate control */
  718.     if(topfield)
  719.     {
  720.       prc->bits_topfield=0;
  721.       prc->Target=(int)(prc->TargetField*0.6);
  722.     }
  723.     /* bottom field at basic unit layer rate control */
  724.     else
  725.     {
  726.       prc->Target=prc->TargetField-prc->bits_topfield;
  727.       generic_RC->NumberofBasicUnitHeaderBits=0;
  728.       generic_RC->NumberofBasicUnitTextureBits=0;
  729.       generic_RC->TotalMADBasicUnit=0;
  730.       prc->NumberofBasicUnit=prc->TotalNumberofBasicUnit >> 1;
  731.     }
  732.   }
  733. }
  735. /*!
  736.  *************************************************************************************
  737.  * brief
  738.  *    update one picture after frame/field encoding
  739.  *
  740.  * param nbits
  741.  *    number of bits used for picture
  742.  *
  743.  *************************************************************************************
  744. */
  745. void rc_update_pict(rc_quadratic *prc, int nbits)
  746. {
  747.   int delta_bits = (nbits - (int)floor(prc->bit_rate / prc->frame_rate + 0.5F) );
  748.   // remaining # of bits in GOP
  749.   generic_RC->RemainingBits -= nbits; 
  750.   generic_RC->CurrentBufferFullness += delta_bits;
  752.   // update the lower bound and the upper bound for the target bits of each frame, HRD consideration
  753.   prc->LowerBound  -= (int) delta_bits;
  754.   prc->UpperBound1 -= (int) delta_bits;
  755.   prc->UpperBound2  = (int)(OMEGA * prc->UpperBound1);
  757.   // update the parameters of quadratic R-D model
  758.   if( img->type==P_SLICE || (params->RCUpdateMode == RC_MODE_1 && img->frm_number) )
  759.   {
  760.     updateRCModel(prc);
  761.     if ( params->RCUpdateMode == RC_MODE_3 )
  762.       prc->PreviousWholeFrameMAD = ComputeFrameMAD();
  763.   }
  764. }
  766. /*!
  767.  *************************************************************************************
  768.  * brief
  769.  *    update one picture after coding
  770.  *
  771.  * param bits
  772.  *    number of bits used for picture
  773.  *
  774.  *************************************************************************************
  775. */
  777. void rc_update_picture( int bits )
  778. {
  779.   rc_update_pict(quadratic_RC, bits);
  780. }
  782. int updateComplexity( rc_quadratic *prc, Boolean is_updated, int nbits )
  783. {
  784.   double Avem_Qc;
  786.   /* frame layer rate control */
  787.   if(img->BasicUnit == img->FrameSizeInMbs)
  788.     return ((int) floor(nbits * prc->m_Qc + 0.5));
  789.   /* basic unit layer rate control */
  790.   else
  791.   {
  792.     if( is_updated )
  793.     {
  794.       if( generic_RC->NoGranularFieldRC == 0 || generic_RC->FieldControl == 0 )
  795.       {
  796.         Avem_Qc = (double)prc->TotalFrameQP / (double)prc->TotalNumberofBasicUnit;
  797.         return ((int)floor(nbits * Avem_Qc + 0.5));
  798.       }
  799.     }
  800.     else if( img->type == B_SLICE )
  801.       return ((int) floor(nbits * prc->m_Qc + 0.5));
  802.   }
  803.   return 0;
  804. }
  806. void updatePparams( rc_quadratic *prc, int complexity )
  807. {
  808.   prc->Xp = complexity;
  809.   prc->Np--;
  810.   prc->Wp = prc->Xp;
  811.   prc->Pm_Hp = generic_RC->NumberofHeaderBits;
  812.   prc->NumberofCodedPFrame++;
  813.   prc->NumberofPPicture++;
  814. }
  816. void updateBparams( rc_quadratic *prc, int complexity )
  817. {
  818.   prc->Xb = complexity;
  819.   prc->Nb--;
  820.   prc->Wb = prc->Xb / THETA;     
  821.   prc->NumberofBFrames++;
  822.   generic_RC->NumberofCodedBFrame++;
  823. }
  825. /*! 
  826.  *************************************************************************************
  827.  * brief
  828.  *    update after frame encoding
  829.  *
  830.  * param nbits
  831.  *    number of bits used for frame
  832.  *
  833.  *************************************************************************************
  834. */
  835. void rc_update_pict_frame(rc_quadratic *prc, int nbits)
  836. {
  837.   /* update the complexity weight of I, P, B frame */  
  838.   int complexity = 0;
  840.   switch( params->RCUpdateMode )
  841.   {
  842.   case RC_MODE_0:
  843.   case RC_MODE_2:
  844.   default:
  845.     complexity = updateComplexity( prc, (Boolean) (img->type == P_SLICE), nbits );
  846.     if ( img->type == P_SLICE )
  847.     {
  848.       if( generic_RC->NoGranularFieldRC == 0 || generic_RC->FieldControl == 0 )
  849.         updatePparams( prc, complexity );
  850.       else
  851.         generic_RC->NoGranularFieldRC = 0;
  852.     }
  853.     else if ( img->type == B_SLICE )
  854.       updateBparams( prc, complexity );
  855.     break;
  856.   case RC_MODE_1:
  857.     complexity = updateComplexity( prc, (Boolean) (img->number != 0), nbits );
  858.     if ( img->number != 0 )
  859.     {
  860.       if( generic_RC->NoGranularFieldRC == 0 || generic_RC->FieldControl == 0 )
  861.         updatePparams( prc, complexity );
  862.       else
  863.         generic_RC->NoGranularFieldRC = 0;
  864.     }
  865.     break;
  866.   case RC_MODE_3:
  867.     complexity = updateComplexity( prc, (Boolean) (img->type == P_SLICE), nbits );
  868.     if (img->type == I_SLICE && (img->number != 0))
  869.       generic_RC->NISlice--;
  871.     if ( img->type == P_SLICE )
  872.     {
  873.       if( generic_RC->NoGranularFieldRC == 0 || generic_RC->FieldControl == 0 )
  874.       {
  875.         updatePparams( prc, complexity );
  876.         generic_RC->NPSlice--;
  877.       }
  878.       else
  879.         generic_RC->NoGranularFieldRC = 0;
  880.     }
  881.     else if ( img->type == B_SLICE )
  882.     {
  883.       updateBparams( prc, complexity );
  884.       generic_RC->hierNb[ params->HierarchicalCoding ? (generic_RC->temporal_levels - 1 - gop_structure[img->b_frame_to_code-1].hierarchy_layer) : 0 ]--;
  885.     }
  886.     break;
  887.   }   
  888. }
  891. /*!
  892.  *************************************************************************************
  893.  * brief
  894.  *    update the parameters of quadratic R-D model
  895.  *
  896.  *************************************************************************************
  897. */
  898. void updateRCModel (rc_quadratic *prc)
  899. {
  900.   int n_windowSize;
  901.   int i;
  902.   double std = 0.0, threshold;
  903.   int m_Nc = prc->NumberofCodedPFrame;
  904.   Boolean MADModelFlag = FALSE;
  905.   static Boolean m_rgRejected[RC_MODEL_HISTORY];
  906.   static double  error       [RC_MODEL_HISTORY];
  908.   if( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) )
  909.   {
  910.     /*frame layer rate control*/
  911.     if(img->BasicUnit == img->FrameSizeInMbs)
  912.     {
  913.       prc->CurrentFrameMAD = ComputeFrameMAD();
  914.       m_Nc=prc->NumberofCodedPFrame;
  915.     }
  916.     /*basic unit layer rate control*/
  917.     else
  918.     {
  919.       /*compute the MAD of the current basic unit*/
  920.       prc->CurrentFrameMAD = (double) ((generic_RC->TotalMADBasicUnit >> 8)/img->BasicUnit);
  921.       generic_RC->TotalMADBasicUnit=0;
  923.       /* compute the average number of header bits*/
  924.       prc->CodedBasicUnit=prc->TotalNumberofBasicUnit-prc->NumberofBasicUnit;
  925.       if(prc->CodedBasicUnit > 0)
  926.       {
  927.         prc->PAveHeaderBits1=(int)((double)(prc->PAveHeaderBits1*(prc->CodedBasicUnit-1)+
  928.           generic_RC->NumberofBasicUnitHeaderBits)/prc->CodedBasicUnit+0.5);
  929.         if(prc->PAveHeaderBits3 == 0)
  930.           prc->PAveHeaderBits2 = prc->PAveHeaderBits1;
  931.         else
  932.         {
  933.           prc->PAveHeaderBits2 = (int)((double)(prc->PAveHeaderBits1 * prc->CodedBasicUnit+
  934.             prc->PAveHeaderBits3 * prc->NumberofBasicUnit)/prc->TotalNumberofBasicUnit+0.5);
  935.         }
  936.       }
  937.       /*update the record of MADs for reference*/
  938.       if(((params->PicInterlace == ADAPTIVE_CODING) || (params->MbInterlace)) && (generic_RC->FieldControl == 1))
  939.         prc->FCBUCFMAD[prc->TotalNumberofBasicUnit-1-prc->NumberofBasicUnit]=prc->CurrentFrameMAD;
  940.       else
  941.         prc->BUCFMAD[prc->TotalNumberofBasicUnit-1-prc->NumberofBasicUnit]=prc->CurrentFrameMAD;
  943.       if(prc->NumberofBasicUnit != 0)
  944.         m_Nc = prc->NumberofCodedPFrame * prc->TotalNumberofBasicUnit + prc->CodedBasicUnit;
  945.       else
  946.         m_Nc = (prc->NumberofCodedPFrame-1) * prc->TotalNumberofBasicUnit + prc->CodedBasicUnit;
  947.     }
  949.     if(m_Nc > 1)
  950.       MADModelFlag=TRUE;
  952.     prc->PPreHeader = generic_RC->NumberofHeaderBits;
  953.     for (i = (RC_MODEL_HISTORY-2); i > 0; i--)
  954.     {// update the history
  955.       prc->Pm_rgQp[i] = prc->Pm_rgQp[i - 1];
  956.       prc->m_rgQp[i]  = prc->Pm_rgQp[i];
  957.       prc->Pm_rgRp[i] = prc->Pm_rgRp[i - 1];
  958.       prc->m_rgRp[i]  = prc->Pm_rgRp[i];
  959.     }
  960.     prc->Pm_rgQp[0] = QP2Qstep(prc->m_Qc); //*1.0/prc->CurrentFrameMAD;
  961.     /*frame layer rate control*/
  962.     if(img->BasicUnit == img->FrameSizeInMbs)
  963.       prc->Pm_rgRp[0] = generic_RC->NumberofTextureBits*1.0/prc->CurrentFrameMAD;
  964.     /*basic unit layer rate control*/
  965.     else
  966.       prc->Pm_rgRp[0] = generic_RC->NumberofBasicUnitTextureBits*1.0/prc->CurrentFrameMAD;
  968.     prc->m_rgQp[0] = prc->Pm_rgQp[0];
  969.     prc->m_rgRp[0] = prc->Pm_rgRp[0];
  970.     prc->m_X1 = prc->Pm_X1;
  971.     prc->m_X2 = prc->Pm_X2;
  973.     /*compute the size of window*/
  974.     n_windowSize = (prc->CurrentFrameMAD>prc->PreviousFrameMAD)
  975.       ? (int)(prc->PreviousFrameMAD/prc->CurrentFrameMAD * (RC_MODEL_HISTORY-1) )
  976.       : (int)(prc->CurrentFrameMAD/prc->PreviousFrameMAD *(RC_MODEL_HISTORY-1));
  977.     n_windowSize=iClip3(1, m_Nc, n_windowSize);
  978.     n_windowSize=imin(n_windowSize,prc->m_windowSize+1);
  979.     n_windowSize=imin(n_windowSize,(RC_MODEL_HISTORY-1));
  981.     /*update the previous window size*/
  982.     prc->m_windowSize=n_windowSize;
  984.     for (i = 0; i < (RC_MODEL_HISTORY-1); i++)
  985.     {
  986.       m_rgRejected[i] = FALSE;
  987.     }
  989.     // initial RD model estimator
  990.     RCModelEstimator (prc, n_windowSize, m_rgRejected);
  992.     n_windowSize = prc->m_windowSize;
  993.     // remove outlier
  995.     for (i = 0; i < (int) n_windowSize; i++)
  996.     {
  997.       error[i] = prc->m_X1 / prc->m_rgQp[i] + prc->m_X2 / (prc->m_rgQp[i] * prc->m_rgQp[i]) - prc->m_rgRp[i];
  998.       std += error[i] * error[i];
  999.     }
  1000.     threshold = (n_windowSize == 2) ? 0 : sqrt (std / n_windowSize);
  1001.     for (i = 0; i < (int) n_windowSize; i++)
  1002.     {
  1003.       if (fabs(error[i]) > threshold)
  1004.         m_rgRejected[i] = TRUE;
  1005.     }
  1006.     // always include the last data point
  1007.     m_rgRejected[0] = FALSE;
  1009.     // second RD model estimator
  1010.     RCModelEstimator (prc, n_windowSize, m_rgRejected);
  1012.     if( MADModelFlag )
  1013.       updateMADModel(prc);
  1014.     else if( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) )
  1015.       prc->PPictureMAD[0] = prc->CurrentFrameMAD;
  1016.   }
  1017. }
  1019. /*!
  1020.  *************************************************************************************
  1021.  * brief
  1022.  *    Model Estimator
  1023.  *
  1024.  *************************************************************************************
  1025. */
  1026. void RCModelEstimator (rc_quadratic *prc, int n_windowSize, Boolean *m_rgRejected)
  1027. {
  1028.   int n_realSize = n_windowSize;
  1029.   int i;
  1030.   double oneSampleQ = 0;
  1031.   double a00 = 0.0, a01 = 0.0, a10 = 0.0, a11 = 0.0, b0 = 0.0, b1 = 0.0;
  1032.   double MatrixValue;
  1033.   Boolean estimateX2 = FALSE;
  1035.   for (i = 0; i < n_windowSize; i++)
  1036.   {// find the number of samples which are not rejected
  1037.     if (m_rgRejected[i])
  1038.       n_realSize--;
  1039.   }
  1041.   // default RD model estimation results
  1042.   prc->m_X1 = prc->m_X2 = 0.0;
  1044.   for (i = 0; i < n_windowSize; i++)
  1045.   {
  1046.     if (!m_rgRejected[i])
  1047.       oneSampleQ = prc->m_rgQp[i];
  1048.   }
  1049.   for (i = 0; i < n_windowSize; i++)
  1050.   {// if all non-rejected Q are the same, take 1st order model
  1051.     if ((prc->m_rgQp[i] != oneSampleQ) && !m_rgRejected[i])
  1052.       estimateX2 = TRUE;
  1053.     if (!m_rgRejected[i])
  1054.       prc->m_X1 += (prc->m_rgQp[i] * prc->m_rgRp[i]) / n_realSize;
  1055.   }
  1057.   // take 2nd order model to estimate X1 and X2
  1058.   if ((n_realSize >= 1) && estimateX2)
  1059.   {
  1060.     for (i = 0; i < n_windowSize; i++)
  1061.     {
  1062.       if (!m_rgRejected[i])
  1063.       {
  1064.         a00  = a00 + 1.0;
  1065.         a01 += 1.0 / prc->m_rgQp[i];
  1066.         a10  = a01;
  1067.         a11 += 1.0 / (prc->m_rgQp[i] * prc->m_rgQp[i]);
  1068.         b0  += prc->m_rgQp[i] * prc->m_rgRp[i];
  1069.         b1  += prc->m_rgRp[i];
  1070.       }
  1071.     }
  1072.     // solve the equation of AX = B
  1073.     MatrixValue=a00*a11-a01*a10;
  1074.     if(fabs(MatrixValue) > 0.000001)
  1075.     {
  1076.       prc->m_X1 = (b0 * a11 - b1 * a01) / MatrixValue;
  1077.       prc->m_X2 = (b1 * a00 - b0 * a10) / MatrixValue;
  1078.     }
  1079.     else
  1080.     {
  1081.       prc->m_X1 = b0 / a00;
  1082.       prc->m_X2 = 0.0;
  1083.     }
  1084.   }
  1085.   if( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) )
  1086.   {
  1087.     prc->Pm_X1 = prc->m_X1;
  1088.     prc->Pm_X2 = prc->m_X2;
  1089.   }
  1090. }
  1092. /*!
  1093.  *************************************************************************************
  1094.  * brief
  1095.  *    update the parameters of linear prediction model
  1096.  *
  1097.  *************************************************************************************
  1098. */
  1099. void updateMADModel (rc_quadratic *prc)
  1100. {
  1101.   int    n_windowSize;
  1102.   int    i;
  1103.   double std = 0.0, threshold;
  1104.   int    m_Nc = prc->NumberofCodedPFrame;
  1105.   static Boolean PictureRejected[RC_MODEL_HISTORY];
  1106.   static double  error          [RC_MODEL_HISTORY];
  1108.   if(prc->NumberofCodedPFrame>0)
  1109.   {
  1110.     //assert (img->type!=P_SLICE);
  1111.     /*frame layer rate control*/
  1112.     if(img->BasicUnit == img->FrameSizeInMbs)
  1113.       m_Nc = prc->NumberofCodedPFrame;
  1114.     else // basic unit layer rate control
  1115.       m_Nc=prc->NumberofCodedPFrame*prc->TotalNumberofBasicUnit+prc->CodedBasicUnit;
  1117.     for (i = (RC_MODEL_HISTORY-2); i > 0; i--)
  1118.     {// update the history
  1119.       prc->PPictureMAD[i]  = prc->PPictureMAD[i - 1];
  1120.       prc->PictureMAD[i]   = prc->PPictureMAD[i];
  1121.       prc->ReferenceMAD[i] = prc->ReferenceMAD[i-1];
  1122.     }
  1123.     prc->PPictureMAD[0] = prc->CurrentFrameMAD;
  1124.     prc->PictureMAD[0]  = prc->PPictureMAD[0];
  1126.     if(img->BasicUnit == img->FrameSizeInMbs)
  1127.       prc->ReferenceMAD[0]=prc->PictureMAD[1];
  1128.     else
  1129.     {
  1130.       if(((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace)) &&(generic_RC->FieldControl==1))
  1131.         prc->ReferenceMAD[0]=prc->FCBUPFMAD[prc->TotalNumberofBasicUnit-1-prc->NumberofBasicUnit];
  1132.       else
  1133.         prc->ReferenceMAD[0]=prc->BUPFMAD[prc->TotalNumberofBasicUnit-1-prc->NumberofBasicUnit];
  1134.     }
  1135.     prc->MADPictureC1 = prc->PMADPictureC1;
  1136.     prc->MADPictureC2 = prc->PMADPictureC2;
  1138.     /*compute the size of window*/
  1139.     n_windowSize = (prc->CurrentFrameMAD > prc->PreviousFrameMAD)
  1140.       ? (int) ((float)(RC_MODEL_HISTORY-1) * prc->PreviousFrameMAD / prc->CurrentFrameMAD)
  1141.       : (int) ((float)(RC_MODEL_HISTORY-1) * prc->CurrentFrameMAD / prc->PreviousFrameMAD);
  1142.     n_windowSize = iClip3(1, (m_Nc-1), n_windowSize);
  1143.     n_windowSize=imin(n_windowSize, imin(20, prc->MADm_windowSize + 1));
  1145.     /*update the previous window size*/
  1146.     prc->MADm_windowSize=n_windowSize;
  1148.     for (i = 0; i < (RC_MODEL_HISTORY-1); i++)
  1149.     {
  1150.       PictureRejected[i] = FALSE;
  1151.     }
  1153.     //update the MAD for the previous frame
  1154.     if( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) )
  1155.       prc->PreviousFrameMAD=prc->CurrentFrameMAD;
  1157.     // initial MAD model estimator
  1158.     MADModelEstimator (prc, n_windowSize, PictureRejected);
  1160.     // remove outlier
  1161.     for (i = 0; i < n_windowSize; i++)
  1162.     {
  1163.       error[i] = prc->MADPictureC1 * prc->ReferenceMAD[i] + prc->MADPictureC2 - prc->PictureMAD[i];
  1164.       std += (error[i] * error[i]);
  1165.     }
  1167.     threshold = (n_windowSize == 2) ? 0 : sqrt (std / n_windowSize);
  1168.     for (i = 0; i < n_windowSize; i++)
  1169.     {
  1170.       if (fabs(error[i]) > threshold)
  1171.         PictureRejected[i] = TRUE;
  1172.     }
  1173.     // always include the last data point
  1174.     PictureRejected[0] = FALSE;
  1176.     // second MAD model estimator
  1177.     MADModelEstimator (prc, n_windowSize, PictureRejected);
  1178.   }
  1179. }
  1182. /*!
  1183.  *************************************************************************************
  1184.  * brief
  1185.  *    MAD mode estimator
  1186.  *
  1187.  *************************************************************************************
  1188. */
  1189. void MADModelEstimator (rc_quadratic *prc, int n_windowSize, Boolean *PictureRejected)
  1190. {
  1191.   int    n_realSize = n_windowSize;
  1192.   int    i;
  1193.   double oneSampleQ = 0.0;
  1194.   double a00 = 0.0, a01 = 0.0, a10 = 0.0, a11 = 0.0, b0 = 0.0, b1 = 0.0;
  1195.   double MatrixValue;
  1196.   Boolean estimateX2 = FALSE;
  1198.   for (i = 0; i < n_windowSize; i++)
  1199.   {// find the number of samples which are not rejected
  1200.     if (PictureRejected[i])
  1201.       n_realSize--;
  1202.   }
  1204.   // default MAD model estimation results
  1205.   prc->MADPictureC1 = prc->MADPictureC2 = 0.0;
  1207.   for (i = 0; i < n_windowSize; i++)
  1208.   {
  1209.     if (!PictureRejected[i])
  1210.       oneSampleQ = prc->PictureMAD[i];
  1211.   }
  1213.   for (i = 0; i < n_windowSize; i++)
  1214.   {// if all non-rejected MAD are the same, take 1st order model
  1215.     if ((prc->PictureMAD[i] != oneSampleQ) && !PictureRejected[i])
  1216.       estimateX2 = TRUE;
  1217.     if (!PictureRejected[i])
  1218.       prc->MADPictureC1 += prc->PictureMAD[i] / (prc->ReferenceMAD[i]*n_realSize);
  1219.   }
  1221.   // take 2nd order model to estimate X1 and X2
  1222.   if ((n_realSize >= 1) && estimateX2)
  1223.   {
  1224.     for (i = 0; i < n_windowSize; i++)
  1225.     {
  1226.       if (!PictureRejected[i])
  1227.       {
  1228.         a00  = a00 + 1.0;
  1229.         a01 += prc->ReferenceMAD[i];
  1230.         a10  = a01;
  1231.         a11 += prc->ReferenceMAD[i] * prc->ReferenceMAD[i];
  1232.         b0  += prc->PictureMAD[i];
  1233.         b1  += prc->PictureMAD[i]   * prc->ReferenceMAD[i];
  1234.       }
  1235.     }
  1236.     // solve the equation of AX = B
  1237.     MatrixValue = a00 * a11 - a01 * a10;
  1238.     if(fabs(MatrixValue) > 0.000001)
  1239.     {
  1240.       prc->MADPictureC2 = (b0 * a11 - b1 * a01) / MatrixValue;
  1241.       prc->MADPictureC1 = (b1 * a00 - b0 * a10) / MatrixValue;
  1242.     }
  1243.     else
  1244.     {
  1245.       prc->MADPictureC1 = b0/a01;
  1246.       prc->MADPictureC2 = 0.0;
  1247.     }
  1248.   }
  1249.   if( img->type == P_SLICE || (params->RCUpdateMode == RC_MODE_1 && (img->number != 0)) )
  1250.   {
  1251.     prc->PMADPictureC1 = prc->MADPictureC1;
  1252.     prc->PMADPictureC2 = prc->MADPictureC2;
  1253.   }
  1254. }
  1256. /*!
  1257.  *************************************************************************************
  1258.  * brief
  1259.  *    compute a  quantization parameter for each frame (RC_MODE_0)
  1260.  *
  1261.  *************************************************************************************
  1262. */
  1263. int updateQPRC0(rc_quadratic *prc, int topfield)
  1264. {
  1265.   int m_Bits;
  1266.   int BFrameNumber;
  1267.   int StepSize;
  1268.   int SumofBasicUnit;
  1269.   int MaxQpChange, m_Qp, m_Hp;
  1271.   /* frame layer rate control */
  1272.   if( img->BasicUnit == img->FrameSizeInMbs )
  1273.   {
  1274.     /* fixed quantization parameter is used to coded I frame, the first P frame and the first B frame
  1275.     the quantization parameter is adjusted according the available channel bandwidth and
  1276.     the type of video */
  1277.     /*top field*/
  1278.     if((topfield) || (generic_RC->FieldControl==0))
  1279.     {
  1280.       if (img->type==I_SLICE)
  1281.       {
  1282.         prc->m_Qc = prc->MyInitialQp;
  1283.         return prc->m_Qc;
  1284.       }
  1285.       else if(img->type == B_SLICE)
  1286.       {
  1287.         if(params->successive_Bframe==1)
  1288.         {
  1289.           if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1290.             updateQPInterlace( prc );
  1292.           prc->m_Qc = imin(prc->PrevLastQP, prc->CurrLastQP) + 2;
  1293.           prc->m_Qc = imax(prc->m_Qc, imax(prc->PrevLastQP, prc->CurrLastQP));
  1294.           prc->m_Qc = imax(prc->m_Qc, prc->CurrLastQP + 1);
  1295.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1296.         }
  1297.         else
  1298.         {
  1299.           BFrameNumber = (prc->NumberofBFrames + 1) % params->successive_Bframe;
  1300.           if(BFrameNumber==0)
  1301.             BFrameNumber = params->successive_Bframe;
  1303.           /*adaptive field/frame coding*/
  1304.           if(BFrameNumber==1)
  1305.           {
  1306.             if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1307.               updateQPInterlace( prc );
  1308.           }
  1310.           if((prc->CurrLastQP-prc->PrevLastQP)<=(-2*params->successive_Bframe-3))
  1311.             StepSize=-3;
  1312.           else  if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe-2))
  1313.             StepSize=-2;
  1314.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe-1))
  1315.             StepSize=-1;
  1316.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe))
  1317.             StepSize=0;
  1318.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe+1))
  1319.             StepSize=1;
  1320.           else
  1321.             StepSize=2;
  1323.           prc->m_Qc  = prc->PrevLastQP + StepSize;
  1324.           prc->m_Qc += iClip3( -2 * (BFrameNumber - 1), 2*(BFrameNumber-1),
  1325.             (BFrameNumber-1)*(prc->CurrLastQP-prc->PrevLastQP)/(params->successive_Bframe-1));
  1326.           prc->m_Qc  = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1327.         }
  1328.         return prc->m_Qc;
  1329.       }
  1330.       else if( img->type == P_SLICE && prc->NumberofPPicture == 0 )
  1331.       {
  1332.         prc->m_Qc=prc->MyInitialQp;
  1334.         if(generic_RC->FieldControl==0)
  1335.           updateQPNonPicAFF( prc );
  1336.         return prc->m_Qc;
  1337.       }
  1338.       else
  1339.       {
  1340.         /*adaptive field/frame coding*/
  1341.         if( ( params->PicInterlace == ADAPTIVE_CODING || params->MbInterlace ) && generic_RC->FieldControl == 0 )
  1342.           updateQPInterlaceBU( prc );
  1344.         prc->m_X1 = prc->Pm_X1;
  1345.         prc->m_X2 = prc->Pm_X2;
  1346.         prc->MADPictureC1 = prc->PMADPictureC1;
  1347.         prc->MADPictureC2 = prc->PMADPictureC2;
  1348.         prc->PreviousPictureMAD = prc->PPictureMAD[0];
  1350.         MaxQpChange = prc->PMaxQpChange;
  1351.         m_Qp = prc->Pm_Qp;
  1352.         m_Hp = prc->PPreHeader;
  1354.         /* predict the MAD of current picture*/
  1355.         prc->CurrentFrameMAD = prc->MADPictureC1*prc->PreviousPictureMAD + prc->MADPictureC2;
  1357.         /*compute the number of bits for the texture*/
  1358.         if(prc->Target < 0)
  1359.         {
  1360.           prc->m_Qc=m_Qp+MaxQpChange;
  1361.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1362.         }
  1363.         else
  1364.         {
  1365.           m_Bits = prc->Target-m_Hp;
  1366.           m_Bits = imax(m_Bits, (int)(prc->bit_rate/(MINVALUE*prc->frame_rate)));
  1368.           updateModelQPFrame( prc, m_Bits );
  1370.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // clipping
  1371.           prc->m_Qc = iClip3(m_Qp-MaxQpChange, m_Qp+MaxQpChange, prc->m_Qc); // control variation
  1372.         }
  1374.         if( generic_RC->FieldControl == 0 )
  1375.           updateQPNonPicAFF( prc );
  1377.         return prc->m_Qc;
  1378.       }
  1379.     }
  1380.     /*bottom field*/
  1381.     else
  1382.     {
  1383.       if( img->type == P_SLICE && generic_RC->NoGranularFieldRC == 0 )
  1384.         updateBottomField( prc );
  1385.       return prc->m_Qc;
  1386.     }
  1387.   }
  1388.   /*basic unit layer rate control*/
  1389.   else
  1390.   {
  1391.     /*top field of I frame*/
  1392.     if (img->type == I_SLICE)
  1393.     {
  1394.       prc->m_Qc = prc->MyInitialQp;
  1395.       return prc->m_Qc;
  1396.     }
  1397.     else if( img->type == B_SLICE )
  1398.     {
  1399.       /*top field of B frame*/
  1400.       if((topfield)||(generic_RC->FieldControl==0))
  1401.       {
  1402.         if(params->successive_Bframe==1)
  1403.         {
  1404.           /*adaptive field/frame coding*/
  1405.           if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1406.             updateQPInterlace( prc );
  1408.           if(prc->PrevLastQP==prc->CurrLastQP)
  1409.             prc->m_Qc=prc->PrevLastQP+2;
  1410.           else
  1411.             prc->m_Qc=(prc->PrevLastQP+prc->CurrLastQP)/2+1;
  1412.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1413.         }
  1414.         else
  1415.         {
  1416.           BFrameNumber=(prc->NumberofBFrames+1)%params->successive_Bframe;
  1417.           if(BFrameNumber==0)
  1418.             BFrameNumber=params->successive_Bframe;
  1420.           /*adaptive field/frame coding*/
  1421.           if(BFrameNumber==1)
  1422.           {
  1423.             if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1424.               updateQPInterlace( prc );
  1425.           }
  1427.           if((prc->CurrLastQP-prc->PrevLastQP)<=(-2*params->successive_Bframe-3))
  1428.             StepSize=-3;
  1429.           else  if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe-2))
  1430.             StepSize=-2;
  1431.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe-1))
  1432.             StepSize=-1;
  1433.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe))
  1434.             StepSize=0;//0
  1435.           else if((prc->CurrLastQP-prc->PrevLastQP)==(-2*params->successive_Bframe+1))
  1436.             StepSize=1;//1
  1437.           else
  1438.             StepSize=2;//2
  1439.           prc->m_Qc=prc->PrevLastQP+StepSize;
  1440.           prc->m_Qc +=
  1441.             iClip3( -2*(BFrameNumber-1), 2*(BFrameNumber-1), (BFrameNumber-1)*(prc->CurrLastQP-prc->PrevLastQP)/(params->successive_Bframe-1) );
  1442.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1443.         }
  1444.         return prc->m_Qc;
  1445.       }
  1446.       /*bottom field of B frame*/
  1447.       else
  1448.       {
  1449.         return prc->m_Qc;
  1450.       }
  1451.     }
  1452.     else if( img->type == P_SLICE )
  1453.     {
  1454.       if( (generic_RC->NumberofGOP == 1) && (prc->NumberofPPicture == 0) )
  1455.       {
  1456.         if((generic_RC->FieldControl==0)||((generic_RC->FieldControl==1) && (generic_RC->NoGranularFieldRC==0)))
  1457.           return updateFirstP( prc, topfield );
  1458.       }
  1459.       else
  1460.       {
  1461.         prc->m_X1=prc->Pm_X1;
  1462.         prc->m_X2=prc->Pm_X2;
  1463.         prc->MADPictureC1=prc->PMADPictureC1;
  1464.         prc->MADPictureC2=prc->PMADPictureC2;
  1466.         m_Qp=prc->Pm_Qp;
  1468.         if(generic_RC->FieldControl==0)
  1469.           SumofBasicUnit=prc->TotalNumberofBasicUnit;
  1470.         else
  1471.           SumofBasicUnit=prc->TotalNumberofBasicUnit>>1;
  1473.         /*the average QP of the previous frame is used to coded the first basic unit of the current frame or field*/
  1474.         if(prc->NumberofBasicUnit==SumofBasicUnit)
  1475.           return updateFirstBU( prc, topfield );
  1476.         else
  1477.         {
  1478.           /*compute the number of remaining bits*/
  1479.           prc->Target -= (generic_RC->NumberofBasicUnitHeaderBits + generic_RC->NumberofBasicUnitTextureBits);
  1480.           generic_RC->NumberofBasicUnitHeaderBits  = 0;
  1481.           generic_RC->NumberofBasicUnitTextureBits = 0;
  1482.           if(prc->Target<0)
  1483.             return updateNegativeTarget( prc, topfield, m_Qp );
  1484.           else
  1485.           {
  1486.             /*predict the MAD of current picture*/
  1487.             predictCurrPicMAD( prc );
  1489.             /*compute the total number of bits for the current basic unit*/
  1490.             updateModelQPBU( prc, topfield, m_Qp );
  1492.             prc->TotalFrameQP +=prc->m_Qc;
  1493.             prc->Pm_Qp=prc->m_Qc;
  1494.             prc->NumberofBasicUnit--;
  1495.             if( prc->NumberofBasicUnit == 0 && img->type == P_SLICE )
  1496.               updateLastBU( prc, topfield );
  1498.             return prc->m_Qc;
  1499.           }
  1500.         }
  1501.       }
  1502.     }
  1503.   }
  1504.   return prc->m_Qc;
  1505. }
  1507. /*!
  1508.  *************************************************************************************
  1509.  * brief
  1510.  *    compute a  quantization parameter for each frame
  1511.  *
  1512.  *************************************************************************************
  1513. */
  1514. int updateQPRC1(rc_quadratic *prc, int topfield)
  1515. {
  1516.   int m_Bits;
  1517.   int SumofBasicUnit;
  1518.   int MaxQpChange, m_Qp, m_Hp;
  1520.   /* frame layer rate control */
  1521.   if( img->BasicUnit == img->FrameSizeInMbs )
  1522.   {
  1523.     /* fixed quantization parameter is used to coded I frame, the first P frame and the first B frame
  1524.     the quantization parameter is adjusted according the available channel bandwidth and
  1525.     the type of vide */
  1526.     /*top field*/
  1527.     if((topfield) || (generic_RC->FieldControl==0))
  1528.     {
  1529.       if (img->number == 0)
  1530.       {
  1531.         prc->m_Qc = prc->MyInitialQp;
  1532.         return prc->m_Qc;
  1533.       }
  1534.       else if( prc->NumberofPPicture == 0 && (img->number != 0))
  1535.       {
  1536.         prc->m_Qc=prc->MyInitialQp;
  1538.         if(generic_RC->FieldControl==0)
  1539.           updateQPNonPicAFF( prc );
  1540.         return prc->m_Qc;
  1541.       }
  1542.       else
  1543.       {
  1544.         /*adaptive field/frame coding*/
  1545.         if( ( params->PicInterlace == ADAPTIVE_CODING || params->MbInterlace ) && generic_RC->FieldControl == 0 )
  1546.           updateQPInterlaceBU( prc );
  1548.         prc->m_X1 = prc->Pm_X1;
  1549.         prc->m_X2 = prc->Pm_X2;
  1550.         prc->MADPictureC1 = prc->PMADPictureC1;
  1551.         prc->MADPictureC2 = prc->PMADPictureC2;
  1552.         prc->PreviousPictureMAD = prc->PPictureMAD[0];
  1554.         MaxQpChange = prc->PMaxQpChange;
  1555.         m_Qp = prc->Pm_Qp;
  1556.         m_Hp = prc->PPreHeader;
  1558.         /* predict the MAD of current picture*/
  1559.         prc->CurrentFrameMAD=prc->MADPictureC1*prc->PreviousPictureMAD + prc->MADPictureC2;
  1561.         /*compute the number of bits for the texture*/
  1562.         if(prc->Target < 0)
  1563.         {
  1564.           prc->m_Qc=m_Qp+MaxQpChange;
  1565.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1566.         }
  1567.         else
  1568.         {
  1569.           m_Bits = prc->Target-m_Hp;
  1570.           m_Bits = imax(m_Bits, (int)(prc->bit_rate/(MINVALUE*prc->frame_rate)));
  1572.           updateModelQPFrame( prc, m_Bits );
  1574.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // clipping
  1575.           prc->m_Qc = iClip3(m_Qp-MaxQpChange, m_Qp+MaxQpChange, prc->m_Qc); // control variation
  1576.         }
  1578.         if( generic_RC->FieldControl == 0 )
  1579.           updateQPNonPicAFF( prc );
  1581.         return prc->m_Qc;
  1582.       }
  1583.     }
  1584.     /*bottom field*/
  1585.     else
  1586.     {
  1587.       if( generic_RC->NoGranularFieldRC == 0 )
  1588.         updateBottomField( prc );
  1589.       return prc->m_Qc;
  1590.     }
  1591.   }
  1592.   /*basic unit layer rate control*/
  1593.   else
  1594.   {
  1595.     /*top field of I frame*/
  1596.     if (img->number == 0)
  1597.     {
  1598.       prc->m_Qc = prc->MyInitialQp;
  1599.       return prc->m_Qc;
  1600.     }
  1601.     else
  1602.     {
  1603.       if((generic_RC->NumberofGOP==1)&&(prc->NumberofPPicture==0))
  1604.       {
  1605.         if((generic_RC->FieldControl==0)||((generic_RC->FieldControl==1) && (generic_RC->NoGranularFieldRC==0)))
  1606.           return updateFirstP( prc, topfield );
  1607.       }
  1608.       else
  1609.       {
  1610.         prc->m_X1=prc->Pm_X1;
  1611.         prc->m_X2=prc->Pm_X2;
  1612.         prc->MADPictureC1=prc->PMADPictureC1;
  1613.         prc->MADPictureC2=prc->PMADPictureC2;
  1615.         m_Qp=prc->Pm_Qp;
  1617.         if(generic_RC->FieldControl==0)
  1618.           SumofBasicUnit=prc->TotalNumberofBasicUnit;
  1619.         else
  1620.           SumofBasicUnit=prc->TotalNumberofBasicUnit>>1;
  1622.         /*the average QP of the previous frame is used to coded the first basic unit of the current frame or field*/
  1623.         if(prc->NumberofBasicUnit==SumofBasicUnit)
  1624.           return updateFirstBU( prc, topfield );
  1625.         else
  1626.         {
  1627.           /*compute the number of remaining bits*/
  1628.           prc->Target -= (generic_RC->NumberofBasicUnitHeaderBits + generic_RC->NumberofBasicUnitTextureBits);
  1629.           generic_RC->NumberofBasicUnitHeaderBits  = 0;
  1630.           generic_RC->NumberofBasicUnitTextureBits = 0;
  1631.           if(prc->Target<0)
  1632.             return updateNegativeTarget( prc, topfield, m_Qp );
  1633.           else
  1634.           {
  1635.             /*predict the MAD of current picture*/
  1636.             predictCurrPicMAD( prc );
  1638.             /*compute the total number of bits for the current basic unit*/
  1639.             updateModelQPBU( prc, topfield, m_Qp );
  1641.             prc->TotalFrameQP +=prc->m_Qc;
  1642.             prc->Pm_Qp=prc->m_Qc;
  1643.             prc->NumberofBasicUnit--;
  1644.             if((prc->NumberofBasicUnit==0) && (img->number != 0))
  1645.               updateLastBU( prc, topfield );
  1647.             return prc->m_Qc;
  1648.           }
  1649.         }
  1650.       }
  1651.     }
  1652.   }
  1653.   return prc->m_Qc;
  1654. }
  1656. /*!
  1657.  *************************************************************************************
  1658.  * brief
  1659.  *    compute a  quantization parameter for each frame
  1660.  *
  1661.  *************************************************************************************
  1662. */
  1663. int updateQPRC2(rc_quadratic *prc, int topfield)
  1664. {
  1665.   int m_Bits;
  1666.   int SumofBasicUnit;
  1667.   int MaxQpChange, m_Qp, m_Hp;
  1669.   /* frame layer rate control */
  1670.   if( img->BasicUnit == img->FrameSizeInMbs )
  1671.   {
  1672.     /* fixed quantization parameter is used to coded I frame, the first P frame and the first B frame
  1673.     the quantization parameter is adjusted according the available channel bandwidth and
  1674.     the type of vide */
  1675.     /*top field*/
  1676.     if((topfield) || (generic_RC->FieldControl==0))
  1677.     {
  1678.       if (img->number == 0)
  1679.       {
  1680.         prc->m_Qc = prc->MyInitialQp;
  1681.         return prc->m_Qc;
  1682.       }
  1683.       else if (img->type==I_SLICE)
  1684.       {
  1685.         if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1686.           updateQPInterlace( prc );
  1688.         prc->m_Qc = prc->CurrLastQP; // Set QP to average qp of last P frame
  1689.         return prc->m_Qc;
  1690.       }
  1691.       else if(img->type == B_SLICE)
  1692.       {
  1693.         int prevQP = imax(prc->PrevLastQP, prc->CurrLastQP);
  1694.         // for more than one consecutive B frames the below call will overwrite the old anchor frame QP with the current value
  1695.         // it should be called once in the B-frame sequence....this should be modified for the BU < frame as well
  1696.         if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1697.           updateQPInterlace( prc );
  1699.         if (params->HierarchicalCoding)
  1700.         {
  1701.           if (img->b_frame_to_code == 0)
  1702.             prc->m_Qc = prevQP;
  1703.           else
  1704.             prc->m_Qc = prevQP + img->GopLevels - gop_structure[img->b_frame_to_code-1].hierarchy_layer;
  1705.         }
  1706.         else
  1707.           prc->m_Qc = prevQP + 2 - img->nal_reference_idc;
  1708.         prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1710.         return prc->m_Qc;
  1711.       }
  1712.       else if( img->type == P_SLICE && prc->NumberofPPicture == 0 )
  1713.       {
  1714.         prc->m_Qc=prc->MyInitialQp;
  1716.         if(generic_RC->FieldControl==0)
  1717.           updateQPNonPicAFF( prc );
  1718.         return prc->m_Qc;
  1719.       }
  1720.       else
  1721.       {
  1722.         /*adaptive field/frame coding*/
  1723.         if( ( params->PicInterlace == ADAPTIVE_CODING || params->MbInterlace ) && generic_RC->FieldControl == 0 )
  1724.           updateQPInterlaceBU( prc );
  1726.         prc->m_X1 = prc->Pm_X1;
  1727.         prc->m_X2 = prc->Pm_X2;
  1728.         prc->MADPictureC1 = prc->PMADPictureC1;
  1729.         prc->MADPictureC2 = prc->PMADPictureC2;
  1730.         prc->PreviousPictureMAD = prc->PPictureMAD[0];
  1732.         MaxQpChange = prc->PMaxQpChange;
  1733.         m_Qp = prc->Pm_Qp;
  1734.         m_Hp = prc->PPreHeader;
  1736.         /* predict the MAD of current picture*/
  1737.         prc->CurrentFrameMAD=prc->MADPictureC1*prc->PreviousPictureMAD + prc->MADPictureC2;
  1739.         /*compute the number of bits for the texture*/
  1740.         if(prc->Target < 0)
  1741.         {
  1742.           prc->m_Qc=m_Qp+MaxQpChange;
  1743.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1744.         }
  1745.         else
  1746.         {
  1747.           m_Bits = prc->Target-m_Hp;
  1748.           m_Bits = imax(m_Bits, (int)(prc->bit_rate/(MINVALUE*prc->frame_rate)));
  1750.           updateModelQPFrame( prc, m_Bits );
  1752.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // clipping
  1753.           prc->m_Qc = iClip3(m_Qp-MaxQpChange, m_Qp+MaxQpChange, prc->m_Qc); // control variation
  1754.         }
  1756.         if( generic_RC->FieldControl == 0 )
  1757.           updateQPNonPicAFF( prc );
  1759.         return prc->m_Qc;
  1760.       }
  1761.     }
  1762.     /*bottom field*/
  1763.     else
  1764.     {
  1765.       if( img->type==P_SLICE && generic_RC->NoGranularFieldRC == 0 )
  1766.         updateBottomField( prc );
  1767.       return prc->m_Qc;
  1768.     }
  1769.   }
  1770.   /*basic unit layer rate control*/
  1771.   else
  1772.   {
  1773.     /*top field of I frame*/
  1774.     if (img->number == 0)
  1775.     {
  1776.       prc->m_Qc = prc->MyInitialQp;
  1777.       return prc->m_Qc;
  1778.     }
  1779.     else if (img->type==I_SLICE)
  1780.     {
  1781.       /*adaptive field/frame coding*/
  1782.       if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1783.         updateQPInterlace( prc );
  1785.       prc->m_Qc = prc->PrevLastQP; // Set QP to average qp of last P frame
  1786.       prc->PrevLastQP = prc->CurrLastQP;
  1787.       prc->CurrLastQP = prc->PrevLastQP;
  1788.       prc->PAveFrameQP = prc->CurrLastQP;
  1790.       return prc->m_Qc;
  1791.     }
  1792.     else if(img->type == B_SLICE)
  1793.     {
  1794.       int prevQP = imax(prc->PrevLastQP, prc->CurrLastQP);
  1795.       if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  1796.         updateQPInterlace( prc );
  1798.       if (params->HierarchicalCoding)
  1799.       {
  1801.         if (img->b_frame_to_code == 0)
  1802.           prc->m_Qc = prevQP;
  1803.         else
  1804.           prc->m_Qc = prevQP + img->GopLevels - gop_structure[img->b_frame_to_code-1].hierarchy_layer;
  1805.       }
  1806.       else
  1807.         prc->m_Qc = prevQP + 2 - img->nal_reference_idc;
  1808.       prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1810.       return prc->m_Qc;
  1812.     }
  1813.     else if( img->type == P_SLICE )
  1814.     {
  1815.       if((generic_RC->NumberofGOP==1)&&(prc->NumberofPPicture==0))
  1816.       {
  1817.         if((generic_RC->FieldControl==0)||((generic_RC->FieldControl==1) && (generic_RC->NoGranularFieldRC==0)))
  1818.           return updateFirstP( prc, topfield );
  1819.       }
  1820.       else
  1821.       {
  1822.         prc->m_X1=prc->Pm_X1;
  1823.         prc->m_X2=prc->Pm_X2;
  1824.         prc->MADPictureC1=prc->PMADPictureC1;
  1825.         prc->MADPictureC2=prc->PMADPictureC2;
  1827.         m_Qp=prc->Pm_Qp;
  1829.         if(generic_RC->FieldControl==0)
  1830.           SumofBasicUnit=prc->TotalNumberofBasicUnit;
  1831.         else
  1832.           SumofBasicUnit=prc->TotalNumberofBasicUnit>>1;
  1834.         /*the average QP of the previous frame is used to coded the first basic unit of the current frame or field*/
  1835.         if(prc->NumberofBasicUnit==SumofBasicUnit)
  1836.           return updateFirstBU( prc, topfield );
  1837.         else
  1838.         {
  1839.           /*compute the number of remaining bits*/
  1840.           prc->Target -= (generic_RC->NumberofBasicUnitHeaderBits + generic_RC->NumberofBasicUnitTextureBits);
  1841.           generic_RC->NumberofBasicUnitHeaderBits  = 0;
  1842.           generic_RC->NumberofBasicUnitTextureBits = 0;
  1843.           if(prc->Target<0)
  1844.             return updateNegativeTarget( prc, topfield, m_Qp );
  1845.           else
  1846.           {
  1847.             /*predict the MAD of current picture*/
  1848.             predictCurrPicMAD( prc );
  1850.             /*compute the total number of bits for the current basic unit*/
  1851.             updateModelQPBU( prc, topfield, m_Qp );
  1853.             prc->TotalFrameQP +=prc->m_Qc;
  1854.             prc->Pm_Qp=prc->m_Qc;
  1855.             prc->NumberofBasicUnit--;
  1856.             if((prc->NumberofBasicUnit==0) && img->type == P_SLICE )
  1857.               updateLastBU( prc, topfield );
  1859.             return prc->m_Qc;
  1860.           }
  1861.         }
  1862.       }
  1863.     }
  1864.   }
  1865.   return prc->m_Qc;
  1866. }
  1868. /*!
  1869.  *************************************************************************************
  1870.  * brief
  1871.  *    compute a  quantization parameter for each frame
  1872.  *
  1873.  *************************************************************************************
  1874. */
  1875. int updateQPRC3(rc_quadratic *prc, int topfield)
  1876. {
  1877.   int m_Bits;
  1878.   int SumofBasicUnit;
  1879.   int MaxQpChange, m_Qp, m_Hp;
  1881.   /* frame layer rate control */
  1882.   if( img->BasicUnit == img->FrameSizeInMbs || img->type != P_SLICE )
  1883.   {
  1884.     /* fixed quantization parameter is used to coded I frame, the first P frame and the first B frame
  1885.     the quantization parameter is adjusted according the available channel bandwidth and
  1886.     the type of video */
  1887.     /*top field*/
  1888.     if((topfield) || (generic_RC->FieldControl==0))
  1889.     {
  1890.       if (img->number == 0)
  1891.       {
  1892.         if((params->PicInterlace == ADAPTIVE_CODING) || (params->MbInterlace))
  1893.           updateQPInterlace( prc );
  1894.         prc->m_Qc = prc->MyInitialQp;
  1895.         return prc->m_Qc;
  1896.       }
  1897.       else if( img->type == P_SLICE && prc->NumberofPPicture == 0 )
  1898.       {
  1899.         prc->m_Qc=prc->MyInitialQp;
  1901.         if(generic_RC->FieldControl==0)
  1902.           updateQPNonPicAFF( prc );
  1903.         return prc->m_Qc;
  1904.       }
  1905.       else
  1906.       {
  1907.         if( ( (img->type == B_SLICE && img->b_frame_to_code == 1) || img->type == I_SLICE) && ((params->PicInterlace == ADAPTIVE_CODING) || (params->MbInterlace)) )
  1908.           updateQPInterlace( prc );
  1909.         /*adaptive field/frame coding*/
  1910.         if( img->type == P_SLICE && ( params->PicInterlace == ADAPTIVE_CODING || params->MbInterlace ) && generic_RC->FieldControl == 0 )
  1911.           updateQPInterlaceBU( prc );
  1913.         prc->m_X1 = prc->Pm_X1;
  1914.         prc->m_X2 = prc->Pm_X2;
  1915.         prc->MADPictureC1 = prc->PMADPictureC1;
  1916.         prc->MADPictureC2 = prc->PMADPictureC2;
  1917.         prc->PreviousPictureMAD = prc->PPictureMAD[0];
  1919.         MaxQpChange = prc->PMaxQpChange;
  1920.         m_Qp = prc->Pm_Qp;
  1921.         m_Hp = prc->PPreHeader;
  1923.         if ( img->BasicUnit < img->FrameSizeInMbs && img->type != P_SLICE )
  1924.         {
  1925.           // when RC_MODE_3 is set and basic unit is smaller than a frame, note that:
  1926.           // the linear MAD model and the quadratic QP model operate on small units and not on a whole frame;
  1927.           // we therefore have to account for this
  1928.           prc->PreviousPictureMAD = prc->PreviousWholeFrameMAD;
  1929.         }
  1930.         if ( img->type == I_SLICE )
  1931.           m_Hp = 0; // it is usually a very small portion of the total I_SLICE bit budget
  1933.         /* predict the MAD of current picture*/
  1934.         prc->CurrentFrameMAD=prc->MADPictureC1*prc->PreviousPictureMAD + prc->MADPictureC2;
  1936.         /*compute the number of bits for the texture*/
  1937.         if(prc->Target < 0)
  1938.         {
  1939.           prc->m_Qc=m_Qp+MaxQpChange;
  1940.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // Clipping
  1941.         }
  1942.         else
  1943.         {
  1944.           if ( img->type != P_SLICE )
  1945.           {
  1946.             if ( img->BasicUnit < img->FrameSizeInMbs )
  1947.               m_Bits =(prc->Target-m_Hp)/prc->TotalNumberofBasicUnit;
  1948.             else
  1949.               m_Bits =prc->Target-m_Hp;
  1950.           }
  1951.           else {
  1952.             m_Bits = prc->Target-m_Hp;
  1953.             m_Bits = imax(m_Bits, (int)(prc->bit_rate/(MINVALUE*prc->frame_rate)));
  1954.           }          
  1955.           updateModelQPFrame( prc, m_Bits );
  1957.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // clipping
  1958.           if ( img->type == P_SLICE )
  1959.             prc->m_Qc = iClip3(m_Qp-MaxQpChange, m_Qp+MaxQpChange, prc->m_Qc); // control variation
  1960.         }
  1962.         if( img->type == P_SLICE && generic_RC->FieldControl == 0 )
  1963.           updateQPNonPicAFF( prc );
  1965.         if ( img->type == B_SLICE )
  1966.         {
  1967.           // hierarchical adjustment
  1968.           int prevqp = ((prc->PrevLastQP+prc->CurrLastQP) >> 1) + 1;
  1969.           if ( params->HierarchicalCoding && img->b_frame_to_code)
  1970.             prc->m_Qc -= gop_structure[img->b_frame_to_code-1].hierarchy_layer;
  1971.           // check bounds
  1972.           prc->m_Qc = iClip3(prevqp - (params->HierarchicalCoding ? 0 : 5), prevqp + 5, prc->m_Qc); // control variation
  1973.           prc->m_Qc = iClip3(img->RCMinQP, img->RCMaxQP, prc->m_Qc); // clipping
  1974.         }
  1975.         return prc->m_Qc;
  1976.       }
  1977.     }
  1978.     /*bottom field*/
  1979.     else
  1980.     {
  1981.       if( img->type==P_SLICE && generic_RC->NoGranularFieldRC == 0 )
  1982.         updateBottomField( prc );
  1983.       return prc->m_Qc;
  1984.     }
  1985.   }
  1986.   /*basic unit layer rate control*/
  1987.   else
  1988.   {
  1989.     /*top field of I frame*/
  1990.     if (img->number == 0)
  1991.     {
  1992.       if((params->PicInterlace == ADAPTIVE_CODING) || (params->MbInterlace))
  1993.         updateQPInterlace( prc );
  1994.       prc->m_Qc = prc->MyInitialQp;
  1995.       return prc->m_Qc;
  1996.     }
  1997.     else if( img->type == P_SLICE )
  1998.     {
  1999.       if((generic_RC->NumberofGOP==1)&&(prc->NumberofPPicture==0))
  2000.       {
  2001.         if((generic_RC->FieldControl==0)||((generic_RC->FieldControl==1) && (generic_RC->NoGranularFieldRC==0)))
  2002.           return updateFirstP( prc, topfield );
  2003.       }
  2004.       else
  2005.       {
  2006.         if( ( (img->type == B_SLICE && img->b_frame_to_code == 1) || img->type == I_SLICE) && ((params->PicInterlace == ADAPTIVE_CODING) || (params->MbInterlace)) )
  2007.           updateQPInterlace( prc );
  2008.         prc->m_X1=prc->Pm_X1;
  2009.         prc->m_X2=prc->Pm_X2;
  2010.         prc->MADPictureC1=prc->PMADPictureC1;
  2011.         prc->MADPictureC2=prc->PMADPictureC2;
  2013.         m_Qp=prc->Pm_Qp;
  2015.         if(generic_RC->FieldControl==0)
  2016.           SumofBasicUnit=prc->TotalNumberofBasicUnit;
  2017.         else
  2018.           SumofBasicUnit=prc->TotalNumberofBasicUnit>>1;
  2020.         /*the average QP of the previous frame is used to coded the first basic unit of the current frame or field*/
  2021.         if(prc->NumberofBasicUnit==SumofBasicUnit)
  2022.           return updateFirstBU( prc, topfield );
  2023.         else
  2024.         {
  2025.           /*compute the number of remaining bits*/
  2026.           prc->Target -= (generic_RC->NumberofBasicUnitHeaderBits + generic_RC->NumberofBasicUnitTextureBits);
  2027.           generic_RC->NumberofBasicUnitHeaderBits  = 0;
  2028.           generic_RC->NumberofBasicUnitTextureBits = 0;
  2029.           if(prc->Target<0)
  2030.             return updateNegativeTarget( prc, topfield, m_Qp );
  2031.           else
  2032.           {
  2033.             /*predict the MAD of current picture*/
  2034.             predictCurrPicMAD( prc );
  2036.             /*compute the total number of bits for the current basic unit*/
  2037.             updateModelQPBU( prc, topfield, m_Qp );
  2039.             prc->TotalFrameQP +=prc->m_Qc;
  2040.             prc->Pm_Qp=prc->m_Qc;
  2041.             prc->NumberofBasicUnit--;
  2042.             if((prc->NumberofBasicUnit==0) && img->type == P_SLICE )
  2043.               updateLastBU( prc, topfield );
  2045.             return prc->m_Qc;
  2046.           }
  2047.         }
  2048.       }
  2049.     }
  2050.   }
  2051.   return prc->m_Qc;
  2052. }
  2054. /*!
  2055.  *************************************************************************************
  2056.  * brief
  2057.  *    Save previous QP values for interlaced coding
  2058.  *
  2059.  *************************************************************************************
  2060. */
  2061. void updateQPInterlace( rc_quadratic *prc )
  2062. {
  2063.   if(generic_RC->FieldControl==0)
  2064.   {
  2065.     /*previous choice is frame coding*/
  2066.     if(generic_RC->FieldFrame==1)
  2067.     {
  2068.       prc->PrevLastQP=prc->CurrLastQP;
  2069.       prc->CurrLastQP=prc->FrameQPBuffer;
  2070.     }
  2071.     /*previous choice is field coding*/
  2072.     else
  2073.     {
  2074.       prc->PrevLastQP=prc->CurrLastQP;
  2075.       prc->CurrLastQP=prc->FieldQPBuffer;
  2076.     }
  2077.   }
  2078. }
  2080. /*!
  2081.  *************************************************************************************
  2082.  * brief
  2083.  *    Save previous QP values for the case of non-PicAFF
  2084.  *
  2085.  *************************************************************************************
  2086. */
  2087. void updateQPNonPicAFF( rc_quadratic *prc )
  2088. {
  2089.   if(active_sps->frame_mbs_only_flag)
  2090.   {
  2091.     prc->TotalQpforPPicture +=prc->m_Qc;
  2092.     prc->PrevLastQP=prc->CurrLastQP;
  2093.     prc->CurrLastQP=prc->m_Qc;
  2094.     prc->Pm_Qp=prc->m_Qc;
  2095.   }
  2096.   /*adaptive field/frame coding*/
  2097.   else
  2098.     prc->FrameQPBuffer=prc->m_Qc;
  2099. }
  2101. /*!
  2102.  *************************************************************************************
  2103.  * brief
  2104.  *    Update QP values for bottom filed in field coding
  2105.  *************************************************************************************
  2106. */
  2107. void updateBottomField( rc_quadratic *prc )
  2108. {
  2109.   /*field coding*/
  2110.   if(params->PicInterlace==FIELD_CODING)
  2111.   {
  2112.     prc->TotalQpforPPicture +=prc->m_Qc;
  2113.     prc->PrevLastQP=prc->CurrLastQP+1;
  2114.     prc->CurrLastQP=prc->m_Qc;//+0 Recent change 13/1/2003
  2115.     prc->Pm_Qp=prc->m_Qc;
  2116.   }
  2117.   /*adaptive field/frame coding*/
  2118.   else
  2119.     prc->FieldQPBuffer=prc->m_Qc;
  2120. }
  2122. /*!
  2123.  *************************************************************************************
  2124.  * brief
  2125.  *    update QP variables for P frames
  2126.  *************************************************************************************
  2127. */
  2128. int updateFirstP( rc_quadratic *prc, int topfield )
  2129. {
  2130.   /*top field of the first P frame*/
  2131.   prc->m_Qc=prc->MyInitialQp;
  2132.   generic_RC->NumberofBasicUnitHeaderBits=0;
  2133.   generic_RC->NumberofBasicUnitTextureBits=0;
  2134.   prc->NumberofBasicUnit--;
  2135.   /*bottom field of the first P frame*/
  2136.   if((!topfield)&&(prc->NumberofBasicUnit==0))
  2137.   {
  2138.     /*frame coding or field coding*/
  2139.     if((active_sps->frame_mbs_only_flag)||(params->PicInterlace==FIELD_CODING))
  2140.     {
  2141.       prc->TotalQpforPPicture +=prc->m_Qc;
  2142.       prc->PrevLastQP=prc->CurrLastQP;
  2143.       prc->CurrLastQP=prc->m_Qc;
  2144.       prc->PAveFrameQP=prc->m_Qc;
  2145.       prc->PAveHeaderBits3=prc->PAveHeaderBits2;
  2146.     }
  2147.     /*adaptive frame/field coding*/
  2148.     else if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  2149.     {
  2150.       if(generic_RC->FieldControl==0)
  2151.       {
  2152.         prc->FrameQPBuffer=prc->m_Qc;
  2153.         prc->FrameAveHeaderBits=prc->PAveHeaderBits2;
  2154.       }
  2155.       else
  2156.       {
  2157.         prc->FieldQPBuffer=prc->m_Qc;
  2158.         prc->FieldAveHeaderBits=prc->PAveHeaderBits2;
  2159.       }
  2160.     }
  2161.   }
  2162.   prc->Pm_Qp=prc->m_Qc;
  2163.   prc->TotalFrameQP +=prc->m_Qc;
  2164.   return prc->m_Qc;
  2165. }
  2167. /*!
  2168.  *************************************************************************************
  2169.  * brief
  2170.  *    update QP when bit target is negative
  2171.  *************************************************************************************
  2172. */
  2173. int updateNegativeTarget( rc_quadratic *prc, int topfield, int m_Qp )
  2174. {
  2175.   int PAverageQP;
  2177.   if(prc->GOPOverdue==TRUE)
  2178.     prc->m_Qc=m_Qp+2;
  2179.   else
  2180.     prc->m_Qc=m_Qp+prc->DDquant;//2
  2182.   prc->m_Qc = imin(prc->m_Qc, img->RCMaxQP);  // clipping
  2183.   if(params->basicunit>=prc->MBPerRow)
  2184.     prc->m_Qc = imin(prc->m_Qc, prc->PAveFrameQP + 6);
  2185.   else
  2186.     prc->m_Qc = imin(prc->m_Qc, prc->PAveFrameQP + 3);
  2188.   prc->TotalFrameQP +=prc->m_Qc;
  2189.   prc->NumberofBasicUnit--;
  2190.   if(prc->NumberofBasicUnit==0)
  2191.   {
  2192.     if((!topfield)||(generic_RC->FieldControl==0))
  2193.     {
  2194.       /*frame coding or field coding*/
  2195.       if((active_sps->frame_mbs_only_flag)||(params->PicInterlace==FIELD_CODING))
  2196.       {
  2197.         PAverageQP=(int)((double)prc->TotalFrameQP/(double)prc->TotalNumberofBasicUnit+0.5);
  2198.         if (prc->NumberofPPicture == (params->intra_period - 2))
  2199.           prc->QPLastPFrame = PAverageQP;
  2201.         prc->TotalQpforPPicture +=PAverageQP;
  2202.         if(prc->GOPOverdue==TRUE)
  2203.         {
  2204.           prc->PrevLastQP=prc->CurrLastQP+1;
  2205.           prc->CurrLastQP=PAverageQP;
  2206.         }
  2207.         else
  2208.         {
  2209.           if((prc->NumberofPPicture==0)&&(generic_RC->NumberofGOP>1))
  2210.           {
  2211.             prc->PrevLastQP=prc->CurrLastQP;
  2212.             prc->CurrLastQP=PAverageQP;
  2213.           }
  2214.           else if(prc->NumberofPPicture>0)
  2215.           {
  2216.             prc->PrevLastQP=prc->CurrLastQP+1;
  2217.             prc->CurrLastQP=PAverageQP;
  2218.           }
  2219.         }
  2220.         prc->PAveFrameQP=PAverageQP;
  2221.         prc->PAveHeaderBits3=prc->PAveHeaderBits2;
  2222.       }
  2223.       /*adaptive field/frame coding*/
  2224.       else if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  2225.       {
  2226.         if(generic_RC->FieldControl==0)
  2227.         {
  2228.           PAverageQP=(int)((double)prc->TotalFrameQP/(double)prc->TotalNumberofBasicUnit+0.5);
  2229.           prc->FrameQPBuffer=PAverageQP;
  2230.           prc->FrameAveHeaderBits=prc->PAveHeaderBits2;
  2231.         }
  2232.         else
  2233.         {
  2234.           PAverageQP=(int)((double)prc->TotalFrameQP/(double)prc->TotalNumberofBasicUnit+0.5);
  2235.           prc->FieldQPBuffer=PAverageQP;
  2236.           prc->FieldAveHeaderBits=prc->PAveHeaderBits2;
  2237.         }
  2238.       }
  2239.     }
  2240.   }
  2241.   if(prc->GOPOverdue==TRUE)
  2242.     prc->Pm_Qp=prc->PAveFrameQP;
  2243.   else
  2244.     prc->Pm_Qp=prc->m_Qc;
  2246.   return prc->m_Qc;
  2247. }
  2249. /*!
  2250.  *************************************************************************************
  2251.  * brief
  2252.  *    update QP for the first Basic Unit in the picture
  2253.  *************************************************************************************
  2254. */
  2255. int updateFirstBU( rc_quadratic *prc, int topfield )
  2256. {
  2257.   /*adaptive field/frame coding*/
  2258.   if(((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))&&(generic_RC->FieldControl==0))
  2259.   {
  2260.     /*previous choice is frame coding*/
  2261.     if(generic_RC->FieldFrame==1)
  2262.     {
  2263.       if(prc->NumberofPPicture>0)
  2264.         prc->TotalQpforPPicture +=prc->FrameQPBuffer;
  2265.       prc->PAveFrameQP=prc->FrameQPBuffer;
  2266.       prc->PAveHeaderBits3=prc->FrameAveHeaderBits;
  2267.     }
  2268.     /*previous choice is field coding*/
  2269.     else
  2270.     {
  2271.       if(prc->NumberofPPicture>0)
  2272.         prc->TotalQpforPPicture +=prc->FieldQPBuffer;
  2273.       prc->PAveFrameQP=prc->FieldQPBuffer;
  2274.       prc->PAveHeaderBits3=prc->FieldAveHeaderBits;
  2275.     }
  2276.   }
  2278.   if(prc->Target<=0)
  2279.   {
  2280.     prc->m_Qc = prc->PAveFrameQP + 2;
  2281.     if(prc->m_Qc > img->RCMaxQP)
  2282.       prc->m_Qc = img->RCMaxQP;
  2284.     if(topfield||(generic_RC->FieldControl==0))
  2285.       prc->GOPOverdue=TRUE;
  2286.   }
  2287.   else
  2288.   {
  2289.     prc->m_Qc=prc->PAveFrameQP;
  2290.   }
  2291.   prc->TotalFrameQP +=prc->m_Qc;
  2292.   prc->NumberofBasicUnit--;
  2293.   prc->Pm_Qp = prc->PAveFrameQP;
  2295.   return prc->m_Qc;
  2296. }
  2298. /*!
  2299.  *************************************************************************************
  2300.  * brief
  2301.  *    update QP for the last Basic Unit in the picture
  2302.  *************************************************************************************
  2303. */
  2304. void updateLastBU( rc_quadratic *prc, int topfield )
  2305. {
  2306.   int PAverageQP;
  2308.   if((!topfield)||(generic_RC->FieldControl==0))
  2309.   {
  2310.     /*frame coding or field coding*/
  2311.     if((active_sps->frame_mbs_only_flag)||(params->PicInterlace==FIELD_CODING))
  2312.     {
  2313.       PAverageQP=(int)((double)prc->TotalFrameQP/(double) prc->TotalNumberofBasicUnit+0.5);
  2314.       if (prc->NumberofPPicture == (params->intra_period - 2))
  2315.         prc->QPLastPFrame = PAverageQP;
  2317.       prc->TotalQpforPPicture +=PAverageQP;
  2318.       prc->PrevLastQP=prc->CurrLastQP;
  2319.       prc->CurrLastQP=PAverageQP;
  2320.       prc->PAveFrameQP=PAverageQP;
  2321.       prc->PAveHeaderBits3=prc->PAveHeaderBits2;
  2322.     }
  2323.     else if((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))
  2324.     {
  2325.       if(generic_RC->FieldControl==0)
  2326.       {
  2327.         PAverageQP=(int)((double) prc->TotalFrameQP/(double)prc->TotalNumberofBasicUnit+0.5);
  2328.         prc->FrameQPBuffer=PAverageQP;
  2329.         prc->FrameAveHeaderBits=prc->PAveHeaderBits2;
  2330.       }
  2331.       else
  2332.       {
  2333.         PAverageQP=(int)((double) prc->TotalFrameQP/(double) prc->TotalNumberofBasicUnit+0.5);
  2334.         prc->FieldQPBuffer=PAverageQP;
  2335.         prc->FieldAveHeaderBits=prc->PAveHeaderBits2;
  2336.       }
  2337.     }
  2338.   }
  2339. }
  2341. /*!
  2342.  *************************************************************************************
  2343.  * brief
  2344.  *    update current picture MAD
  2345.  *************************************************************************************
  2346. */
  2347. void predictCurrPicMAD( rc_quadratic *prc )
  2348. {
  2349.   int i;
  2350.   if(((params->PicInterlace==ADAPTIVE_CODING)||(params->MbInterlace))&&(generic_RC->FieldControl==1))
  2351.   {
  2352.     prc->CurrentFrameMAD=prc->MADPictureC1*prc->FCBUPFMAD[prc->TotalNumberofBasicUnit-prc->NumberofBasicUnit]+prc->MADPictureC2;
  2353.     prc->TotalBUMAD=0;
  2354.     for(i=prc->TotalNumberofBasicUnit-1; i>=(prc->TotalNumberofBasicUnit-prc->NumberofBasicUnit);i--)
  2355.     {
  2356.       prc->CurrentBUMAD=prc->MADPictureC1*prc->FCBUPFMAD[i]+prc->MADPictureC2;
  2357.       prc->TotalBUMAD +=prc->CurrentBUMAD*prc->CurrentBUMAD;
  2358.     }
  2359.   }
  2360.   else
  2361.   {
  2362.     prc->CurrentFrameMAD=prc->MADPictureC1*prc->BUPFMAD[prc->TotalNumberofBasicUnit-prc->NumberofBasicUnit]+prc->MADPictureC2;
  2363.     prc->TotalBUMAD=0;
  2364.     for(i=prc->TotalNumberofBasicUnit-1; i>=(prc->TotalNumberofBasicUnit-prc->NumberofBasicUnit);i--)
  2365.     {
  2366.       prc->CurrentBUMAD=prc->MADPictureC1*prc->BUPFMAD[i]+prc->MADPictureC2;
  2367.       prc->TotalBUMAD +=prc->CurrentBUMAD*prc->CurrentBUMAD;
  2368.     }
  2369.   }
  2370. }
  2372. /*!
  2373.  *************************************************************************************
  2374.  * brief
  2375.  *    update QP using the quadratic model for basic unit coding
  2376.  *************************************************************************************
  2377. */
  2378. void updateModelQPBU( rc_quadratic *prc, int topfield, int m_Qp )
  2379. {
  2380.   double dtmp, m_Qstep;
  2381.   int m_Bits;
  2382.   /*compute the total number of bits for the current basic unit*/
  2383.   m_Bits =(int)(prc->Target * prc->CurrentFrameMAD * prc->CurrentFrameMAD / prc->TotalBUMAD);
  2384.   /*compute the number of texture bits*/
  2385.   m_Bits -=prc->PAveHeaderBits2;
  2387.   m_Bits=imax(m_Bits,(int)(prc->bit_rate/(MINVALUE*prc->frame_rate*prc->TotalNumberofBasicUnit)));
  2389.   dtmp = prc->CurrentFrameMAD * prc->CurrentFrameMAD * prc->m_X1 * prc->m_X1 
  2390.     + 4 * prc->m_X2 * prc->CurrentFrameMAD * m_Bits;
  2391.   if ((prc->m_X2 == 0.0) || (dtmp < 0) || ((sqrt (dtmp) - prc->m_X1 * prc->CurrentFrameMAD) <= 0.0))  // fall back 1st order mode
  2392.     m_Qstep = (float)(prc->m_X1 * prc->CurrentFrameMAD / (double) m_Bits);
  2393.   else // 2nd order mode
  2394.     m_Qstep = (float) ((2 * prc->m_X2 * prc->CurrentFrameMAD) / (sqrt (dtmp) - prc->m_X1 * prc->CurrentFrameMAD));
  2396.   prc->m_Qc = Qstep2QP(m_Qstep);
  2397.   prc->m_Qc = imin(m_Qp+prc->DDquant,  prc->m_Qc); // control variation
  2399.   if(params->basicunit>=prc->MBPerRow)
  2400.     prc->m_Qc = imin(prc->PAveFrameQP+6, prc->m_Qc);
  2401.   else
  2402.     prc->m_Qc = imin(prc->PAveFrameQP+3, prc->m_Qc);
  2404.   prc->m_Qc = iClip3(m_Qp-prc->DDquant, img->RCMaxQP, prc->m_Qc); // clipping
  2405.   if(params->basicunit>=prc->MBPerRow)
  2406.     prc->m_Qc = imax(prc->PAveFrameQP-6, prc->m_Qc);
  2407.   else
  2408.     prc->m_Qc = imax(prc->PAveFrameQP-3, prc->m_Qc);
  2410.   prc->m_Qc = imax(img->RCMinQP, prc->m_Qc);
  2411. }
  2413. /*!
  2414.  *************************************************************************************
  2415.  * brief
  2416.  *    update QP variables for interlaced pictures and basic unit coding
  2417.  *************************************************************************************
  2418. */
  2419. void updateQPInterlaceBU( rc_quadratic *prc )
  2420. {
  2421.   /*previous choice is frame coding*/
  2422.   if(generic_RC->FieldFrame==1)
  2423.   {
  2424.     prc->TotalQpforPPicture +=prc->FrameQPBuffer;
  2425.     prc->Pm_Qp=prc->FrameQPBuffer;
  2426.   }
  2427.   /*previous choice is field coding*/
  2428.   else
  2429.   {
  2430.     prc->TotalQpforPPicture +=prc->FieldQPBuffer;
  2431.     prc->Pm_Qp=prc->FieldQPBuffer;
  2432.   }
  2433. }
  2435. /*!
  2436.  *************************************************************************************
  2437.  * brief
  2438.  *    update QP with quadratic model
  2439.  *************************************************************************************
  2440. */
  2441. void updateModelQPFrame( rc_quadratic *prc, int m_Bits )
  2442. {
  2443.   double dtmp, m_Qstep;
  2445.   dtmp = prc->CurrentFrameMAD * prc->m_X1 * prc->CurrentFrameMAD * prc->m_X1
  2446.     + 4 * prc->m_X2 * prc->CurrentFrameMAD * m_Bits;
  2447.   if ((prc->m_X2 == 0.0) || (dtmp < 0) || ((sqrt (dtmp) - prc->m_X1 * prc->CurrentFrameMAD) <= 0.0)) // fall back 1st order mode
  2448.     m_Qstep = (float) (prc->m_X1 * prc->CurrentFrameMAD / (double) m_Bits);
  2449.   else // 2nd order mode
  2450.     m_Qstep = (float) ((2 * prc->m_X2 * prc->CurrentFrameMAD) / (sqrt (dtmp) - prc->m_X1 * prc->CurrentFrameMAD));
  2452.   prc->m_Qc = Qstep2QP(m_Qstep);
  2453. }
  2455. /*!
  2456.  *************************************************************************************
  2457.  * brief
  2458.  *    rate control at the MB level
  2459.  *************************************************************************************
  2460. */
  2461. int rc_handle_mb( int prev_mb, Macroblock *currMB, Slice *curr_slice )
  2462. {
  2463.   int  mb_qp = img->qp;
  2464.   Macroblock *prevMB = NULL;
  2466.   if (prev_mb > -1)
  2467.   {
  2468.     prevMB = &img->mb_data[prev_mb];
  2470.     if ( params->MbInterlace == ADAPTIVE_CODING && !img->bot_MB && currMB->mb_field )
  2471.       mb_qp = prevMB->qp;
  2472.   }
  2474.   // frame layer rate control
  2475.   if (params->basicunit != img->FrameSizeInMbs)
  2476.   {
  2477.     // each I or B frame has only one QP
  2478.     if ( ((img->type == I_SLICE || img->type == B_SLICE) && params->RCUpdateMode != RC_MODE_1 ) || !(img->number) )
  2479.     {
  2480.       return mb_qp;
  2481.     }
  2482.     else if ( img->type == P_SLICE || params->RCUpdateMode == RC_MODE_1 )
  2483.     {
  2484.       if (!img->write_macroblock) //write macroblock
  2485.       {
  2486.         if (prev_mb > -1) 
  2487.         {      
  2488.           if (!((params->MbInterlace) && img->bot_MB)) //top macroblock
  2489.           {
  2490.             if (prevMB->prev_cbp != 1)
  2491.             {
  2492.               mb_qp = prevMB->prev_qp;
  2493.             }
  2494.           }
  2495.         }
  2496.       }
  2498.       // compute the quantization parameter for each basic unit of P frame
  2500.       if (!img->write_macroblock)
  2501.       {
  2502.         if(!((params->MbInterlace) && img->bot_MB))
  2503.         {
  2504.           if(params->RCUpdateMode <= MAX_RC_MODE && (img->NumberofCodedMacroBlocks > 0) && (img->NumberofCodedMacroBlocks % img->BasicUnit == 0))
  2505.           {
  2506.             updateRCModel(quadratic_RC);
  2507.             // frame coding
  2508.             if(active_sps->frame_mbs_only_flag)
  2509.             {
  2510.               img->BasicUnitQP = updateQP(quadratic_RC, generic_RC->TopFieldFlag);
  2512.             }
  2513.             // picture adaptive field/frame coding
  2514.             else if(params->MbInterlace || ((params->PicInterlace!=FRAME_CODING) && (generic_RC->NoGranularFieldRC==0)))
  2515.             {
  2516.               img->BasicUnitQP = updateQP(quadratic_RC, generic_RC->TopFieldFlag);
  2517.             }
  2518.           }
  2520.           if(img->current_mb_nr==0)
  2521.             img->BasicUnitQP = mb_qp;
  2524.           mb_qp = img->BasicUnitQP;
  2525.           mb_qp = iClip3(-img->bitdepth_luma_qp_scale, 51, mb_qp);
  2526.         }
  2527.       }
  2528.     }
  2529.   }
  2530.   return mb_qp;
  2531. }
  2533. /*!
  2534.  *************************************************************************************
  2535.  * brief
  2536.  *    initialize rate control model for the top field
  2537.  *************************************************************************************
  2538. */
  2539. void rc_init_top_field ( void )
  2540. {
  2541.   img->BasicUnit = params->basicunit;
  2542.   generic_RC->TopFieldFlag = 1;
  2543.   rc_init_pict_ptr(quadratic_RC, 0, 1, (params->PicInterlace == FIELD_CODING), 1.0F); 
  2544.   img->qp = updateQP(quadratic_RC, 1);
  2545. }
  2547. /*!
  2548.  *************************************************************************************
  2549.  * brief
  2550.  *    initialize rate control model for the bottom field
  2551.  *************************************************************************************
  2552. */
  2553. void rc_init_bottom_field ( int TopFieldBits )
  2554. {
  2555.   quadratic_RC->bits_topfield = TopFieldBits;
  2556.   generic_RC->TopFieldFlag = 0;
  2557.   rc_init_pict_ptr(quadratic_RC, 0,0,0, 1.0F); 
  2558.   img->qp  = updateQP(quadratic_RC, 0); 
  2559. }
  2561. /*!
  2562.  *************************************************************************************
  2563.  * brief
  2564.  *    initialize rate control for RDPictureDecision
  2565.  *************************************************************************************
  2566. */
  2567. void rc_init_frame_rdpic( float rateRatio )
  2568. {
  2569.   switch (params->RCUpdateMode)
  2570.   {
  2571.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2572.     // re-store the initial RC model
  2573.     rc_copy_quadratic( quadratic_RC, quadratic_RC_init );
  2574.     rc_copy_generic( generic_RC, generic_RC_init );
  2575.     rc_init_pict_ptr(quadratic_RC, 1,0,1, rateRatio );
  2576.     img->qp  = updateQP(quadratic_RC, 0);
  2577.     break;
  2578.   default:
  2579.     break;
  2580.   }
  2581. }
  2583. /*!
  2584.  *************************************************************************************
  2585.  * brief
  2586.  *    allocate rate control memory
  2587.  *************************************************************************************
  2588. */
  2589. void rc_allocate_memory( void )
  2590. {
  2591.   switch (params->RCUpdateMode)
  2592.   {
  2593.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2594.     rc_alloc_generic( &generic_RC );
  2595.     rc_alloc_quadratic( &quadratic_RC );
  2596.     if ( params->RDPictureDecision || params->MbInterlace == ADAPTIVE_CODING )
  2597.     {
  2598.       rc_alloc_generic( &generic_RC_init );
  2599.       rc_alloc_quadratic( &quadratic_RC_init );
  2600.       rc_alloc_generic( &generic_RC_best );
  2601.       rc_alloc_quadratic( &quadratic_RC_best );
  2602.     }
  2603.     break;
  2604.   default:
  2605.     break;
  2606.   }
  2607. }
  2609. /*!
  2610.  *************************************************************************************
  2611.  * brief
  2612.  *    free rate control memory
  2613.  *************************************************************************************
  2614. */
  2615. void rc_free_memory( void )
  2616. {
  2617.   switch (params->RCUpdateMode)
  2618.   {
  2619.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2620.     rc_free_generic( &generic_RC );
  2621.     rc_free_quadratic( &quadratic_RC );
  2623.     if ( params->RDPictureDecision || params->MbInterlace == ADAPTIVE_CODING )
  2624.     {
  2625.       rc_free_generic( &generic_RC_init );
  2626.       rc_free_quadratic( &quadratic_RC_init );
  2627.       rc_free_generic( &generic_RC_best );
  2628.       rc_free_quadratic( &quadratic_RC_best );
  2629.     }
  2630.     break;
  2631.   default:
  2632.     break;
  2633.   }
  2634. }
  2636. /*!
  2637.  *************************************************************************************
  2638.  * brief
  2639.  *    update coding statistics after MB coding
  2640.  *************************************************************************************
  2641. */
  2642. void rc_update_mb_stats( Macroblock *currMB, int *bitCount )
  2643. {
  2644.   // Rate control
  2645.   img->NumberofMBHeaderBits = bitCount[BITS_MB_MODE] + bitCount[BITS_INTER_MB]
  2646.                             + bitCount[BITS_CBP_MB ] + bitCount[BITS_DELTA_QUANT_MB];
  2647.   img->NumberofMBTextureBits = bitCount[BITS_COEFF_Y_MB]+ bitCount[BITS_COEFF_UV_MB];
  2649.   switch (params->RCUpdateMode)
  2650.   {
  2651.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2652.     generic_RC->NumberofTextureBits += img->NumberofMBTextureBits;
  2653.     generic_RC->NumberofHeaderBits  += img->NumberofMBHeaderBits;
  2654.     // basic unit layer rate control
  2655.     if(img->BasicUnit < img->FrameSizeInMbs)
  2656.     {
  2657.       generic_RC->NumberofBasicUnitHeaderBits  += img->NumberofMBHeaderBits;
  2658.       generic_RC->NumberofBasicUnitTextureBits += img->NumberofMBTextureBits;
  2659.     }
  2660.     break;
  2661.   default:
  2662.     break;
  2663.   }
  2664. }
  2666. /*!
  2667.  *************************************************************************************
  2668.  * brief
  2669.  *    save state of rate control model
  2670.  *************************************************************************************
  2671. */
  2672. void rc_save_state( void )
  2673. {
  2674.   switch (params->RCUpdateMode)
  2675.   {
  2676.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2677.     rc_copy_quadratic( quadratic_RC_best, quadratic_RC );
  2678.     rc_copy_generic( generic_RC_best, generic_RC );
  2679.     break;
  2680.   default:
  2681.     break;
  2682.   }
  2683. }
  2685. /*!
  2686.  *************************************************************************************
  2687.  * brief
  2688.  *    restore state of rate control model
  2689.  *************************************************************************************
  2690. */
  2691. void rc_restore_state( void )
  2692. {
  2693.   switch (params->RCUpdateMode)
  2694.   {
  2695.   case RC_MODE_0:  case RC_MODE_1:  case RC_MODE_2:  case RC_MODE_3:
  2696.     rc_copy_quadratic( quadratic_RC, quadratic_RC_best );
  2697.     rc_copy_generic( generic_RC, generic_RC_best );
  2698.     break;
  2699.   default:
  2700.     break;
  2701.   }
  2702. }