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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
common.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：13k
源码类别：

多媒体编程

开发平台：

Visual C++

common.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. *
  3. * $Id: common.cpp,v 1.2 2005/01/30 05:11:40 gabest Exp $ $Name:  $
  4. *
  5. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  6. *
  7. * The contents of this file are subject to the Mozilla Public License
  8. * Version 1.1 (the "License"); you may not use this file except in compliance
  9. * with the License. You may obtain a copy of the License at
  10. * http://www.mozilla.org/MPL/
  11. *
  12. * Software distributed under the License is distributed on an "AS IS" basis,
  13. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  14. * the specific language governing rights and limitations under the License.
  15. *
  16. * The Original Code is BBC Research and Development code.
  17. *
  18. * The Initial Developer of the Original Code is the British Broadcasting
  19. * Corporation.
  20. * Portions created by the Initial Developer are Copyright (C) 2004.
  21. * All Rights Reserved.
  22. *
  23. * Contributor(s): Thomas Davies (Original Author),
  24.                   Scott R Ladd,
  25.                   Tim Borer
  26. *
  27. * Alternatively, the contents of this file may be used under the terms of
  28. * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
  29. * Public License Version 2.1 (the "LGPL"), in which case the provisions of
  30. * the GPL or the LGPL are applicable instead of those above. If you wish to
  31. * allow use of your version of this file only under the terms of the either
  32. * the GPL or LGPL and not to allow others to use your version of this file
  33. * under the MPL, indicate your decision by deleting the provisions above
  34. * and replace them with the notice and other provisions required by the GPL
  35. * or LGPL. If you do not delete the provisions above, a recipient may use
  36. * your version of this file under the terms of any one of the MPL, the GPL
  37. * or the LGPL.
  38. * ***** END LICENSE BLOCK ***** */
  40. #include <libdirac_common/common.h>
  41. #include <algorithm>
  42. using namespace dirac;
  45. //PicArray functions
  47. PicArray::PicArray(int height, int width, CompSort cs):
  48.     TwoDArray<ValueType>(height , width),
  49.     m_csort(cs)
  50. {
  51.          //Nothing
  52. }
  54. const CompSort& PicArray::CSort() const 
  55. {
  56.     return m_csort;
  57. }
  59. void PicArray::SetCSort(const CompSort cs)
  60. {
  61.     m_csort=cs;
  62. }    
  66. //EntropyCorrector functions
  68. EntropyCorrector::EntropyCorrector(int depth): 
  69.     m_Yfctrs( 3 , 3*depth+1 ),
  70.     m_Ufctrs( 3 , 3*depth+1 ),
  71.     m_Vfctrs( 3 , 3*depth+1 )
  72. {
  73.     Init();
  74. }
  76. float EntropyCorrector::Factor(const int bandnum , const FrameSort fsort ,const CompSort c) const
  77. {
  78.     
  79.     if (c == U_COMP)
  80.         return m_Ufctrs[fsort][bandnum-1];
  81.     else if (c == V_COMP)
  82.         return m_Vfctrs[fsort][bandnum-1];
  83.     else
  84.         return m_Yfctrs[fsort][bandnum-1];
  85. }
  87. void EntropyCorrector::Init()
  88. {
  89.     
  90.     //do I-frames
  91.     for (int  i=0 ; i<m_Yfctrs.LengthX() ; ++i )
  92.     {
  93.         if ( i == m_Yfctrs.LastX() )
  94.         {        
  95.             m_Yfctrs[I_frame][i] = 1.0;
  96.             m_Ufctrs[I_frame][i] = 1.0;
  97.             m_Vfctrs[I_frame][i] = 1.0;
  98.             m_Yfctrs[L1_frame][i] = 0.85;
  99.             m_Ufctrs[L1_frame][i] = 0.85;
  100.             m_Vfctrs[L1_frame][i] = 0.85;
  101.             m_Yfctrs[L2_frame][i] = 0.85;
  102.             m_Ufctrs[L2_frame][i] = 0.85;
  103.             m_Vfctrs[L2_frame][i] = 0.85;
  104.         }
  105.         else if ( i >= m_Yfctrs.LastX()-3 )
  106.         {
  107.             m_Yfctrs[I_frame][i] = 0.85;
  108.             m_Ufctrs[I_frame][i] = 0.85;
  109.             m_Vfctrs[I_frame][i] = 0.85;
  110.             m_Yfctrs[L1_frame][i] = 0.75;
  111.             m_Ufctrs[L1_frame][i] = 0.75;
  112.             m_Vfctrs[L1_frame][i] = 0.75;
  113.             m_Yfctrs[L2_frame][i] = 0.75;
  114.             m_Ufctrs[L2_frame][i] = 0.75;
  115.             m_Vfctrs[L2_frame][i] = 0.75;            
  116.         }
  117.         else
  118.         {
  119.             m_Yfctrs[I_frame][i] = 0.75;
  120.             m_Ufctrs[I_frame][i] = 0.75;
  121.             m_Vfctrs[I_frame][i] = 0.75;
  122.             m_Yfctrs[L1_frame][i] = 0.75;
  123.             m_Ufctrs[L1_frame][i] = 0.75;
  124.             m_Vfctrs[L1_frame][i] = 0.75;
  125.             m_Yfctrs[L2_frame][i] = 0.75;
  126.             m_Ufctrs[L2_frame][i] = 0.75;
  127.             m_Vfctrs[L2_frame][i] = 0.75;            
  128.         }
  129.     }//i
  130.     
  131. }
  133. void EntropyCorrector::Update(int bandnum , FrameSort fsort , CompSort c ,int est_bits , int actual_bits){
  134.     //updates the factors - note that the estimated bits are assumed to already include the correction factor
  135.     
  136.     float multiplier;
  137.     if (actual_bits != 0 && est_bits != 0)
  138.         multiplier = float(actual_bits)/float(est_bits);
  139.     else
  140.         multiplier=1.0;
  141.     if (c == U_COMP)
  142.         m_Ufctrs[fsort][bandnum-1] *= multiplier;
  143.     else if (c == V_COMP)
  144.         m_Vfctrs[fsort][bandnum-1] *= multiplier;
  145.     else
  146.         m_Yfctrs[fsort][bandnum-1] *= multiplier;
  147. }
  149. // Overlapped block parameter functions
  151. OLBParams::OLBParams(const int xblen, int const yblen, int const xbsep, int const ybsep):
  152.     m_xblen(xblen),
  153.     m_yblen(yblen),
  154.     m_xbsep(xbsep),
  155.     m_ybsep(ybsep),
  156.     m_xoffset( (xblen-xbsep)/2 ),
  157.     m_yoffset( (yblen-ybsep)/2 )
  158. {}
  160. namespace dirac
  161. {
  162. std::ostream & operator<< (std::ostream & stream, OLBParams & params)
  163. {
  164.     stream << params.Ybsep() << " " << params.Xbsep();
  165. //     stream << " " <<params.Yblen() << " " << params.Xblen();
  166.     
  167.     return stream;
  168. }
  170. std::istream & operator>> (std::istream & stream, OLBParams & params)
  171. {
  172.     int temp;
  174.     stream >> temp;
  175.     params.SetYbsep(temp);
  177.     stream >> temp;
  178.     params.SetXbsep(temp);
  180. //     stream >> temp;
  181. //     params.SetYblen(temp);
  183. //     stream >> temp;
  184. //     params.SetXblen(temp);
  185.     
  186.     return stream;
  187. }
  189. }
  191. // Codec params functions
  193. CodecParams::CodecParams():
  194.     m_x_num_mb(0),
  195.     m_y_num_mb(0),
  196.     m_x_num_blocks(0),
  197.     m_y_num_blocks(0),
  198.     m_verbose(false),
  199.     m_interlace(false),
  200.     m_topfieldfirst(false),
  201.     m_lbparams(3),
  202.     m_cbparams(3)
  203. {}
  205. void CodecParams::SetBlockSizes(const OLBParams& olbparams , const ChromaFormat cformat)
  206. {
  207.     //given the raw overlapped block parameters, set the modified internal parameters to
  208.     //take account of the chroma sampling format and overlapping requirements, as well
  209.     //as the equivalent parameters for sub-MBs and MBs.
  210.     //Does NOT set the number of blocks or macroblocks, as padding may be required.
  212.     // Factors for scaling chroma blocks
  213.     int xcfactor,ycfactor; 
  214.  
  215.     if (cformat == format420)
  216.     {
  217.         xcfactor = 2;
  218.         ycfactor = 2;
  219.     }
  220.     else if (cformat == format422)
  221.     {
  222.         xcfactor = 2;
  223.         ycfactor = 1;
  225.     }
  226.     else if (cformat==format411)
  227.     {
  228.         xcfactor = 4;
  229.         ycfactor = 1;
  230.     }
  231.     else
  232.     {// assume 444
  233.         xcfactor = 1;
  234.         ycfactor = 1;
  235.     }
  237.     m_lbparams[2] = olbparams;
  238.     
  239.     // Check the separations aren't too small
  240.     m_lbparams[2].SetXbsep( std::max(m_lbparams[2].Xbsep() , 4) );
  241.     m_lbparams[2].SetYbsep( std::max(m_lbparams[2].Ybsep() , 4) );
  243.     // Check the lengths aren't too big (100% is max roll-off)
  244.     m_lbparams[2].SetXblen( std::min(m_lbparams[2].Xbsep()*2 , m_lbparams[2].Xblen()) );
  245.     m_lbparams[2].SetYblen( std::min(m_lbparams[2].Ybsep()*2 , m_lbparams[2].Yblen()) );
  246.     
  247.     // Check overlap is divisible by 2
  248.     if (( m_lbparams[2].Xblen() - m_lbparams[2].Xbsep() )%2 != 0)
  249.         m_lbparams[2].SetXblen( m_lbparams[2].Xblen()-1 );
  250.     if (( m_lbparams[2].Yblen() - m_lbparams[2].Ybsep() )%2 != 0)
  251.         m_lbparams[2].SetYblen( m_lbparams[2].Yblen()-1 );
  253.     // Check there's now sufficient overlap  
  254.     m_lbparams[2].SetXblen( std::max(m_lbparams[2].Xbsep()+2 , m_lbparams[2].Xblen()) );
  255.     m_lbparams[2].SetYblen( std::max(m_lbparams[2].Ybsep()+2 , m_lbparams[2].Yblen()) );
  258.     // If the overlapped blocks don't work for the chroma format, we have to iterate
  259.     if ( (m_lbparams[2].Xbsep()%xcfactor != 0) || (m_lbparams[2].Ybsep()%ycfactor != 0) )
  260.     {
  261.         OLBParams new_olbparams( m_lbparams[2] );
  263.         if (m_lbparams[2].Xbsep()%xcfactor != 0)
  264.             new_olbparams.SetXbsep( ( (m_lbparams[2].Xbsep()/xcfactor) + 1 )*xcfactor );
  266.         if (m_lbparams[2].Ybsep()%ycfactor != 0)
  267.             new_olbparams.SetYbsep( ( (m_lbparams[2].Ybsep()/ycfactor) + 1 )*ycfactor );
  269.         new_olbparams.SetXblen( std::max( new_olbparams.Xbsep()+2 , olbparams.Xblen() ) );
  270.         new_olbparams.SetYblen( std::max( new_olbparams.Xbsep()+2 , olbparams.Xblen() ) );
  271.         
  272.         SetBlockSizes( new_olbparams , cformat );
  273.     }
  274.     
  275.     // Now compute the resulting chroma block params
  277.     m_cbparams[2].SetXbsep( m_lbparams[2].Xbsep()/xcfactor );
  278.     m_cbparams[2].SetYbsep( m_lbparams[2].Ybsep()/ycfactor );
  279.     m_cbparams[2].SetXblen( std::max(m_lbparams[2].Xblen()/xcfactor , m_cbparams[2].Xbsep()+2) );
  280.     m_cbparams[2].SetYblen( std::max(m_lbparams[2].Yblen()/ycfactor , m_cbparams[2].Ybsep()+2) );
  281.     
  282.     //check overlap is divisible by 2
  283.     if (( m_cbparams[2].Xblen() - m_cbparams[2].Xbsep() )%2 != 0)
  284.         m_cbparams[2].SetXblen( m_cbparams[2].Xblen()+1 );
  285.     if (( m_cbparams[2].Yblen() - m_cbparams[2].Ybsep() )%2 != 0)
  286.         m_cbparams[2].SetYblen( m_cbparams[2].Yblen()+1 );
  287.     
  288.     //Now work out the overlaps for splitting levels 1 and 0
  289.     m_lbparams[1].SetXbsep( m_lbparams[2].Xbsep()*2 );
  290.     m_lbparams[1].SetXblen( m_lbparams[2].Xblen() + m_lbparams[2].Xbsep() );
  291.     m_lbparams[1].SetYbsep( m_lbparams[2].Ybsep()*2 );
  292.     m_lbparams[1].SetYblen( m_lbparams[2].Yblen() + m_lbparams[2].Xbsep() );
  293.     
  294.     m_lbparams[0].SetXbsep( m_lbparams[1].Xbsep()*2 );
  295.     m_lbparams[0].SetXblen( m_lbparams[1].Xblen() + m_lbparams[1].Xbsep() );
  296.     m_lbparams[0].SetYbsep( m_lbparams[1].Ybsep()*2 );
  297.     m_lbparams[0].SetYblen( m_lbparams[1].Yblen() + m_lbparams[1].Xbsep() );        
  298.     
  299.     m_cbparams[1].SetXbsep( m_cbparams[2].Xbsep()*2 );
  300.     m_cbparams[1].SetXblen( m_cbparams[2].Xblen() + m_cbparams[2].Xbsep() );
  301.     m_cbparams[1].SetYbsep( m_cbparams[2].Ybsep()*2 );
  302.     m_cbparams[1].SetYblen( m_cbparams[2].Yblen() + m_cbparams[2].Xbsep() );    
  303.     
  304.     m_cbparams[0].SetXbsep( m_cbparams[1].Xbsep()*2 );
  305.     m_cbparams[0].SetXblen( m_cbparams[1].Xblen() + m_cbparams[1].Xbsep() );
  306.     m_cbparams[0].SetYbsep( m_cbparams[1].Ybsep()*2 );
  307.     m_cbparams[0].SetYblen( m_cbparams[1].Yblen() + m_cbparams[1].Xbsep() );        
  308.     
  309. }
  311. //EncoderParams functions
  313. //Default constructor    
  314. EncoderParams::EncoderParams():
  315.     CodecParams(),
  316.     m_qf(5.0),
  317.     m_num_L1(0),
  318.     m_L1_sep(0),
  319.     m_ufactor(1.0),
  320.     m_vfactor(1.0),
  321.     m_cpd(20.0),
  322.     m_I_lambda(0.f),
  323.     m_L1_lambda(0.0f),
  324.     m_L2_lambda(0.0f),
  325.     m_L1_me_lambda(0.0f),
  326.     m_L2_me_lambda(0.0f),
  327.     m_ent_correct(0),
  328.     m_bit_out(0)
  329. {}
  331. float EncoderParams::Lambda(const FrameSort& fsort) const
  332. {
  333.     if (fsort == I_frame)
  334.         return ILambda();
  335.     else if (fsort == L1_frame)
  336.         return L1Lambda();
  337.     else
  338.         return L2Lambda();
  339. }
  342. void EncoderParams::SetLambda(const FrameSort& fsort, const float l)
  343. {
  344.     if (fsort == I_frame)
  345.         SetILambda(l);
  346.     else if (fsort == L1_frame)
  347.         SetL1Lambda(l);
  348.     else
  349.         SetL2Lambda(l);
  350. }
  352. //SeqParams functions
  353. //constructor
  354. SeqParams::SeqParams():
  355.     m_xl(0),
  356.     m_yl(0),
  357.     m_cformat(format422),
  358.     m_interlace(false),
  359.     m_topfieldfirst(true),
  360.     m_framerate(12)
  361. {}
  363. int SeqParams::ChromaWidth() const
  364. {
  365.     switch (m_cformat)
  366.     {
  367.     case Yonly:
  368.         return 0;
  369.     case format411:
  370.         return m_xl/4;
  372.     case format420:
  373.     case format422:
  374.         return m_xl/2;
  376.     case format444:
  377.     default:
  378.         return m_xl;
  379.     }
  380. }
  382. int SeqParams::ChromaHeight() const
  383. {
  384.     switch (m_cformat)
  385.     {
  386.     case Yonly:
  387.         return 0;
  388.         return m_yl;
  390.     case format420:
  391.         return m_yl/2;
  393.     case format422:
  394.     case format444:
  395.     case format411:
  396.     default:
  397.         return m_yl;
  398.     }
  399. }
  400. //FrameParams functions
  402. // Default constructor
  403. FrameParams::FrameParams():
  404. m_fsort(I_frame),
  405. m_output(false)
  406. {}    
  408. // Constructor 
  409. FrameParams::FrameParams(const ChromaFormat& cf, int xlen, int ylen):
  410.     m_cformat(cf),
  411.     m_xl(xlen),
  412.     m_yl(ylen),
  413.     m_fsort(I_frame),
  414.     m_output(false)
  415. {}
  417. // Constructor
  418. FrameParams::FrameParams(const ChromaFormat& cf, const FrameSort& fs):
  419.     m_cformat(cf),
  420.     m_fsort(fs),
  421.     m_output(false)
  422. {}    
  424. // Constructor
  425. FrameParams::FrameParams(const SeqParams& sparams):
  426.     m_cformat(sparams.CFormat()),
  427.     m_xl(sparams.Xl()),
  428.     m_yl(sparams.Yl()),
  429.     m_fsort(I_frame),
  430.     m_output(false)
  431. {}
  433. // Constructor
  434. FrameParams::FrameParams(const SeqParams& sparams, const FrameSort& fs):
  435.     m_cformat(sparams.CFormat()),
  436.     m_xl(sparams.Xl()),
  437.     m_yl(sparams.Yl()),
  438.     m_fsort(fs),
  439.     m_output(false)
  440. {}