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

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

多媒体编程

开发平台：

Visual C++

mv_codec.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. *
  3. * $Id: mv_codec.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), 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/mv_codec.h>
  39. using namespace dirac;
  41. //public functions//
  42. ////////////////////
  43. // Constructor for encoding
  44. MvDataCodec::MvDataCodec(BasicOutputManager* bits_out,
  45.                          size_t number_of_contexts,
  46.                          const ChromaFormat& cf)
  47.   : ArithCodec <MvData> (bits_out,number_of_contexts),
  48.     m_cformat(cf)
  49. {
  50.     // nada
  51. }        
  53. // Constructor for decoding
  54. MvDataCodec::MvDataCodec(BitInputManager* bits_in,
  55.                          size_t number_of_contexts,
  56.                          const ChromaFormat& cf)
  57.   : ArithCodec <MvData> (bits_in,number_of_contexts),
  58.     m_cformat(cf)
  59. {
  60.     // nada
  61. }    
  63. void MvDataCodec::InitContexts() 
  64. {
  65.     for (size_t i = 0;  i < m_context_list.size();  ++i)
  66.         m_context_list[i].SetCounts(1,1);     
  67. }
  69.     
  71. //protected functions//
  72. ///////////////////////
  74. inline void MvDataCodec::Resize(const int context_num)
  75. {
  76.     m_context_list[context_num].HalveCounts();     
  77. }
  80. inline void MvDataCodec::Update( const bool symbol , const int context_num )
  81. {    
  82.     m_context_list[context_num].IncrCount( symbol , 1 ); 
  83.     
  84.     if ( m_context_list[context_num].Weight()  >= 1024 )
  85.         Resize( context_num ); 
  86. }
  87. inline void MvDataCodec::ResetAll() {}
  89. //coding functions//
  90. ////////////////////
  92. //prediction functions
  94. //basic context functions
  96. inline int MvDataCodec::ChooseContext(const MvData& data, const int BinNumber) const
  97. {
  98.     return 0;
  99. }
  101. inline int MvDataCodec::ChooseContext(const MvData& data) const
  102. {
  103.     return 0;
  104. }
  106. inline int MvDataCodec::ChooseSignContext(const MvData& data) const
  107. {
  108.     return 0;
  109. }
  111. //proper context functions
  113. inline int MvDataCodec::ChooseMBSContext(const MvData& data, const int BinNumber) const
  114. {
  115.     if (BinNumber == 1)
  116.         return MB_SPLIT_BIN1_CTX; 
  117.     else
  118.         return MB_SPLIT_BIN2_CTX; 
  119. }
  121. inline int MvDataCodec::ChooseMBCContext(const MvData& data) const
  122. {
  123.     return MB_CMODE_CTX; 
  124. }
  126. inline int MvDataCodec::ChoosePredContext(const MvData& data, const int BinNumber) const
  127. {
  128.     if (BinNumber == 1)
  129.         return PMODE_BIN1_CTX; 
  130.     else if (BinNumber == 2)
  131.         return PMODE_BIN2_CTX; 
  132.     else
  133.         return PMODE_BIN3_CTX; 
  134. }
  136. inline int MvDataCodec::ChooseREF1xContext(const MvData& data, const int BinNumber) const
  137. {
  138.     if (BinNumber == 1)
  139.         return REF1x_BIN1_CTX; 
  140.     else if (BinNumber == 2)
  141.         return REF1x_BIN2_CTX; 
  142.     else if (BinNumber == 3)
  143.         return REF1x_BIN3_CTX; 
  144.     else if (BinNumber == 4)
  145.         return REF1x_BIN4_CTX; 
  146.     else
  147.         return REF1x_BIN5plus_CTX; 
  148. }
  150. inline int MvDataCodec::ChooseREF1xSignContext(const MvData& data) const
  151. {
  152.     return REF1x_SIGN0_CTX;
  153. }
  155. inline int MvDataCodec::ChooseREF1yContext(const MvData& data, const int BinNumber) const
  156. {
  157.     if (BinNumber == 1)
  158.         return REF1y_BIN1_CTX; 
  159.     else if (BinNumber == 2)
  160.         return REF1y_BIN2_CTX; 
  161.     else if (BinNumber == 3)
  162.         return REF1y_BIN3_CTX; 
  163.     else if (BinNumber == 4)
  164.         return REF1y_BIN4_CTX; 
  165.     else
  166.         return REF1y_BIN5plus_CTX; 
  167. }
  169. inline int MvDataCodec::ChooseREF1ySignContext(const MvData& data) const
  170. {
  171.     return REF1y_SIGN0_CTX;
  172. }
  174. inline int MvDataCodec::ChooseREF2xContext(const MvData& data, const int BinNumber) const
  175. {
  176.     if (BinNumber == 1)
  177.         return REF2x_BIN1_CTX; 
  178.     else if (BinNumber == 2)
  179.         return REF2x_BIN2_CTX; 
  180.     else if (BinNumber == 3)
  181.         return REF2x_BIN3_CTX; 
  182.     else if (BinNumber == 4)
  183.         return REF2x_BIN4_CTX; 
  184.     else
  185.         return REF2x_BIN5plus_CTX; 
  186. }
  188. inline int MvDataCodec::ChooseREF2xSignContext(const MvData& data) const
  189. {
  190.     return REF2x_SIGN0_CTX; 
  191. }
  193. inline int MvDataCodec::ChooseREF2yContext(const MvData& data, const int BinNumber) const
  194. {
  195.     if (BinNumber == 1)
  196.         return REF2y_BIN1_CTX; 
  197.     else if (BinNumber == 2)
  198.         return REF2y_BIN2_CTX; 
  199.     else if (BinNumber == 3)
  200.         return REF2y_BIN3_CTX; 
  201.     else if (BinNumber == 4)
  202.         return REF2y_BIN4_CTX; 
  203.     else
  204.         return REF2y_BIN5plus_CTX; 
  205. }
  207. inline int MvDataCodec::ChooseREF2ySignContext(const MvData& data) const
  208. {
  209.     return REF2y_SIGN0_CTX; 
  210. }
  212. inline int MvDataCodec::ChooseYDCContext(const MvData& data, const int BinNumber) const
  213. {
  214.     if (BinNumber == 1)
  215.         return YDC_BIN1_CTX; 
  216.     else
  217.         return YDC_BIN2plus_CTX; 
  218. }
  220. inline int MvDataCodec::ChooseUDCContext(const MvData& data, const int BinNumber) const
  221. {
  222.     if (BinNumber == 1)
  223.         return UDC_BIN1_CTX; 
  224.     else
  225.         return UDC_BIN2plus_CTX; 
  226. }
  228. inline int MvDataCodec::ChooseVDCContext(const MvData& data, const int BinNumber) const
  229. {
  230.     if (BinNumber == 1)
  231.         return VDC_BIN1_CTX; 
  232.     else
  233.         return VDC_BIN2plus_CTX; 
  234. }
  236. inline int MvDataCodec::ChooseYDCSignContext(const MvData& data) const
  237. {
  238.     return YDC_SIGN0_CTX; 
  239. }
  241. inline int MvDataCodec::ChooseUDCSignContext(const MvData& data) const
  242. {
  243.     return UDC_SIGN0_CTX; 
  244. }
  246. inline int MvDataCodec::ChooseVDCSignContext(const MvData& data) const
  247. {
  248.     return VDC_SIGN0_CTX; 
  249. }
  251. inline unsigned int MvDataCodec::MBSplitPrediction(const TwoDArray<int> & split_data ) const
  252. {    
  253.     int result = 0;
  254.     
  255.     std::vector < unsigned int >  nbrs;
  256.     
  257.     if (mb_xp > 0 && mb_yp > 0)
  258.     {
  259.         nbrs.push_back( split_data[mb_yp-1][mb_xp] ); 
  260.         nbrs.push_back( split_data[mb_yp-1][mb_xp-1] ); 
  261.         nbrs.push_back( split_data[mb_yp][mb_xp-1] ); 
  263.         result = GetMean(nbrs);     
  264.     }
  265.     else if (mb_xp > 0 && mb_yp == 0)
  266.         result = split_data[mb_yp][mb_xp-1]; 
  267.     else if (mb_xp == 0 && mb_yp > 0)
  268.         result =  split_data[mb_yp-1][mb_xp]; 
  270.     return result; 
  271. }
  273. inline bool MvDataCodec::MBCBModePrediction(const TwoDArray <bool> & cbm_data) const
  274. {
  275.     bool result = true;
  276.     std::vector < unsigned int >  nbrs; 
  277.     
  278.     if (mb_xp > 0 && mb_yp > 0)
  279.     {
  280.         nbrs.push_back( (unsigned int)( cbm_data[mb_yp-1][mb_xp] ) ); 
  281.         nbrs.push_back( (unsigned int)( cbm_data[mb_yp-1][mb_xp-1] ) ); 
  282.         nbrs.push_back( (unsigned int)( cbm_data[mb_yp][mb_xp-1] ) ); 
  284.         result = bool(GetMean(nbrs));     
  285.     }
  286.     else if (mb_xp > 0 && mb_yp == 0)
  287.         result = cbm_data[mb_yp][mb_xp-1]; 
  288.     else if (mb_xp == 0 && mb_yp > 0)
  289.         result = cbm_data[mb_yp-1][mb_xp]; 
  290.     
  291.     return result; 
  292. }
  294. inline unsigned int MvDataCodec::BlockModePrediction(const TwoDArray < PredMode > & preddata) const
  295. {
  296.     unsigned int result = (unsigned int)(REF1_ONLY);
  297.     std::vector <unsigned int> nbrs; 
  298.     
  299.     if (b_xp > 0 && b_yp > 0)
  300.     {
  301.         nbrs.push_back( (unsigned int)( preddata[b_yp-1][b_xp] ) ); 
  302.         nbrs.push_back( (unsigned int)( preddata[b_yp-1][b_xp-1] ) ); 
  303.         nbrs.push_back( (unsigned int)( preddata[b_yp][b_xp-1] ) ); 
  305.         result = GetMean(nbrs);
  306.     }
  307.     else if (b_xp > 0 && b_yp == 0)
  308.         result = preddata[b_yp][b_xp-1]; 
  309.     else if (b_xp == 0 && b_yp > 0)
  310.         result = preddata[b_yp-1][b_xp]; 
  312.     return result; 
  313. }
  315. inline MVector MvDataCodec::Mv1Prediction(const MvArray& mvarray,
  316.                                           const TwoDArray < PredMode > & preddata) const
  317. {
  318.     std::vector <MVector>  nbrs; 
  319.     PredMode pmode;     
  320.     MVector result; 
  321.     
  322.     if (b_xp > 0 && b_yp > 0)
  323.     {
  324.         pmode = preddata[b_yp-1][b_xp]; 
  325.         if (pmode == REF1_ONLY || pmode == REF1AND2) 
  326.             nbrs.push_back(mvarray[b_yp-1][b_xp]); 
  327.         
  328.         pmode = preddata[b_yp-1][b_xp-1]; 
  329.         if (pmode == REF1_ONLY || pmode == REF1AND2)
  330.             nbrs.push_back(mvarray[b_yp-1][b_xp-1]); 
  331.         
  332.         pmode = preddata[b_yp][b_xp-1]; 
  333.         if (pmode == REF1_ONLY || pmode == REF1AND2)        
  334.             nbrs.push_back(mvarray[b_yp][b_xp-1]); 
  335.         
  336.         if (nbrs.size() > 0)
  337.             result = MvMedian(nbrs); 
  338.     }
  339.     else if (b_xp > 0 && b_yp == 0)
  340.     {
  341.         pmode = preddata[0][b_xp-1]; 
  342.         if (pmode == REF1_ONLY || pmode == REF1AND2)
  343.             result = mvarray[0][b_xp-1]; 
  344.     }
  345.     else if (b_xp == 0 && b_yp > 0)
  346.     {
  347.         pmode = preddata[b_yp-1][0]; 
  348.         if (pmode == REF1_ONLY || pmode == REF1AND2)
  349.             result = mvarray[b_yp-1][0]; 
  350.     }
  352.     return result; 
  353. }
  355. inline MVector MvDataCodec::Mv2Prediction(const MvArray & mvarray,
  356.                                           const TwoDArray < PredMode >  & preddata) const
  357. {
  358.     std::vector <MVector>  nbrs; 
  359.     PredMode pmode; 
  360.     MVector result; 
  361.     
  362.     if (b_xp > 0 && b_yp > 0)
  363.     {
  364.         pmode = preddata[b_yp-1][b_xp]; 
  365.         if (pmode == REF2_ONLY || pmode == REF1AND2)
  366.             nbrs.push_back(mvarray[b_yp-1][b_xp]); 
  367.         
  368.         pmode = preddata[b_yp-1][b_xp-1]; 
  369.         if (pmode == REF2_ONLY || pmode == REF1AND2)
  370.             nbrs.push_back(mvarray[b_yp-1][b_xp-1]); 
  371.         
  372.         pmode = preddata[b_yp][b_xp-1]; 
  373.         if (pmode == REF2_ONLY || pmode == REF1AND2)
  374.             nbrs.push_back(mvarray[b_yp][b_xp-1]); 
  375.         
  376.         if (nbrs.size() > 0)
  377.             result = MvMedian(nbrs); 
  378.     }
  379.     else if (b_xp > 0 && b_yp == 0)
  380.     {
  381.         pmode = preddata[0][b_xp-1]; 
  382.         if(pmode == REF2_ONLY || pmode == REF1AND2)
  383.             result = mvarray[0][b_xp-1]; 
  384.     }
  385.     else if (b_xp == 0 && b_yp > 0)
  386.     {
  387.         pmode = preddata[b_yp-1][0]; 
  388.         if(pmode == REF2_ONLY || pmode == REF1AND2)
  389.             result = mvarray[b_yp-1][0]; 
  390.     }
  392.     return result; 
  393. }
  395. inline ValueType MvDataCodec::DCPrediction(const TwoDArray < ValueType > & dcdata,
  396.                                            const TwoDArray < PredMode > & preddata) const
  397. {
  398.     std::vector < int >  nbrs; 
  399.     PredMode pmode;
  400.     ValueType result = 128; 
  401.     
  402.     if (b_xp > 0 && b_yp > 0)
  403.     {
  404.         pmode = preddata[b_yp-1][b_xp]; 
  405.         if (pmode == INTRA) 
  406.             nbrs.push_back(int(dcdata[b_yp-1][b_xp])); 
  407.         
  408.         pmode = preddata[b_yp-1][b_xp-1]; 
  409.         if (pmode == INTRA)
  410.             nbrs.push_back(int(dcdata[b_yp-1][b_xp-1])); 
  411.         
  412.         pmode = preddata[b_yp][b_xp-1]; 
  413.         if (pmode == INTRA)        
  414.             nbrs.push_back(int(dcdata[b_yp][b_xp-1])); 
  415.         
  416.         if (nbrs.size() > 0)
  417.             result = ValueType(GetMean(nbrs));     
  418.     }
  419.     else if (b_xp > 0 && b_yp == 0)
  420.     {
  421.         pmode = preddata[0][b_xp-1]; 
  422.         if (pmode == INTRA)
  423.             result = dcdata[0][b_xp-1]; 
  424.     }
  425.     else if (b_xp == 0 && b_yp > 0)
  426.     {
  427.         pmode = preddata[b_yp-1][0]; 
  428.         if (pmode == INTRA)
  429.             result = dcdata[b_yp-1][0]; 
  430.     }
  432.     return result;
  433. }
  436. void MvDataCodec::DoWorkCode( MvData& in_data )
  437. {
  438.     int step,max; 
  439.     int pstep,pmax; 
  440.     int split_depth; 
  441.     bool common_ref; 
  443.     MB_count = 0; 
  444.     
  445.     for (mb_yp = 0, mb_tlb_y = 0;  mb_yp < in_data.MBSplit().LengthY();  ++mb_yp, mb_tlb_y += 4)
  446.     {
  447.         for (mb_xp = 0,mb_tlb_x = 0; mb_xp < in_data.MBSplit().LengthX(); ++mb_xp,mb_tlb_x += 4)
  448.         {
  449.              //start with split mode
  450.             CodeMBSplit(in_data); 
  451.             split_depth = in_data.MBSplit()[mb_yp][mb_xp]; 
  453.             step = 4  >>  (split_depth); 
  454.             max = (1 << split_depth); 
  456.             //next do common_ref
  457.             if(split_depth != 0)
  458.             {
  459.                 CodeMBCom(in_data); 
  460.                 pstep = step; 
  461.                 pmax = max; 
  462.             }
  463.             else
  464.             {
  465.                 pstep = 4; 
  466.                 pmax = 1; 
  467.             }
  468.             common_ref = in_data.MBCommonMode()[mb_yp][mb_xp]; 
  471.             //do prediction modes            
  472.             for (b_yp = mb_tlb_y; b_yp < mb_tlb_y+4; b_yp += pstep)
  473.                 for (b_xp = mb_tlb_x; b_xp < mb_tlb_x+4; b_xp += pstep)
  474.                     CodePredmode(in_data); 
  475.             
  476.             step = 4 >> (split_depth);             
  477.             
  478.                //now do all the block mvs in the mb            
  479.             for (b_yp = mb_tlb_y; b_yp < mb_tlb_y+4; b_yp += step)
  480.             {
  481.                 for (b_xp = mb_tlb_x; b_xp < mb_tlb_x+4; b_xp += step)
  482.                 {
  483.                     if (in_data.Mode()[b_yp][b_xp] == REF1_ONLY || in_data.Mode()[b_yp][b_xp] == REF1AND2 )
  484.                         CodeMv1(in_data); 
  485.                     
  486.                     if (in_data.Mode()[b_yp][b_xp] == REF2_ONLY || in_data.Mode()[b_yp][b_xp] == REF1AND2 )
  487.                         CodeMv2(in_data); 
  488.                     
  489.                     if(in_data.Mode()[b_yp][b_xp] == INTRA)
  490.                         CodeDC(in_data);                     
  491.                 }//b_xp
  492.             }//b_yp    
  493.             
  494.             //TODO: Update all contexts here?
  495.             
  496.         }//mb_xp
  497.     }//mb_yp
  499. }
  502. void MvDataCodec::CodeMBSplit(const MvData& in_data)
  503. {
  504.     int val = in_data.MBSplit()[mb_yp][mb_xp] - MBSplitPrediction( in_data.MBSplit() ); 
  505.     
  506.     if (val < 0)
  507.         val += 3; //produce prediction mod 3    
  508.     
  509.     int ctx; 
  510.     
  511.     for (int bin = 1; bin <= val; ++bin)
  512.     {
  513.         ctx = ChooseMBSContext(in_data,bin); 
  514.         EncodeSymbol(0,ctx); 
  515.     }
  516.     
  517.     if (val != 2)//if we've had two zeroes, know we must have value 2
  518.         EncodeSymbol(1,ChooseMBSContext(in_data,val+1)); 
  519. }
  521. void MvDataCodec::CodeMBCom(const MvData& in_data)
  522. {
  523.     bool val = in_data.MBCommonMode()[mb_yp][mb_xp]; 
  524.     
  525.     if (val != MBCBModePrediction( in_data.MBCommonMode() ))
  526.         EncodeSymbol( 1 , ChooseMBCContext( in_data ) ); 
  527.     else
  528.         EncodeSymbol( 0 , ChooseMBCContext( in_data ) ); 
  529. }
  531. void MvDataCodec::CodePredmode(const MvData& in_data)
  532. {
  533.     int val = in_data.Mode()[b_yp][b_xp] - BlockModePrediction( in_data.Mode() ); 
  534.     
  535.     if (val < 0)
  536.         val += 4;  //produce value mod 4    
  537.     
  538.     for (int bin = 1;  bin<= val;  ++bin)
  539.         EncodeSymbol( 0 , ChoosePredContext( in_data , bin ) ); 
  540.                  
  541.     if (val  !=  3) //if we've had three zeroes, know we must have value 3
  542.         EncodeSymbol( 1 , ChoosePredContext( in_data , val + 1 ) ); 
  543. }
  545. void MvDataCodec::CodeMv1(const MvData& in_data )
  546. {
  547.     const MvArray& mv_array = in_data.Vectors(1);
  548.     const MVector pred = Mv1Prediction( mv_array , in_data.Mode() ); 
  550.     const int valx = mv_array[b_yp][b_xp].x - pred.x; 
  551.     const int abs_valx = std::abs(valx); 
  552.     
  553.     for (int bin = 1;  bin  <= abs_valx;  ++bin)
  554.         EncodeSymbol( 0 , ChooseREF1xContext( in_data , bin ) ); 
  556.     EncodeSymbol( 1 , ChooseREF1xContext( in_data , abs_valx + 1 ) ); 
  557.     
  558.     if (valx != 0)
  559.         EncodeSymbol( ( (valx > 0)? 1 : 0) , ChooseREF1xSignContext( in_data ) ); 
  561.     const int valy = mv_array[b_yp][b_xp].y - pred.y;         
  562.     const int abs_valy = std::abs( valy );     
  563.     
  564.     for (int bin = 1; bin<=abs_valy ; ++bin )
  565.         EncodeSymbol( 0 , ChooseREF1yContext( in_data , bin ) );         
  566.     
  567.     EncodeSymbol( 1 , ChooseREF1yContext( in_data , abs_valy + 1 ) ); 
  568.     
  569.     if (valy != 0)
  570.         EncodeSymbol( ( (valy > 0)? 1 : 0) , ChooseREF1ySignContext( in_data ) );  
  571. }
  573. void MvDataCodec::CodeMv2(const MvData& in_data)
  574. {
  575.     const MvArray& mv_array = in_data.Vectors(2);
  576.     const MVector pred = Mv2Prediction( mv_array , in_data.Mode() );     
  578.     const int valx = mv_array[b_yp][b_xp].x - pred.x; 
  579.     const int abs_valx = abs(valx); 
  580.     
  581.     for (int bin = 1; bin <= abs_valx; ++bin)
  582.         EncodeSymbol( 0 , ChooseREF2xContext( in_data , bin ) ); 
  584.     EncodeSymbol( 1 , ChooseREF2xContext( in_data , abs_valx + 1 ) ); 
  585.     
  586.     if (valx != 0)
  587.         EncodeSymbol( ( (valx > 0)? 1 : 0) , ChooseREF2xSignContext( in_data ) ); 
  589.     const int valy = mv_array[b_yp][b_xp].y-pred.y; 
  590.     const int abs_valy = std::abs(valy);     
  591.     
  592.     for (int bin = 1; bin<=abs_valy; ++bin )
  593.         EncodeSymbol( 0 , ChooseREF2yContext( in_data , bin ) ); 
  594.     
  595.     EncodeSymbol( 1 , ChooseREF2yContext( in_data , abs_valy + 1 ) ); 
  596.     
  597.     if (valy != 0)
  598.         EncodeSymbol( ( (valy > 0)? 1 : 0) , ChooseREF2ySignContext( in_data ) ); 
  599. }
  601. void MvDataCodec::CodeDC(const MvData& in_data)
  602. {    
  603.     //begin with Y DC value    
  604.     const ValueType valY = in_data.DC( Y_COMP )[b_yp][b_xp]
  605.                            - DCPrediction( in_data.DC(Y_COMP) , in_data.Mode() ); 
  606.     const ValueType abs_valY = std::abs( valY ); 
  608.     for (ValueType bin = 1; bin <= abs_valY; ++bin)
  609.         EncodeSymbol( 0 , ChooseYDCContext( in_data , bin ) ); 
  611.     EncodeSymbol( 1 , ChooseYDCContext (in_data , abs_valY + 1 ) ); 
  612.     
  613.     if (valY != 0)
  614.         EncodeSymbol( ( (valY > 0)? 1 : 0) , ChooseYDCSignContext( in_data ) ); 
  616.     //now do U and V if necessary
  617.     if (m_cformat != Yonly)
  618.     {
  619.         //continue with U and V DC values
  620.         const int valU =  in_data.DC(U_COMP)[b_yp][b_xp]
  621.                           - DCPrediction(in_data.DC( U_COMP ) , in_data.Mode()); 
  622.         const int abs_valU = std::abs( valU ); 
  624.         for (ValueType bin = 1;  bin<=abs_valU ; ++bin)
  625.             EncodeSymbol( 0 , ChooseUDCContext( in_data , bin ) ); 
  626.         
  627.         EncodeSymbol( 1 , ChooseUDCContext( in_data , abs_valU + 1 ) ); 
  628.         
  629.         if (valU != 0)
  630.             EncodeSymbol( ( (valU > 0) ? 1 : 0) , ChooseUDCSignContext( in_data ) ); 
  631.         
  632.         const int valV = in_data.DC( V_COMP )[b_yp][b_xp] 
  633.                          - DCPrediction( in_data.DC( V_COMP ) , in_data.Mode() ); 
  634.         const int abs_valV = std::abs( valV ); 
  636.         for (ValueType bin = 1; bin<=abs_valV ; ++bin)
  637.             EncodeSymbol( 0 , ChooseVDCContext( in_data , bin ) ); 
  639.         EncodeSymbol( 1 , ChooseVDCContext( in_data , abs_valV + 1 ) ); 
  640.         
  641.         if (valV != 0)
  642.             EncodeSymbol( ( (valV > 0)? 1 : 0) , ChooseVDCSignContext( in_data ) ); 
  643.     }
  644. }
  646. //decoding functions//
  647. //////////////////////
  649. void MvDataCodec::DoWorkDecode( MvData& out_data, int num_bits)
  650. {
  651.     int step,max; 
  652.     int pstep,pmax;     
  653.     int split_depth; 
  654.     bool common_ref; 
  655.     int xstart,ystart;     
  657.     for (mb_yp = 0,mb_tlb_y = 0; mb_yp < out_data.MBSplit().LengthY(); ++mb_yp,mb_tlb_y += 4)
  658.     {
  659.         for (mb_xp = 0,mb_tlb_x = 0; mb_xp < out_data.MBSplit().LengthX(); ++mb_xp,mb_tlb_x += 4)
  660.         {
  661.              //start with split mode
  662.             DecodeMBSplit( out_data ); 
  663.             split_depth = out_data.MBSplit()[mb_yp][mb_xp]; 
  664.             step =  4  >>  (split_depth); 
  665.             max  = (1 << split_depth); 
  667.             //next do common_ref
  668.             if(split_depth  !=  0)
  669.             {
  670.                 DecodeMBCom( out_data ); 
  671.                 pstep = step; 
  672.                 pmax = max; 
  673.             }
  674.             else
  675.             {
  676.                 out_data.MBCommonMode()[mb_yp][mb_xp] = true; 
  677.                 pstep = 4; 
  678.                 pmax = 1; 
  679.             }
  680.             
  681.             common_ref = out_data.MBCommonMode()[mb_yp][mb_xp]; 
  683.             // do prediction modes
  684.             for (b_yp = mb_tlb_y;  b_yp < mb_tlb_y + 4;  b_yp += pstep)
  685.             {                
  686.                 for (b_xp = mb_tlb_x; b_xp < mb_tlb_x + 4;  b_xp += pstep)
  687.                 {
  688.                     DecodePredmode(out_data); 
  689.                     
  690.                     // propagate throughout MB                
  691.                     for (int y = b_yp;  y < b_yp + pstep;  y++)
  692.                         for (int x = b_xp;  x < b_xp + pstep;  x++)
  693.                             out_data.Mode()[y][x] = out_data.Mode()[b_yp][b_xp];                                                         
  694.                 }
  695.             }
  697.                //now do all the block mvs in the mb
  698.             for (int j = 0; j < max; ++j)
  699.             {                
  700.                 for (int i = 0; i < max; ++i)
  701.                 {
  702.                     xstart = b_xp = mb_tlb_x + i * step; 
  703.                     ystart = b_yp = mb_tlb_y + j * step;                                             
  704.                     
  705.                     if (out_data.Mode()[b_yp][b_xp] == REF1_ONLY || out_data.Mode()[b_yp][b_xp] == REF1AND2 )
  706.                         DecodeMv1( out_data ); 
  707.                     
  708.                     if (out_data.Mode()[b_yp][b_xp] == REF2_ONLY || out_data.Mode()[b_yp][b_xp] == REF1AND2 )
  709.                         DecodeMv2( out_data ); 
  710.                     
  711.                     if(out_data.Mode()[b_yp][b_xp] == INTRA)
  712.                         DecodeDC( out_data ); 
  713.                     
  714.                       //propagate throughout MB    
  715.                     for (b_yp = ystart; b_yp < ystart+step; b_yp++)
  716.                     {
  717.                         for (b_xp = xstart; b_xp < xstart+step; b_xp++)
  718.                         {                    
  719.                             out_data.Vectors(1)[b_yp][b_xp].x = out_data.Vectors(1)[ystart][xstart].x; 
  720.                             out_data.Vectors(1)[b_yp][b_xp].y = out_data.Vectors(1)[ystart][xstart].y; 
  721.                             out_data.Vectors(2)[b_yp][b_xp].x = out_data.Vectors(2)[ystart][xstart].x; 
  722.                             out_data.Vectors(2)[b_yp][b_xp].y = out_data.Vectors(2)[ystart][xstart].y; 
  723.                             out_data.DC( Y_COMP )[b_yp][b_xp] = out_data.DC( Y_COMP )[ystart][xstart]; 
  724.                             out_data.DC( U_COMP )[b_yp][b_xp] = out_data.DC( U_COMP )[ystart][xstart]; 
  725.                             out_data.DC( V_COMP )[b_yp][b_xp] = out_data.DC( V_COMP )[ystart][xstart]; 
  726.                         }//b_xp
  727.                     }//b_yp
  728.                 }//i                    
  729.             }//j
  731.         }//mb_xp
  732.     }//mb_yp
  734. }
  736. void MvDataCodec::DecodeMBSplit(MvData& out_data)
  737. {
  738.     int val = 0; 
  739.     int bin = 1; 
  740.     bool bit; 
  742.     do
  743.     {
  744.         DecodeSymbol( bit , ChooseMBSContext( out_data , bin ) ); 
  745.         
  746.         if (!bit)
  747.             val++; 
  748.         
  749.         bin++; 
  750.     }
  751.     while (!bit && val != 2);  
  752.     
  753.     out_data.MBSplit()[mb_yp][mb_xp] = ( val + MBSplitPrediction( out_data.MBSplit() ) ) % 3;     
  754. }
  756. void MvDataCodec::DecodeMBCom( MvData& out_data )
  757. {
  758.     bool bit; 
  759.     DecodeSymbol( bit , ChooseMBCContext( out_data ) ); 
  760.     
  761.     if ( bit )
  762.         out_data.MBCommonMode()[mb_yp][mb_xp] = !MBCBModePrediction( out_data.MBCommonMode() ); 
  763.     else
  764.         out_data.MBCommonMode()[mb_yp][mb_xp] = MBCBModePrediction( out_data.MBCommonMode() ); 
  765. }
  767. void MvDataCodec::DecodePredmode( MvData& out_data )
  768. {
  769.     int val = 0; 
  770.     int bin = 1; 
  771.     bool bit; 
  772.     
  773.     do
  774.     {
  775.         DecodeSymbol( bit , ChoosePredContext( out_data , bin ) ); 
  776.         
  777.         if (!bit)
  778.             val++; 
  779.         
  780.         bin++; 
  781.     }
  782.     while (!bit && val != 3);  
  783.     
  784.     out_data.Mode()[b_yp][b_xp] = PredMode( ( val + BlockModePrediction (out_data.Mode() ) ) %4); 
  785. }
  787. void MvDataCodec::DecodeMv1( MvData& out_data )
  788. {
  789.     MVector pred = Mv1Prediction( out_data.Vectors(1) , out_data.Mode() );     
  790.     int val = 0;
  791.     int bin = 1; 
  792.     bool bit; 
  793.     
  794.     do
  795.     {
  796.         DecodeSymbol( bit , ChooseREF1xContext( out_data , bin ) ); 
  797.         
  798.         if ( !bit )
  799.             val++; 
  800.         
  801.         bin++; 
  802.     }
  803.     while ( !bit ); 
  804.     
  805.     if (val != 0)
  806.     {
  807.         DecodeSymbol( bit , ChooseREF1xSignContext( out_data ) ); 
  808.         
  809.         if (!bit)
  810.             val = -val; 
  811.     }
  812.     
  813.     out_data.Vectors(1)[b_yp][b_xp].x = val + pred.x; 
  815.     val = 0; 
  816.     bin = 1; 
  817.     
  818.     do
  819.     {
  820.         DecodeSymbol( bit , ChooseREF1yContext( out_data , bin ) ); 
  821.         
  822.         if ( !bit )
  823.             val++; 
  824.         
  825.         bin++; 
  826.     }
  827.     while ( !bit ); 
  828.     
  829.     if (val != 0)
  830.     {
  831.         DecodeSymbol( bit , ChooseREF1ySignContext( out_data ) ); 
  832.         
  833.         if (!bit)
  834.             val = -val; 
  835.     }
  836.     
  837.     out_data.Vectors(1)[b_yp][b_xp].y = val + pred.y; 
  838. }
  840. void MvDataCodec::DecodeMv2( MvData& out_data )
  841. {
  842.     MVector pred = Mv2Prediction( out_data.Vectors(2) , out_data.Mode() ); 
  843.     int val = 0; 
  844.     int bin = 1; 
  845.     bool bit; 
  846.     
  847.     do
  848.     {
  849.         DecodeSymbol( bit , ChooseREF2xContext( out_data , bin ) ); 
  850.         
  851.         if ( !bit )
  852.             val++; 
  853.         
  854.         bin++; 
  855.     }
  856.     while ( !bit ); 
  857.     
  858.     if (val != 0)
  859.     {
  860.         DecodeSymbol( bit , ChooseREF2xSignContext( out_data ) ); 
  861.         
  862.         if (!bit)
  863.             val = -val; 
  864.     }
  865.     
  866.     out_data.Vectors(2)[b_yp][b_xp].x = val + pred.x; 
  868.     val = 0; 
  869.     bin = 1; 
  870.     
  871.     do
  872.     {
  873.         DecodeSymbol( bit , ChooseREF2yContext( out_data , bin ) ); 
  874.         
  875.         if ( !bit )
  876.             val++; 
  877.         
  878.         bin++; 
  879.     }
  880.     while ( !bit ); 
  881.     
  882.     if (val != 0)
  883.     {
  884.         DecodeSymbol( bit , ChooseREF2ySignContext( out_data ) ); 
  885.         
  886.         if ( !bit )
  887.             val = -val; 
  888.     }
  889.     
  890.     out_data.Vectors(2)[b_yp][b_xp].y = val + pred.y; 
  891. }
  893. void MvDataCodec::DecodeDC( MvData& out_data )
  894. {
  895.     //begin with Y DC value    
  896.     ValueType val = 0; 
  897.     int bin = 1; 
  898.     bool bit; 
  899.     
  900.     do
  901.     {
  902.         DecodeSymbol( bit , ChooseYDCContext( out_data , bin ) ); 
  903.         
  904.         if ( !bit )
  905.             val++; 
  906.         
  907.         bin++; 
  908.     }
  909.     while ( !bit ); 
  910.     
  911.     if (val != 0)
  912.     {
  913.         DecodeSymbol( bit , ChooseYDCSignContext( out_data ) ); 
  914.         
  915.         if (!bit)
  916.             val = -val; 
  917.     }
  918.     
  919.     out_data.DC( Y_COMP )[b_yp][b_xp] = val + DCPrediction( out_data.DC( Y_COMP ) , out_data.Mode()); 
  921.     if (m_cformat != Yonly)
  922.     {
  923.         //move onto U and V DC values
  924.         val = 0; 
  925.         bin = 1; 
  926.         
  927.         do
  928.         {
  929.             DecodeSymbol( bit , ChooseUDCContext( out_data , bin ) ); 
  930.             
  931.             if (!bit)
  932.                 val++; 
  933.             
  934.             bin++; 
  935.         }
  936.         while (!bit); 
  937.         
  938.         if (val != 0)
  939.         {
  940.             DecodeSymbol( bit , ChooseUDCSignContext ( out_data ) ); 
  941.             
  942.             if (!bit)
  943.                 val = -val; 
  944.         }
  945.         
  946.         out_data.DC( U_COMP )[b_yp][b_xp] = val + DCPrediction( out_data.DC( U_COMP ) , out_data.Mode()); 
  948.         val = 0; 
  949.         bin = 1; 
  950.         
  951.         do
  952.         {
  953.             DecodeSymbol( bit , ChooseVDCContext( out_data , bin ) ); 
  954.             
  955.             if ( !bit )
  956.                 val++; 
  957.             
  958.             bin++; 
  959.         }
  960.         while ( !bit ); 
  961.         
  962.         if (val != 0)
  963.         {
  964.             DecodeSymbol( bit , ChooseVDCSignContext( out_data ) ); 
  965.             
  966.             if ( !bit )
  967.                 val = -val; 
  968.         }
  969.         
  970.         out_data.DC( V_COMP )[b_yp][b_xp] = val + DCPrediction( out_data.DC( V_COMP ) , out_data.Mode() ); 
  971.     }
  972. }