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

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

多媒体编程

开发平台：

Visual C++

band_codec.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. *
  3. * $Id: band_codec.cpp,v 1.5 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), Scott R Ladd
  24. *
  25. * Alternatively, the contents of this file may be used under the terms of
  26. * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
  27. * Public License Version 2.1 (the "LGPL"), in which case the provisions of
  28. * the GPL or the LGPL are applicable instead of those above. If you wish to
  29. * allow use of your version of this file only under the terms of the either
  30. * the GPL or LGPL and not to allow others to use your version of this file
  31. * under the MPL, indicate your decision by deleting the provisions above
  32. * and replace them with the notice and other provisions required by the GPL
  33. * or LGPL. If you do not delete the provisions above, a recipient may use
  34. * your version of this file under the terms of any one of the MPL, the GPL
  35. * or the LGPL.
  36. * ***** END LICENSE BLOCK ***** */
  38. #include <libdirac_common/band_codec.h>
  39. using namespace dirac;
  41. //! Constructor for encoding.
  42. BandCodec::BandCodec(BasicOutputManager* bits_out,
  43.                      size_t number_of_contexts,
  44.                      const SubbandList & band_list,
  45.                      int band_num):
  46.     ArithCodec<PicArray>(bits_out,number_of_contexts),
  47.     m_bnum(band_num),
  48.     m_node(band_list(band_num)),
  49.     m_xp(m_node.Xp()),
  50.     m_yp(m_node.Yp()),
  51.     m_xl(m_node.Xl()),
  52.     m_yl(m_node.Yl()),
  53.     m_vol(m_node.Xl()*m_node.Yl()),
  54.     m_reset_coeff_num( std::max( 25 , std::min(m_vol/32,800) ) ),
  55.     m_cut_off_point(m_node.Scale()>>1)
  56. {
  57.     if (m_node.Parent()!=0) 
  58.         m_pnode=band_list(m_node.Parent());
  59. }        
  61. //! Constructor for decoding.
  62. BandCodec::BandCodec(BitInputManager* bits_in,
  63.                      size_t number_of_contexts,
  64.                      const SubbandList& band_list,
  65.                      int band_num):
  66.     ArithCodec<PicArray>(bits_in,number_of_contexts),
  67.     m_bnum(band_num),
  68.     m_node(band_list(band_num)),
  69.     m_xp(m_node.Xp()),
  70.     m_yp(m_node.Yp()),
  71.     m_xl(m_node.Xl()),
  72.     m_yl(m_node.Yl()),
  73.     m_vol(m_node.Xl()*m_node.Yl()),
  74.     m_reset_coeff_num( std::max( 25 , std::min(m_vol/32,800) ) ),
  75.     m_cut_off_point(m_node.Scale()>>1)
  76. {
  77.     if (m_node.Parent()!=0) m_pnode=band_list(m_node.Parent());
  78. }
  80. void BandCodec::InitContexts()
  81. {
  82.     //initialises the contexts. 
  83.     //If _list does not already have values, then they're set to default values. 
  84.     //This way, the constructor can override default initialisation.
  85.     Context tmp_ctx;
  86.     
  87.     for (size_t i=0; i<m_context_list.size(); ++i)
  88.     {
  89.         if (i>=m_context_list.size())
  90.             m_context_list.push_back(tmp_ctx);
  91.         else
  92.         {
  93.             if (m_context_list[i].Weight()==0)
  94.                 m_context_list[i].SetCounts(1,1);
  95.         }
  96.     }
  97. }
  99. void BandCodec::ResetAll()
  100. {
  101.     for (unsigned int c = 0; c < m_context_list.size(); ++c)
  102.         if (m_context_list[c].Weight()>16)
  103.             m_context_list[c].HalveCounts();
  104. }
  106. void BandCodec::Resize(const int context_num)
  107. {
  108.     m_context_list[context_num].HalveCounts();
  109. }
  111. void BandCodec::Update( const bool symbol , const int context_num )
  112. {
  113.     m_context_list[context_num].IncrCount(symbol,1);
  114.     
  115.     if ( m_context_list[context_num].Weight() >= 1024 )
  116.         Resize( context_num );
  117. }
  119. int BandCodec::ChooseContext(const PicArray& data) const{ return NZ_BIN5plus_CTX; }
  121. //encoding function
  122. void BandCodec::DoWorkCode(PicArray& in_data)
  123. {
  125.     //main coding function, using binarisation
  126.     if (m_node.Parent()!=0)
  127.     {
  128.         m_pxp=m_pnode.Xp(); m_pyp=m_pnode.Yp();
  129.         m_pxl=m_pnode.Xl(); m_pyl=m_pnode.Yl();
  130.     }
  131.     else
  132.     {
  133.         m_pxp=0; m_pyp=0;
  134.         m_pxl=0; m_pyl=0;
  135.     }
  136.     
  137.     ValueType val;
  138.     m_qf=m_node.Qf(0);
  139.     m_qfinv=(1<<17)/m_qf;
  140.     m_offset=(3*m_qf+4)>>3;    
  141.     m_cut_off_point*=m_qf;
  143.     m_coeff_count=0;
  145.     for (m_ypos=m_yp,m_pypos=m_pyp;m_ypos<m_yp+m_yl;++m_ypos,m_pypos=((m_ypos-m_yp)>>1)+m_pyp)
  146.     {
  147.         for (m_xpos=m_xp,m_pxpos=m_pxp;m_xpos<m_xp+m_xl;++m_xpos,m_pxpos=((m_xpos-m_xp)>>1)+m_pxp)
  148.         {
  149.             if (m_xpos==m_xp)
  150.                 m_nhood_sum = (m_ypos!=m_yp) ? std::abs(in_data[m_ypos-1][m_xpos]) : 0;
  151.             else
  152.                 m_nhood_sum = (m_ypos!=m_yp) ? 
  153.                 (std::abs(in_data[m_ypos-1][m_xpos]) + std::abs(in_data[m_ypos][m_xpos-1])) 
  154.                : std::abs(in_data[m_ypos][m_xpos-1]);
  155.                 
  156.             m_parent_notzero = static_cast<bool> ( in_data[m_pypos][m_pxpos] );
  157.             val = in_data[m_ypos][m_xpos];
  158.             in_data[m_ypos][m_xpos]=0;
  159.             CodeVal( in_data , val );
  161.         }//m_xpos
  162.     }//m_ypos    
  164. #if defined(VERBOSE_DEBUG)
  165.     // Show the symbol counts
  166.     cerr<<endl<<"Context counts";
  167.     
  168.     for (int c = 0; c < 16; ++c)
  169.          cerr << endl
  170.              << c
  171.              << ": Zero-"
  172.              << ContextList()[c].get_count0()
  173.              << ", One-"
  174.              << ContextList()[c].get_count1();
  175. #endif
  176. }
  178. void BandCodec::CodeVal( PicArray& in_data , const ValueType val )
  179. {
  180.     int abs_val( std::abs(val) );
  181.     abs_val *= m_qfinv;
  182.     abs_val >>= 17;
  184.     for ( int bin=1 ; bin<=abs_val ; ++bin )
  185.         EncodeSymbol( 0 , ChooseContext( in_data , bin ) );
  186.     
  187.     EncodeSymbol( 1 , ChooseContext( in_data , abs_val+1 ) );
  189.     if ( abs_val )
  190.     {
  191.         abs_val *= m_qf;
  192.         in_data[m_ypos][m_xpos] = static_cast<ValueType>( abs_val );                
  193.         
  194.         if ( val>0 )
  195.         {
  196.             EncodeSymbol( 1 , ChooseSignContext( in_data ) );
  197.             in_data[m_ypos][m_xpos] += m_offset;
  198.         }
  199.         else
  200.         {
  201.             EncodeSymbol( 0 , ChooseSignContext(in_data) );
  202.             in_data[m_ypos][m_xpos]  = -in_data[m_ypos][m_xpos];
  203.             in_data[m_ypos][m_xpos] -= m_offset;
  204.         }
  205.     }
  206.     
  207.     m_coeff_count++;
  208.     
  209.     if (m_coeff_count > m_reset_coeff_num)
  210.     {
  211.         m_coeff_count=0;
  212.         ResetAll();
  213.     }
  214. }
  216. void BandCodec::DoWorkDecode(PicArray& out_data, int num_bits)
  217. {
  219.     if (m_node.Parent()!=0)
  220.     {
  221.         m_pxp = m_pnode.Xp();
  222.         m_pyp = m_pnode.Yp();
  223.         m_pxl = m_pnode.Xl();
  224.         m_pyl = m_pnode.Yl();
  225.     }
  226.     else
  227.     {
  228.         m_pxp = 0;
  229.         m_pyp = 0;
  230.         m_pxl = 0;
  231.         m_pyl = 0;
  232.     }    
  234.     m_qf = m_node.Qf(0);
  235.     m_offset = (3 * m_qf + 4) >> 3;
  236.     m_cut_off_point *= m_qf;
  238.     //Work
  239.     m_coeff_count=0;
  240.     
  241.     for (m_ypos=m_yp,m_pypos=m_pyp;m_ypos<m_yp+m_yl;++m_ypos,m_pypos=((m_ypos-m_yp)>>1)+m_pyp)
  242.     {        
  243.         for (m_xpos = m_xp, m_pxpos = m_pxp; m_xpos < m_xp+m_xl; ++m_xpos, m_pxpos=((m_xpos-m_xp)>>1)+m_pxp)
  244.         {
  245.             if (m_xpos == m_xp)
  246.                 m_nhood_sum=(m_ypos!=m_yp) ? std::abs(out_data[m_ypos-1][m_xpos]): 0;
  247.             else
  248.                 m_nhood_sum=(m_ypos!=m_yp) ? 
  249.                 (std::abs(out_data[m_ypos-1][m_xpos]) + std::abs(out_data[m_ypos][m_xpos-1])) 
  250.               : std::abs(out_data[m_ypos][m_xpos-1]);
  251.             
  252.             m_parent_notzero = static_cast<bool>( out_data[m_pypos][m_pxpos] );            
  253.             DecodeVal(out_data);            
  254.         }//m_xpos
  255.     }//m_ypos
  256. }
  258. void BandCodec::DecodeVal(PicArray& out_data)
  259. {
  260.     ValueType val = 0;
  261.     bool bit;
  262.     int  bin = 1;
  263.     
  264.     do
  265.     {
  266.         DecodeSymbol(bit,ChooseContext(out_data,bin));
  267.         
  268.         if (!bit)
  269.             val++;
  270.         
  271.         bin++;
  272.     }
  273.     while (!bit);            
  275.     out_data[m_ypos][m_xpos] = val;
  276.     
  277.     if (out_data[m_ypos][m_xpos])
  278.     {
  279.         out_data[m_ypos][m_xpos] *= m_qf;
  280.         out_data[m_ypos][m_xpos] += m_offset;
  281.         DecodeSymbol( bit , ChooseSignContext(out_data) );
  282.     }
  283.     
  284.     if (!bit)
  285.         out_data[m_ypos][m_xpos]=-out_data[m_ypos][m_xpos];
  287.     m_coeff_count++;
  288.     
  289.     if (m_coeff_count>m_reset_coeff_num)
  290.     {
  291.         ResetAll();
  292.         m_coeff_count=0;
  293.     }
  294. }
  296. int BandCodec::ChooseContext(const PicArray& data, const int BinNumber) const
  297. {
  298.     //condition on neighbouring values and parent values
  299.     if (!m_parent_notzero && (m_pxp != 0 || m_pyp != 0))
  300.     {
  301.         if (BinNumber == 1)
  302.         {
  303.             if(m_nhood_sum == 0)
  304.                 return Z_BIN1z_CTX;
  305.             else
  306.                 return Z_BIN1nz_CTX;
  307.         }
  308.         else if(BinNumber == 2)
  309.             return Z_BIN2_CTX;
  310.         else if(BinNumber == 3)
  311.             return Z_BIN3_CTX;
  312.         else if(BinNumber == 4)
  313.             return Z_BIN4_CTX;
  314.         else
  315.             return Z_BIN5plus_CTX;
  316.     }
  317.     else
  318.     {
  319.         if (BinNumber == 1)
  320.         {
  321.             if(m_nhood_sum == 0)
  322.                 return NZ_BIN1z_CTX;
  323.             else if (m_nhood_sum>m_cut_off_point)
  324.                 return NZ_BIN1b_CTX;
  325.             else
  326.                 return NZ_BIN1a_CTX;
  327.         }
  328.         else if(BinNumber == 2)
  329.             return NZ_BIN2_CTX;
  330.         else if(BinNumber == 3)
  331.             return NZ_BIN3_CTX;
  332.         else if(BinNumber == 4)
  333.             return NZ_BIN4_CTX;
  334.         else
  335.             return NZ_BIN5plus_CTX;
  336.     }
  337. }
  339. int BandCodec::ChooseSignContext(const PicArray& data) const
  340. {    
  341.     if (m_yp == 0 && m_xp != 0)
  342.     {
  343.         //we're in a vertically oriented subband
  344.         if (m_ypos == 0)
  345.             return SIGN0_CTX;
  346.         else
  347.         {
  348.             if (data[m_ypos-1][m_xpos]>0)
  349.                 return SIGN_POS_CTX;        
  350.             else if (data[m_ypos-1][m_xpos]<0)
  351.                 return SIGN_NEG_CTX;
  352.             else
  353.                 return SIGN0_CTX;
  354.         }        
  355.     }
  356.     else if (m_xp == 0 && m_yp != 0)
  357.     {
  358.         //we're in a horizontally oriented subband
  359.         if (m_xpos == 0)
  360.             return SIGN0_CTX;
  361.         else
  362.         {
  363.             if ( data[m_ypos][m_xpos-1] > 0 )
  364.                 return SIGN_POS_CTX;                
  365.             else if ( data[m_ypos][m_xpos-1] < 0 )
  366.                 return SIGN_NEG_CTX;
  367.             else
  368.                 return SIGN0_CTX;
  369.         }
  370.     }
  371.     else
  372.         return SIGN0_CTX;
  373. }
  375. //////////////////////////////////////////////////////////////////////////////////
  376. //Now for special class for LF bands (since we don't want/can't refer to parent)//
  377. //////////////////////////////////////////////////////////////////////////////////
  379. void LFBandCodec::DoWorkCode(PicArray& in_data)
  380. {
  381.     //main coding function, using binarisation
  382.     m_pxp = 0;
  383.     m_pyp = 0;
  384.     m_parent_notzero = false; //set parent to always be zero
  385.     ValueType val;
  387.     m_qf     = m_node.Qf(0);
  388.     m_qfinv  = (1<<17)/m_qf;
  389.     m_offset = (3*m_qf+4)>>3;
  390.     m_cut_off_point*=m_qf;
  392.     m_coeff_count = 0;
  393.     
  394.     for ( m_ypos=m_yp ; m_ypos<m_yp+m_yl ; ++m_ypos )
  395.     {        
  396.         for ( m_xpos=m_xp ; m_xpos<m_xp+m_xl ; ++m_xpos )
  397.         {
  398.             if ( m_xpos == m_xp )
  399.                 m_nhood_sum = (m_ypos!=m_yp) ? std::abs(in_data[m_ypos-1][m_xpos]) : 0;
  400.             else
  401.                 m_nhood_sum = (m_ypos!=m_yp) ? 
  402.                 (std::abs(in_data[m_ypos-1][m_xpos]) + std::abs(in_data[m_ypos][m_xpos-1])) 
  403.                : std::abs(in_data[m_ypos][m_xpos-1]);    
  404.             
  405.             val = in_data[m_ypos][m_xpos];
  406.             in_data[m_ypos][m_xpos] = 0;
  407.             CodeVal(in_data,val);            
  408.         }//m_xpos
  409.     }//m_ypos    
  410. }
  412. void LFBandCodec::DoWorkDecode(PicArray& out_data, int num_bits)
  413. {
  414.     m_pxp = 0;
  415.     m_pyp = 0;
  416.     m_parent_notzero = false;//set parent to always be zero    
  417.     m_qf = m_node.Qf(0);
  418.     m_offset = (3*m_qf+4)>>3;
  419.     m_cut_off_point *= m_qf;
  421.     //Work
  422.     m_coeff_count = 0;
  423.     
  424.     for ( m_ypos=m_yp ; m_ypos<m_yp+m_yl ; ++m_ypos )
  425.     {
  426.         for ( m_xpos=0 ; m_xpos<m_xp+m_xl; ++m_xpos )
  427.         {
  428.             if ( m_xpos == m_xp )
  429.                 m_nhood_sum=(m_ypos!=m_yp) ? std::abs(out_data[m_ypos-1][m_xpos]) : 0;
  430.             else
  431.                 m_nhood_sum=(m_ypos!=m_yp) ? 
  432.                 (std::abs(out_data[m_ypos-1][m_xpos]) + std::abs(out_data[m_ypos][m_xpos-1])) 
  433.                : std::abs(out_data[m_ypos][m_xpos-1]);
  435.             DecodeVal(out_data);            
  436.         }//m_xpos
  437.     }//m_ypos
  438. }
  440. //////////////////////////////////////////////////////////////////////////////////
  441. //Finally,special class incorporating prediction for the DC band of intra frames//
  442. //////////////////////////////////////////////////////////////////////////////////
  444. void IntraDCBandCodec::DoWorkCode(PicArray& in_data)
  445. {
  446.     //main coding function, using binarisation
  447.     m_pxp = 0;
  448.     m_pyp = 0;
  450.     //set parent to always be zero
  451.     m_parent_notzero = false;
  452.     ValueType val;
  453.     
  454.     //residues after prediction, quantisation and inverse quant
  455.     PicArray pred_res(m_yl , m_xl);
  456.     ValueType prediction;
  458.     m_qf     = m_node.Qf(0);
  459.     m_qfinv  = (1<<17) / m_qf;
  460.     m_offset = (3*m_qf+4) >> 3;
  461.     m_cut_off_point *= m_qf;
  463.     m_coeff_count=0;
  464.     
  465.     for (m_ypos=m_yp; m_ypos < m_yp + m_yl; ++m_ypos)
  466.     {
  467.         for (m_xpos = m_xp; m_xpos < m_xp + m_xl; ++m_xpos)
  468.         {
  469.              if (m_xpos == m_xp)
  470.                 m_nhood_sum = (m_ypos!=m_yp) ? std::abs(pred_res[m_ypos-1][m_xpos]) : 0;
  471.              else
  472.                  m_nhood_sum = (m_ypos!=m_yp) ? 
  473.                                (std::abs(pred_res[m_ypos-1][m_xpos]) + std::abs(pred_res[m_ypos][m_xpos-1])) 
  474.                               : std::abs(pred_res[m_ypos][m_xpos-1]);
  475.           
  476.             prediction = GetPrediction(in_data);            
  477.             val = in_data[m_ypos][m_xpos]-prediction;
  478.             in_data[m_ypos][m_xpos] = 0;
  479.             CodeVal(in_data,val);            
  480.             pred_res[m_ypos][m_xpos] = in_data[m_ypos][m_xpos];
  481.             in_data[m_ypos][m_xpos] += prediction;
  482.         }//m_xpos
  484. #if defined(VERBOSE_DEBUG)
  485.          cerr << endl
  486.              << "Val at "
  487.              << m_ypos
  488.              << " "
  489.              << m_xl-1
  490.              << " : "
  491.              << in_data[m_ypos][m_xl-1]
  492.              << endl 
  493.              << "Contexts at "
  494.              << m_ypos 
  495.              << " " 
  496.              << m_xl-1 
  497.              << " : ";
  498.              
  499.          for (int c=0;c<18;++c)
  500.              cerr << endl
  501.                  << c 
  502.                  << ": Zero "
  503.                  << ContextList()[c].get_count0()
  504.                  << ", One "
  505.                  << ContextList()[c].get_count1();    
  506. #endif
  507.             
  508.     }//m_ypos    
  509. }
  511. void IntraDCBandCodec::DoWorkDecode(PicArray& out_data, int num_bits)
  512. {
  513.     m_pxp = 0;
  514.     m_pyp = 0;
  515.     m_parent_notzero = false; //set parent to always be zero
  517.     //residues after prediction, quantisation and inverse quant
  518.     PicArray pred_res(m_yl , m_xl); 
  520.     m_qf = m_node.Qf(0);
  521.     m_offset = (3*m_qf+4)>>3;
  522.     m_cut_off_point *= m_qf;
  524.     //Work
  525.     m_coeff_count=0;
  526.     
  527.     for (m_ypos=m_yp;m_ypos<m_yp+m_yl;++m_ypos)
  528.     {
  529.         for (m_xpos=0;m_xpos<m_xp+m_xl;++m_xpos)
  530.         {
  531.              if (m_xpos==m_xp)
  532.                  m_nhood_sum=(m_ypos!=m_yp) ? std::abs(pred_res[m_ypos - 1][m_xpos]) : 0;
  533.              else
  534.                  m_nhood_sum=(m_ypos!=m_yp) ? 
  535.                              (std::abs(pred_res[m_ypos - 1][m_xpos]) + std::abs(pred_res[m_ypos][m_xpos - 1]))
  536.                             : std::abs(pred_res[m_ypos][m_xpos-1]);
  537.           
  538.             DecodeVal(out_data);
  539.              pred_res[m_ypos][m_xpos]=out_data[m_ypos][m_xpos];
  540.             out_data[m_ypos][m_xpos]+=GetPrediction(out_data);
  541.         }//m_xpos
  542.     }//m_ypos
  543. }
  545. ValueType IntraDCBandCodec::GetPrediction(const PicArray& data) const
  546. {
  547.     if (m_ypos!=0)
  548.     {
  549.         if (m_xpos!=0)
  550.             return (data[m_ypos][m_xpos - 1] + data[m_ypos - 1][m_xpos - 1] + data[m_ypos - 1][m_xpos]) / 3;
  551.         else
  552.             return data[m_ypos - 1][0];
  553.     }
  554.     else
  555.     {
  556.         if(m_xpos!=0)
  557.             return data[0][m_xpos - 1];
  558.         else
  559.             return 2692; // TODO: What does this mean? Literal constants like this are dangerous!
  560.     }
  561. }