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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
huffman.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：43k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

huffman.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  9. (date: March, 1996)
  11. and edited by
  12. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  13. Takeshi Nagai (TOSHIBA CORPORATION)
  14. Toshiaki Watanabe (TOSHIBA CORPORATION)
  15. Noboru Yamaguchi (TOSHIBA CORPORATION)
  17. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  18. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  19. as specified by the MPEG-4 Video. 
  20. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  21. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  22. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  23. The original developer of this software module and his/her company, 
  24. the subsequent editors and their companies, 
  25. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  26. Copyright is not released for non MPEG-4 Video conforming products. 
  27. Microsoft retains full right to use the code for his/her own purpose, 
  28. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  29. This copyright notice must be included in all copies or derivative works. 
  31. Copyright (c) 1996, 1997.
  33. Module Name:
  35. huffman.cpp
  37. Abstract:
  39. Classes for Huffman encode/decode.
  41. Revision History:
  43. *************************************************************************/
  45. #include <stdlib.h>
  46. #include <string.h>
  47. #include <iostream.h>
  48. #include "typeapi.h"
  49. #include "entropy.hpp"
  50. #include "huffman.hpp"
  51. #include "iostream.h"
  52. #include "fstream.h"
  53. #include "math.h"
  54. #include "bitstrm.hpp"
  56. #include "vlc.hpp"
  58. #ifdef __MFC_
  59. #ifdef _DEBUG
  60. #undef THIS_FILE
  61. static char BASED_CODE THIS_FILE[] = __FILE__;
  62. #endif
  64. #define new DEBUG_NEW    
  65. #endif // __MFC_
  67. #ifdef __PC_COMPILER_
  68. #define FULLNAME(dir, filename) strcpy (pch, "\"#dir"\"#filename);
  69. #else 
  70. #define FULLNAME(dir, filename) strcpy (pch, "/"#dir"/"#filename);
  71. #endif
  73. class CNode
  74. {
  75. friend class CHuffmanTree;
  76. friend Int huffmanNodeCompare (const Void* Element1,const Void* Element2);
  77. private:
  78.     Char m_cCode;
  79.     Int m_lNodeIndex;
  80.     Int m_lFrequency;
  81.     Int m_lBalancer;
  82.     CNode () {m_cCode = 0; m_lNodeIndex = -1; m_lFrequency = 0; m_lBalancer = 1;};
  83. };
  85. Class CHuffmanDecoderNode
  86. {
  87. friend class CHuffmanDecoder;
  88.     Char m_c0End;
  89.     Char m_c1End;
  90.     Int m_l0NextNodeOrSymbol;
  91.     Int m_l1NextNodeOrSymbol;
  92.     CHuffmanDecoderNode () {m_c0End=0;m_c1End=0;
  93.             m_l0NextNodeOrSymbol=-1;m_l1NextNodeOrSymbol=-1;};
  94.     Bool is0Valid() {if ((m_c0End==0)&&(m_l0NextNodeOrSymbol==-1))
  95.             return FALSE;return TRUE;};
  96.     Bool is1Valid() {if ((m_c1End==0)&&(m_l1NextNodeOrSymbol==-1))
  97.             return FALSE;return TRUE;};
  98. };
  100. CHuffmanTree::CHuffmanTree (Int lNOfSymbols, Int *lpFrequencies)
  101. {
  102.     assert(lNOfSymbols>1);
  103.     m_lNOfSymbols=lNOfSymbols;
  104.     m_pNodes = new CNode[2*m_lNOfSymbols-1];
  105.     if(lpFrequencies)
  106.         setFrequencies (lpFrequencies);
  107. }
  109. CHuffmanTree::~CHuffmanTree()
  110. {
  111.     delete[]m_pNodes;
  112. }
  114. Void CHuffmanTree::writeSymbol (Int symbolNo,ostream &stream)
  115. {
  116.     stream<<symbolNo<<" ";
  117. }
  119. Void CHuffmanTree::setFrequencies (Int* lpFrequencies)
  120. {
  121.     for (Int lIndex=0;lIndex<m_lNOfSymbols;lIndex++)
  122.         setFrequency(lpFrequencies[lIndex],lIndex);
  123. }
  125. Void CHuffmanTree::setFrequency (Int lFrequency, Int lIndex)
  126. {
  127.     m_pNodes[lIndex].m_lFrequency=lFrequency;
  128. }
  130. Int huffmanNodeCompare (const Void* Element1, const Void* Element2)
  131. {
  132.     if((*((CNode**)Element1))->m_lFrequency<
  133.             (*((CNode**)Element2))->m_lFrequency)return  1;   
  134.     if((*((CNode**)Element1))->m_lFrequency>
  135.             (*((CNode**)Element2))->m_lFrequency)return -1;
  136.     if((*((CNode**)Element1))->m_lBalancer<
  137.             (*((CNode**)Element2))->m_lBalancer)return  1;   
  138.     if((*((CNode**)Element1))->m_lBalancer>
  139.             (*((CNode**)Element2))->m_lBalancer)return -1;
  140.     return 0;
  141. }
  143. Void CHuffmanTree::buildTree ()
  144. {
  145.     assert(m_lNOfSymbols>1);
  146.     Int NOfNodesForSorting=m_lNOfSymbols;
  147.     Int NextFreeNode=m_lNOfSymbols;
  148.     CNode **pSortingArray;
  149.     pSortingArray=new CNode*[m_lNOfSymbols];
  150.     for (Int i=0;i<m_lNOfSymbols;i++)
  151.         pSortingArray [i] = &m_pNodes[i];
  152.     
  153.     while (NOfNodesForSorting>1)
  154.     {
  155.         qsort(&pSortingArray[0],NOfNodesForSorting,
  156.                 sizeof(pSortingArray[0]),huffmanNodeCompare);
  157.         pSortingArray[NOfNodesForSorting-2]->m_lNodeIndex=NextFreeNode;
  158.         pSortingArray[NOfNodesForSorting-1]->m_lNodeIndex=NextFreeNode;
  159.         pSortingArray[NOfNodesForSorting-2]->m_cCode=0;
  160.         pSortingArray[NOfNodesForSorting-1]->m_cCode=1;
  161.         m_pNodes[NextFreeNode].m_lFrequency=
  162.                 pSortingArray[NOfNodesForSorting-2]->m_lFrequency+
  163.                 pSortingArray[NOfNodesForSorting-1]->m_lFrequency;
  164.         m_pNodes[NextFreeNode].m_lBalancer=
  165.                 pSortingArray[NOfNodesForSorting-2]->m_lBalancer+
  166.                 pSortingArray[NOfNodesForSorting-1]->m_lBalancer;
  167.         pSortingArray[NOfNodesForSorting-2]=&m_pNodes[NextFreeNode];
  168.         NOfNodesForSorting--;
  169.         NextFreeNode++;
  170.     };
  171.     delete pSortingArray;
  172. }
  174. void CHuffmanTree::writeOneTableEntry(ostream &stream, Int entryNo,
  175.                                     Double lTotalFrequency, Double &dNOfBits)
  176. {
  177.     Double dP=m_pNodes[entryNo].m_lFrequency/(Double)lTotalFrequency;
  178.     Char *pCodeArray=new Char[m_lNOfSymbols-1];
  179.     Int lNode=entryNo;
  180.     Int lCodeNo=0;
  181.     while(lNode!=2*m_lNOfSymbols-2)
  182.     {
  183.         pCodeArray[lCodeNo++]=m_pNodes[lNode].m_cCode;
  184.         lNode=m_pNodes[lNode].m_lNodeIndex;
  185.     };
  186.     writeSymbol(entryNo,stream);
  187.     dNOfBits+=dP*lCodeNo;
  188.     while(lCodeNo>0)
  189.     {
  190.         lCodeNo--;
  191.         stream<<(Int)pCodeArray[lCodeNo];
  192.     };
  193.     stream<<endl;
  194.     delete pCodeArray;
  195. }
  197. Void CHuffmanTree::writeTable (ostream &stream)
  198. {
  199.     Int lTotalFrequency=0;
  200.     Double dEntropy=0;
  201.     Double dNOfBits=0;
  202.     statistics (lTotalFrequency, dEntropy);
  203.     for (Int i = 0; i < m_lNOfSymbols; i++)
  204.         writeOneTableEntry (stream, i, lTotalFrequency, dNOfBits);
  205.     printStatistics (dEntropy, dNOfBits, stream);
  206. }
  208. Void CHuffmanTree::writeTableSorted(ostream &stream)
  209. {
  210.     Int lTotalFrequency=0;
  211.     Double dEntropy=0;
  212.     Double dNOfBits=0;
  213.     statistics(lTotalFrequency,dEntropy);
  214.     CNode **pSortingArray;
  215.     pSortingArray = new CNode*[m_lNOfSymbols];
  216. Int i;
  217.     for (i = 0; i < m_lNOfSymbols; i++)
  218.         pSortingArray [i] = &m_pNodes[i];
  219.     qsort(&pSortingArray[0],m_lNOfSymbols,
  220.             sizeof (pSortingArray [0]), huffmanNodeCompare);
  221.     for(i=0;i<m_lNOfSymbols;i++)
  222.         writeOneTableEntry (stream, pSortingArray [i] - m_pNodes,
  223.                 lTotalFrequency,dNOfBits);
  224.     delete pSortingArray;
  225.     printStatistics (dEntropy, dNOfBits, stream);
  226. }
  228. Void CHuffmanTree::statistics (Int& lTotalFrequency,Double &dEntropy)
  229. {
  230. Int i;
  231.     for (i=0;i<m_lNOfSymbols;i++)
  232.         lTotalFrequency+=m_pNodes[i].m_lFrequency;
  233.     for(i=0;i<m_lNOfSymbols;i++)
  234.     {
  235.         double dP=m_pNodes[i].m_lFrequency/(double)lTotalFrequency;
  236.         if(dP!=0)
  237.             dEntropy+=dP*log(1.0/dP)/log(2.0);    
  238.     };
  239. }
  241. Void CHuffmanTree::printStatistics (Double dEntropy, Double dNOfBits, ostream &stream)
  242. {
  243.     stream<<endl<<endl;
  244.     stream<<"//Entropy Per Symbol : "<<dEntropy<<endl;
  245.     stream<<"//Bits Per Symbol    : "<<dNOfBits<<endl;
  246.     stream<<"//Table Efficiency   : "<<dEntropy/dNOfBits<<endl;
  247. }
  249. Int CHuffmanCoDec::makeIndexFromSymbolInTable(istream &huffmanTable)  
  250. {
  251.     Int lR;
  252. huffmanTable >> lR;
  253. return lR;
  254. }
  256. Void CHuffmanCoDec::trashRestOfLine (istream &str)
  257. {
  258.     Int iC;
  259.     do
  260.     {
  261.         iC = str.get ();
  262.     }
  263.     while ((iC!='n') && (iC!=EOF));
  264. }
  266. Bool CHuffmanCoDec::processOneLine (istream &huffmanTable, Int &lSymbol,
  267.                     Int &lCodeSize, Char *pCode)
  268. {
  269. huffmanTable >> ws;
  270.     while(huffmanTable.peek()=='/')
  271.     {
  272. trashRestOfLine (huffmanTable);
  273. huffmanTable >> ws;
  274.     }
  275.     if(huffmanTable.peek()==EOF)
  276.         return FALSE;
  278. lSymbol=makeIndexFromSymbolInTable(huffmanTable);      
  279. huffmanTable >> ws;
  280. int iC=huffmanTable.get();                            
  281. lCodeSize=0;                                       
  282. while((iC=='0')||(iC=='1'))                             
  283.     {                                                       
  284.         if(pCode)                                           
  285.         {                                                   
  286.             if(iC=='0')                                     
  287.                 pCode[lCodeSize]=0;                         
  288.             else                                            
  289.                 pCode[lCodeSize]=1;                         
  290.         };                                                  
  291.         lCodeSize++;                                        
  292.         iC=huffmanTable.get();                            
  293.     };
  294.     if((iC!='n')&&(iC!=EOF))
  295.         trashRestOfLine(huffmanTable);                         
  296.     assert(lCodeSize);
  297.     return TRUE;
  298. }
  300. Void CHuffmanCoDec::profileTable (istream &huffmanTable,
  301.             Int &lNOfSymbols, Int &lMaxCodeSize)
  302. {
  303.     huffmanTable.clear();
  304.     huffmanTable.seekg(0,ios::beg);
  305.     lNOfSymbols=0;
  306.     lMaxCodeSize=0;
  307.     while(huffmanTable.peek()!=EOF)
  308.     {
  309.         Int lCodeSize;
  310.         Int lSymbol;
  311.         if (processOneLine(huffmanTable,lSymbol,lCodeSize,NULL))
  312.         {
  313.             lNOfSymbols++;
  314.             if(lCodeSize>lMaxCodeSize)
  315.                 lMaxCodeSize=lCodeSize;
  316.             assert(lCodeSize);
  317.         };
  318.     };
  319.     assert(lNOfSymbols>1);
  320.     assert(lMaxCodeSize);
  321. }
  323. CHuffmanDecoder::CHuffmanDecoder (CInBitStream &bitStream)
  324. {
  325.     attachStream (bitStream);
  326. }
  328. CHuffmanDecoder::CHuffmanDecoder (CInBitStream &bitStream, VlcTable *pVlc)
  329. {
  330.     attachStream (bitStream);
  331. loadTable (pVlc);
  333. }
  335. CHuffmanDecoder::~CHuffmanDecoder()
  336. {
  337.     delete []m_pTree;
  338. }
  340. Void CHuffmanDecoder::realloc(Int lOldSize,Int lNewSize)
  341. {
  342.     CHuffmanDecoderNode *pNewTree=new CHuffmanDecoderNode[lNewSize];
  343.     Int i;
  344.     for(i=0;i<lOldSize;i++)
  345.     {
  346.         pNewTree[i].m_c0End=m_pTree[i].m_c0End;
  347.         pNewTree[i].m_c1End=m_pTree[i].m_c1End;
  348.         pNewTree[i].m_l0NextNodeOrSymbol=m_pTree[i].m_l0NextNodeOrSymbol;
  349.         pNewTree[i].m_l1NextNodeOrSymbol=m_pTree[i].m_l1NextNodeOrSymbol;
  350.     };
  351.     delete []m_pTree;
  352.     m_pTree=pNewTree;
  353. }
  355. void CHuffmanDecoder::loadTable(istream &huffmanTable,Bool bIncompleteTree)
  356. {
  357.     Int lTableSize;
  358.     Int lNOfSymbols;
  359.     Int lMaxCodeSize;
  360.     Int lNextFreeNode=1;
  361.     profileTable (huffmanTable,lNOfSymbols,lMaxCodeSize);
  362.     assert(lNOfSymbols>1);
  363.     assert(lMaxCodeSize);
  364.     m_pTree = new CHuffmanDecoderNode [lNOfSymbols - 1];
  365.     lTableSize=lNOfSymbols-1;
  366.     Char *pCode = new Char[lMaxCodeSize];
  367.     huffmanTable.clear();
  368.     huffmanTable.seekg(0,ios::beg);
  369.     while(huffmanTable.peek()!=EOF)
  370.     {
  371.         Int lCodeSize;
  372.         Int lSymbol;
  373.         Int lCurrentNode=0;
  374.         if (processOneLine (huffmanTable,lSymbol,lCodeSize,pCode))
  375.         {
  376.             assert((lSymbol<lNOfSymbols)||bIncompleteTree);                                              
  377.             assert(lCodeSize);                                                        
  378.             for(Int i=0;i<lCodeSize;i++)                                             
  379.             {                                                                         
  380. assert ((lCurrentNode<lNOfSymbols-1)||bIncompleteTree);                                 
  381.                 int iBit=pCode[i];                                                    
  382.                 assert((iBit==0)||(iBit==1));                                         
  383.                 if(i==(lCodeSize-1))                                                  
  384.                 {                                                                     
  385.                     if(iBit==0)                                                       
  386.                     {                                                                 
  387.                         assert(!m_pTree[lCurrentNode].is0Valid());                    
  388.                         m_pTree[lCurrentNode].m_c0End=1;                              
  389.                         m_pTree[lCurrentNode].m_l0NextNodeOrSymbol=lSymbol;           
  390.                     }                                                                 
  391.                     else                                                              
  392.                     {                                                                 
  393.                         assert(!m_pTree[lCurrentNode].is1Valid());                    
  394.                         m_pTree[lCurrentNode].m_c1End=1;                              
  395.                         m_pTree[lCurrentNode].m_l1NextNodeOrSymbol=lSymbol;           
  396.                     }                                                                 
  397.                 }                                                                     
  398.                 else                                                                  
  399.                 {                                                                     
  400.                     if(iBit==0)                                                       
  401.                     {                                                                 
  402.                         if(!m_pTree[lCurrentNode].is0Valid())                         
  403.                         {                                                             
  404. if(bIncompleteTree)
  405.                                 if(lNextFreeNode>=lTableSize)
  406.                                 {
  407.                                     realloc(lTableSize,lTableSize+10);
  408.                                     lTableSize+=10;
  409.                                 };
  410.                             assert((lNextFreeNode<lNOfSymbols-1)||bIncompleteTree);                    
  411.                             m_pTree[lCurrentNode].m_c0End=0;                          
  412.                             m_pTree[lCurrentNode].m_l0NextNodeOrSymbol=lNextFreeNode; 
  413.                             lNextFreeNode++;                                          
  414.                         };                                                            
  415.                         assert(m_pTree[lCurrentNode].m_c0End==0);                     
  416.                         lCurrentNode=m_pTree[lCurrentNode].m_l0NextNodeOrSymbol;      
  417.                     }                                                                 
  418.                     else                                                              
  419.                     {                                                                 
  420.                         if(!m_pTree[lCurrentNode].is1Valid())                         
  421.                         {                                                             
  422. if(bIncompleteTree)
  423.                                 if(lNextFreeNode>=lTableSize)
  424.                                 {
  425.                                     realloc(lTableSize,lTableSize+10);
  426.                                     lTableSize+=10;
  427.                                 };
  428.                             assert((lNextFreeNode<lNOfSymbols-1)||bIncompleteTree);                    
  429.                             m_pTree[lCurrentNode].m_c1End=0;                          
  430.                             m_pTree[lCurrentNode].m_l1NextNodeOrSymbol=lNextFreeNode; 
  431.                             lNextFreeNode++;                                          
  432.                         };                                                            
  433.                         assert(m_pTree[lCurrentNode].m_c1End==0);                     
  434.                         lCurrentNode=m_pTree[lCurrentNode].m_l1NextNodeOrSymbol;      
  435.                     }                                                                
  436.                 }                                                                    
  437.             }
  438.         }
  439.     }
  440.     for(Int i=0;i<lTableSize;i++)
  441.     {
  442.         assert((m_pTree[i].is0Valid())||bIncompleteTree);
  443.         assert((m_pTree[i].is1Valid())||bIncompleteTree);
  444.     };
  445.     delete pCode;
  446. }
  448. void CHuffmanDecoder::loadTable(VlcTable *pVlc,Bool bIncompleteTree)
  449. {
  450.     Int lTableSize;
  451.     Int lNextFreeNode = 1;
  452.     Int lNOfSymbols = 0;
  453.     Int lMaxCodeSize = 0;
  454. VlcTable *pVlcTmp;
  455.     for(pVlcTmp = pVlc; pVlcTmp->pchBits!=NULL; pVlcTmp++)
  456.     {
  457.         lNOfSymbols++;
  458. Int lCodeSize = strlen(pVlcTmp->pchBits);
  460. assert(pVlcTmp->lSymbol>=0 && pVlcTmp->lSymbol<1000);
  461. assert(lCodeSize>0);
  463.         if(lCodeSize>lMaxCodeSize)
  464. lMaxCodeSize=lCodeSize;
  465.     }
  466.     assert(lNOfSymbols>1);
  467.     assert(lMaxCodeSize>0);
  469.     m_pTree = new CHuffmanDecoderNode [lNOfSymbols - 1];
  470.     lTableSize=lNOfSymbols-1;
  472.     for(pVlcTmp = pVlc; pVlcTmp->pchBits!=NULL; pVlcTmp++)
  473.     {
  474.         Int lCodeSize = strlen(pVlcTmp->pchBits);
  475.         Int lSymbol = pVlcTmp->lSymbol;
  476.         Int lCurrentNode = 0;
  477. //printf("%dt%dt%sn",lSymbol, lCodeSize, pVlcTmp->pchBits);
  479.         assert((lSymbol<lNOfSymbols)||bIncompleteTree);                                              
  480.         assert(lCodeSize);                                                        
  481.         for(Int i=0;i<lCodeSize;i++)                                             
  482.         {                                                                         
  483. assert ((lCurrentNode<lNOfSymbols-1)||bIncompleteTree);
  484.             int iBit = pVlcTmp->pchBits[i] - '0';
  485. assert((iBit==0)||(iBit==1));                                         
  486.             if(i==(lCodeSize-1))                                                  
  487.             {                                                                     
  488.                 if(iBit==0)                                                       
  489.                 {                                                                 
  490.                     assert(!m_pTree[lCurrentNode].is0Valid());                    
  491.                     m_pTree[lCurrentNode].m_c0End=1;                              
  492.                     m_pTree[lCurrentNode].m_l0NextNodeOrSymbol=lSymbol;           
  493.                 }                                                                 
  494.                 else                                                              
  495.                 {                                                                 
  496.                     assert(!m_pTree[lCurrentNode].is1Valid());                    
  497.                     m_pTree[lCurrentNode].m_c1End=1;                              
  498.                     m_pTree[lCurrentNode].m_l1NextNodeOrSymbol=lSymbol;           
  499.                 }                                                                 
  500.             }                                                                     
  501.             else                                                                  
  502.             {                                                                     
  503.                 if(iBit==0)                                                       
  504.                 {                                                                 
  505.                     if(!m_pTree[lCurrentNode].is0Valid())                         
  506.                     {                                                             
  507. if(bIncompleteTree)
  508.                             if(lNextFreeNode>=lTableSize)
  509.                             {
  510.                                 realloc(lTableSize,lTableSize+10);
  511.                                 lTableSize+=10;
  512.                             };
  513.                         assert((lNextFreeNode<lNOfSymbols-1)||bIncompleteTree);                    
  514.                         m_pTree[lCurrentNode].m_c0End=0;                          
  515.                         m_pTree[lCurrentNode].m_l0NextNodeOrSymbol=lNextFreeNode; 
  516.                         lNextFreeNode++;                                          
  517.                     };                                                            
  518.                     assert(m_pTree[lCurrentNode].m_c0End==0);                     
  519.                     lCurrentNode=m_pTree[lCurrentNode].m_l0NextNodeOrSymbol;      
  520.                 }                                                                 
  521.                 else                                                              
  522.                 {                                                                 
  523.                     if(!m_pTree[lCurrentNode].is1Valid())                         
  524.                     {                                                             
  525. if(bIncompleteTree)
  526.                             if(lNextFreeNode>=lTableSize)
  527.                             {
  528.                                 realloc(lTableSize,lTableSize+10);
  529.                                 lTableSize+=10;
  530.                             };
  531.                         assert((lNextFreeNode<lNOfSymbols-1)||bIncompleteTree);                    
  532.                         m_pTree[lCurrentNode].m_c1End=0;                          
  533.                         m_pTree[lCurrentNode].m_l1NextNodeOrSymbol=lNextFreeNode; 
  534.                         lNextFreeNode++;                                          
  535.                     };                                                            
  536.                     assert(m_pTree[lCurrentNode].m_c1End==0);                     
  537.                     lCurrentNode=m_pTree[lCurrentNode].m_l1NextNodeOrSymbol;      
  538.                 }                                                                
  539.             }                                                                    
  540.         }
  541.     }
  542.     for(Int i=0;i<lTableSize;i++)
  543.     {
  544.         assert((m_pTree[i].is0Valid())||bIncompleteTree);
  545.         assert((m_pTree[i].is1Valid())||bIncompleteTree);
  546.     }
  547. }
  549. Void CHuffmanDecoder::attachStream(CInBitStream &bitStream)
  550. {
  551.     m_pBitStream=&bitStream;
  552. }
  554. Int CHuffmanDecoder::decodeSymbol()
  555. {
  556.     Char cEnd=0;
  557.     Int lNextNodeOrSymbol=0;
  558.     do
  559.     {
  560.         Int iBit;
  561.         iBit=m_pBitStream->getBits((uint32_t)1);
  562.         if(iBit==0)
  563.         {
  564.             if(m_pTree[lNextNodeOrSymbol].is0Valid())
  565.             {
  566.                 cEnd=m_pTree[lNextNodeOrSymbol].m_c0End;
  567.                 lNextNodeOrSymbol=m_pTree[lNextNodeOrSymbol].m_l0NextNodeOrSymbol;
  568.             }
  569.             else
  570.             {
  571.                 cEnd=TRUE;
  572.                 lNextNodeOrSymbol=-1;
  573.             }
  574.         }
  575.         else
  576.         {
  577.             if(m_pTree[lNextNodeOrSymbol].is1Valid())
  578.             {
  579.                 cEnd=m_pTree[lNextNodeOrSymbol].m_c1End;
  580.                 lNextNodeOrSymbol=m_pTree[lNextNodeOrSymbol].m_l1NextNodeOrSymbol;
  581.             }
  582.             else
  583.             {
  584.                 cEnd=TRUE;
  585.                 lNextNodeOrSymbol=-1;
  586.             }
  587.         };
  588.     }
  589.     while(cEnd==0);
  590.     return lNextNodeOrSymbol;
  591. }
  593. CHuffmanEncoder::~CHuffmanEncoder ()
  594. {
  595. delete m_pCodeTable; 
  596. delete m_pSizeTable;
  597. }
  599. CHuffmanEncoder::CHuffmanEncoder(COutBitStream &bitStream)
  600. {
  601.     attachStream(bitStream);
  602. }
  604. CHuffmanEncoder::CHuffmanEncoder(COutBitStream &bitStream, VlcTable *pVlc)
  605. {
  606. attachStream(bitStream);
  608. loadTable(pVlc);
  609. }
  611. Void CHuffmanEncoder::loadTable(istream &huffmanTable)
  612. {
  613.     Int lNOfSymbols;
  614.     Int lMaxCodeSize;
  615.     profileTable(huffmanTable,lNOfSymbols,lMaxCodeSize);
  616.     assert(lNOfSymbols>1);
  617.     assert(lMaxCodeSize);
  618.     m_lCodeTableEntrySize=lMaxCodeSize/8;
  619.     if(lMaxCodeSize%8)
  620.         m_lCodeTableEntrySize++;
  621.     m_pSizeTable = new Int [lNOfSymbols];
  622.     m_pCodeTable = new Int [lNOfSymbols];
  623.     Char *pCode=new Char[lMaxCodeSize];
  624.     huffmanTable.clear();
  625.     huffmanTable.seekg(0,ios::beg);
  626.     while(huffmanTable.peek()!=EOF)
  627.     {
  628.         Int lCodeSize;
  629.         Int lSymbol;
  630.         Int iBitPosition=0;
  631.         if(processOneLine(huffmanTable,lSymbol,lCodeSize,pCode))
  632.         {
  633.             assert(lSymbol<lNOfSymbols);                                                 
  634.             assert(lCodeSize >=0 && lCodeSize <= (Int) sizeof (Int) * 8);
  635.             m_pSizeTable[lSymbol]=lCodeSize;                                             
  636.             Int* pCodeTableEntry=&m_pCodeTable[lSymbol]; 
  637.             for(Int i=0;i<lCodeSize;i++)                                                
  638.             {                                                                            
  639.                 if(iBitPosition==0)                                                      
  640.                     *pCodeTableEntry=0;                                                  
  641.                 assert((pCode[lCodeSize - i - 1]==0)||(pCode[lCodeSize - i - 1]==1));                                    
  642.                 if(pCode[lCodeSize - i - 1]==0)                                                          
  643.                     *pCodeTableEntry&=~(0x01<<iBitPosition);                             
  644.                 else                                                                     
  645.                     *pCodeTableEntry|=0x01<<iBitPosition;                                
  646.                 iBitPosition++;                                                          
  647. /*
  648.                 if(iBitPosition>=8)                                                      
  649.                 {                                                                        
  650.                     iBitPosition=0;                                                      
  651.                     pCodeTableEntry++;                                                   
  652.                 } 
  653. */
  654.             }                                                                           
  655.         }
  656.     }
  657.     delete pCode;
  658. }
  660. Void CHuffmanEncoder::loadTable(VlcTable *pVlc)
  661. {
  662.     Int lNOfSymbols = 0;
  663.     Int lMaxCodeSize = 0;
  665. VlcTable *pVlcTmp;
  667. for(pVlcTmp = pVlc; pVlcTmp->pchBits!=NULL; pVlcTmp++)
  668. {
  669.         lNOfSymbols++;
  670. Int lCodeSize = strlen(pVlcTmp->pchBits);
  672. assert(pVlcTmp->lSymbol>=0 && pVlcTmp->lSymbol<1000);
  673. assert(lCodeSize>0);
  675.         if(lCodeSize>lMaxCodeSize)
  676. lMaxCodeSize=lCodeSize;
  677.     }
  678.     assert(lNOfSymbols>1);
  679.     assert(lMaxCodeSize>0);
  681.     m_lCodeTableEntrySize=lMaxCodeSize/8;
  682.     if(lMaxCodeSize%8)
  683.         m_lCodeTableEntrySize++;
  684.     m_pSizeTable = new Int [lNOfSymbols];
  685.     m_pCodeTable = new Int [lNOfSymbols];
  687. for(pVlcTmp = pVlc; pVlcTmp->pchBits!=NULL; pVlcTmp++)
  688.     {
  689.         Int lCodeSize = strlen(pVlcTmp->pchBits);
  690.         Int lSymbol = pVlcTmp->lSymbol;
  691.         Int iBitPosition=0;
  693.         assert(lSymbol<lNOfSymbols);                                                 
  694.         assert(lCodeSize >=0 && lCodeSize <= (Int) sizeof (Int) * 8);
  695.         m_pSizeTable[lSymbol]=lCodeSize;                                             
  696.         Int* pCodeTableEntry=&m_pCodeTable[lSymbol]; 
  697.         for(Int i=0;i<lCodeSize;i++)                                                
  698.         {                                                                            
  699.         if(iBitPosition==0)                                                      
  700.         *pCodeTableEntry=0;                                                  
  701. Int iBitC = pVlcTmp->pchBits[lCodeSize - i - 1];
  702.             assert(iBitC=='0' || iBitC=='1');
  703.             if(iBitC=='0')                                                          
  704. *pCodeTableEntry&=~(0x01<<iBitPosition);                             
  705.             else                                                                     
  706.                 *pCodeTableEntry|=0x01<<iBitPosition;                                
  707.             iBitPosition++;                                                          
  708. /*
  709.                 if(iBitPosition>=8)                                                      
  710.                 {                                                                        
  711.                     iBitPosition=0;                                                      
  712.                     pCodeTableEntry++;                                                   
  713.                 } 
  714. */                                                                         
  715.         }
  716.     }
  717. }
  719. void CHuffmanEncoder::attachStream(COutBitStream &bitStream)
  720. {
  721.     m_pBitStream=&bitStream;
  722. }
  724. UInt CHuffmanEncoder::encodeSymbol (Int lSymbol, Char* rgchSymbolName, Bool bDontSendBits)
  725. {
  726.     Int lSize=m_pSizeTable[lSymbol];
  727. if (bDontSendBits == TRUE) //for counting bits
  728. return (lSize);
  729. // Added for Data Partitioning by Toshiba (98-1-16)
  730. if(m_pBitStream -> GetDontSendBits()) 
  731. return (lSize);
  732. // End Toshiba(1998-1-16)
  734.     Int iCode=m_pCodeTable[lSymbol];
  735. Int lPrevCounter = m_pBitStream -> getCounter ();
  736.     m_pBitStream -> putBits (iCode,lSize, rgchSymbolName);
  737. return (m_pBitStream -> getCounter () - lPrevCounter);
  738. }
  741. CEntropyEncoderSet::CEntropyEncoderSet (COutBitStream &bitStream)
  742. {
  743. m_pentrencDCT = new CHuffmanEncoder (bitStream, g_rgVlcDCT);
  744. m_pentrencDCTIntra = new CHuffmanEncoder (bitStream, g_rgVlcDCTIntra);
  745.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  746.   m_pentrencDCTRVLC = new CHuffmanEncoder (bitStream, g_rgVlcDCTRVLC);
  747.   m_pentrencDCTIntraRVLC = new CHuffmanEncoder (bitStream, g_rgVlcDCTIntraRVLC);
  748.   // End Toshiba(1998-1-16:DP+RVLC)
  749. m_pentrencMV = new CHuffmanEncoder (bitStream, g_rgVlcMV);
  750. m_pentrencMCBPCintra = new CHuffmanEncoder (bitStream, g_rgVlcMCBPCintra);
  751. m_pentrencMCBPCinter = new CHuffmanEncoder (bitStream, g_rgVlcMCBPCinter);
  752. m_pentrencCBPY = new CHuffmanEncoder (bitStream, g_rgVlcCBPY);
  753. m_pentrencCBPY1 = new CHuffmanEncoder (bitStream, g_rgVlcCBPY1);
  754. m_pentrencCBPY2 = new CHuffmanEncoder (bitStream, g_rgVlcCBPY2);
  755. m_pentrencCBPY3 = new CHuffmanEncoder (bitStream, g_rgVlcCBPY3);
  756. m_pentrencIntraDCy = new CHuffmanEncoder (bitStream, g_rgVlcIntraDCy);
  757. m_pentrencIntraDCc = new CHuffmanEncoder (bitStream, g_rgVlcIntraDCc);
  758. m_pentrencMbTypeBVOP = new CHuffmanEncoder (bitStream, g_rgVlcMbTypeBVOP);
  759.   m_pentrencWrpPnt = new CHuffmanEncoder (bitStream, g_rgVlcWrpPnt);
  760. m_ppentrencShapeMode [0] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode0);
  761. m_ppentrencShapeMode [1] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode1);
  762. m_ppentrencShapeMode [2] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode2);
  763. m_ppentrencShapeMode [3] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode3);
  764. m_ppentrencShapeMode [4] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode4);
  765. m_ppentrencShapeMode [5] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode5);
  766. m_ppentrencShapeMode [6] = new CHuffmanEncoder (bitStream, g_rgVlcShapeMode6);
  767. m_pentrencShapeMV1 = new CHuffmanEncoder (bitStream, g_rgVlcShapeMV1);
  768. m_pentrencShapeMV2 = new CHuffmanEncoder (bitStream, g_rgVlcShapeMV2);
  770. /*ifstream istrmTableDCT;
  771. ifstream istrmTableDCTintra;
  772. ifstream istrmTableMV;
  773. ifstream istrmTableMCBPCintra;
  774. ifstream istrmTableMCBPCinter;
  775. ifstream istrmTableCBPY;
  776. ifstream istrmTableCBPY2;
  777. ifstream istrmTableCBPY3;
  778. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  779. ifstream istrmTableCBPY1DP;
  780. ifstream istrmTableCBPY2DP;
  781. ifstream istrmTableCBPY3DP;
  782. // End Toshiba(1998-1-16:DP+RVLC)
  783. ifstream istrmTableIntraDCy;
  784. ifstream istrmTableIntraDCc;
  785. ifstream istrmMbTypeBVOP;
  786. ifstream istrmWrpPnt;
  787. ifstream istrmShapeMode [7];
  788. ifstream istrmShapeMv1;
  789. ifstream istrmShapeMv2;
  790.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  791.   ifstream istrmTableDCTRVLC;
  792.   ifstream istrmTableDCTIntraRVLC;
  793.   // End Toshiba(1998-1-16:DP+RVLC)
  795. // get the vm_home value
  796. Char *rgchVmHome = getenv ( "VM_HOME" );
  797. assert (rgchVmHome != NULL );
  798. Char rgchFile [100];
  799. strcpy (rgchFile, rgchVmHome);
  800. Int iLength = strlen (rgchFile);
  801. Char* pch = rgchFile + iLength;
  803. FULLNAME (sys, vlcdct.txt);
  804. istrmTableDCT.open (rgchFile);
  805. FULLNAME (sys, dctin.txt);
  806. istrmTableDCTintra.open (rgchFile);
  807. FULLNAME (sys, vlcmvd.txt);
  808. istrmTableMV.open (rgchFile);
  809. FULLNAME (sys, mcbpc1.txt);
  810. istrmTableMCBPCintra.open (rgchFile);
  811. FULLNAME (sys, mcbpc2.txt);
  812. istrmTableMCBPCinter.open (rgchFile);
  813. FULLNAME (sys, cbpy.txt);
  814. istrmTableCBPY.open (rgchFile);
  815. FULLNAME (sys, cbpy2.txt);
  816. istrmTableCBPY2.open (rgchFile);
  817. FULLNAME (sys, cbpy3.txt);
  818. istrmTableCBPY3.open (rgchFile);
  819. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  820. FULLNAME (sys, cbpy1dp.txt);
  821. istrmTableCBPY1DP.open (rgchFile);
  822. FULLNAME (sys, cbpy2dp.txt);
  823. istrmTableCBPY2DP.open (rgchFile);
  824. FULLNAME (sys, cbpy3dp.txt);
  825. istrmTableCBPY3DP.open (rgchFile);
  826. // End Toshiba(1998-1-16:DP+RVLC)
  827. FULLNAME (sys, dcszy.txt);
  828. istrmTableIntraDCy.open (rgchFile);
  829. FULLNAME (sys, dcszc.txt);
  830. istrmTableIntraDCc.open (rgchFile);
  831. FULLNAME (sys, mbtyp.txt);
  832. istrmMbTypeBVOP.open (rgchFile);
  833. FULLNAME (sys, wrppnt.txt);
  834. istrmWrpPnt.open (rgchFile);
  835. FULLNAME (sys, shpmd0.txt);
  836. istrmShapeMode[0].open (rgchFile);
  837. FULLNAME (sys, shpmd1.txt);
  838. istrmShapeMode[1].open (rgchFile);
  839. FULLNAME (sys, shpmd2.txt);
  840. istrmShapeMode[2].open (rgchFile);
  841. FULLNAME (sys, shpmd3.txt);
  842. istrmShapeMode[3].open (rgchFile);
  843. FULLNAME (sys, shpmd4.txt);
  844. istrmShapeMode[4].open (rgchFile);
  845. FULLNAME (sys, shpmd5.txt);
  846. istrmShapeMode[5].open (rgchFile);
  847. FULLNAME (sys, shpmd6.txt);
  848. istrmShapeMode[6].open (rgchFile);
  849. FULLNAME (sys, shpmv1.txt);
  850. istrmShapeMv1.open (rgchFile);
  851. FULLNAME (sys, shpmv2.txt);
  852. istrmShapeMv2.open (rgchFile);
  853.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  854.   FULLNAME (sys, rvlcdct.txt);
  855.   istrmTableDCTRVLC.open (rgchFile);
  856.   FULLNAME (sys, rvlcin.txt);
  857.   istrmTableDCTIntraRVLC.open (rgchFile);
  858.   // End Toshiba(1998-1-16:DP+RVLC)
  860. m_pentrencDCT -> loadTable (istrmTableDCT);
  861. m_pentrencDCTIntra -> loadTable (istrmTableDCTintra);
  862.     m_pentrencMV -> loadTable (istrmTableMV);
  863.     m_pentrencMCBPCintra -> loadTable (istrmTableMCBPCintra);
  864.     m_pentrencMCBPCinter -> loadTable (istrmTableMCBPCinter);
  865.     m_pentrencCBPY -> loadTable (istrmTableCBPY);
  866.     m_pentrencCBPY2 -> loadTable (istrmTableCBPY2);
  867.     m_pentrencCBPY3 -> loadTable (istrmTableCBPY3);
  868. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  869.     m_pentrencCBPY1DP -> loadTable (istrmTableCBPY1DP);
  870.     m_pentrencCBPY2DP -> loadTable (istrmTableCBPY2DP);
  871.     m_pentrencCBPY3DP -> loadTable (istrmTableCBPY3DP);
  872. // End Toshiba(1998-1-16:DP+RVLC)
  873.     m_pentrencIntraDCy -> loadTable (istrmTableIntraDCy);
  874.     m_pentrencIntraDCc -> loadTable (istrmTableIntraDCc);
  875.     m_pentrencMbTypeBVOP->loadTable (istrmMbTypeBVOP);
  876.     m_pentrencWrpPnt->loadTable (istrmWrpPnt);
  877. for (iShapeMd = 0; iShapeMd < 7; iShapeMd++)
  878. m_ppentrencShapeMode [iShapeMd]->loadTable (istrmShapeMode [iShapeMd]);
  879. m_pentrencShapeMV1->loadTable (istrmShapeMv1);
  880. m_pentrencShapeMV2->loadTable (istrmShapeMv2);
  881.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  882.   m_pentrencDCTRVLC -> loadTable (istrmTableDCTRVLC);
  883.   m_pentrencDCTIntraRVLC -> loadTable (istrmTableDCTIntraRVLC);
  884.   // End Toshiba(1998-1-16:DP+RVLC)
  885. */
  886. }
  888. CEntropyEncoderSet::~CEntropyEncoderSet()
  889. {
  890. delete m_pentrencDCT;
  891. delete m_pentrencDCTIntra;
  892. delete m_pentrencMV;
  893. delete m_pentrencMCBPCintra;
  894. delete m_pentrencMCBPCinter;
  895. delete m_pentrencCBPY;
  896. delete m_pentrencCBPY2;
  897. delete m_pentrencCBPY3;
  898. delete m_pentrencIntraDCy;
  899. delete m_pentrencIntraDCc;
  900. delete m_pentrencMbTypeBVOP;
  901. delete m_pentrencWrpPnt;
  902. for (UInt iShapeMd = 0; iShapeMd < 7; iShapeMd++)
  903. delete m_ppentrencShapeMode [iShapeMd];
  904. delete m_pentrencShapeMV1;
  905. delete m_pentrencShapeMV2;
  906.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  907.   delete m_pentrencDCTRVLC;
  908.   delete m_pentrencDCTIntraRVLC;
  909.   // End Toshiba(1998-1-16:DP+RVLC)
  910. }
  912. CEntropyDecoderSet::CEntropyDecoderSet (CInBitStream &bitStream)
  913. {
  914. m_pentrdecDCT = new CHuffmanDecoder (bitStream, g_rgVlcDCT);
  915. m_pentrdecDCTIntra = new CHuffmanDecoder (bitStream, g_rgVlcDCTIntra);
  916.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  917.   m_pentrdecDCTRVLC = new CHuffmanDecoder (bitStream, g_rgVlcDCTRVLC);
  918.   m_pentrdecDCTIntraRVLC = new CHuffmanDecoder (bitStream, g_rgVlcDCTIntraRVLC);
  919.   // End Toshiba(1998-1-16:DP+RVLC)
  920. m_pentrdecMV = new CHuffmanDecoder (bitStream, g_rgVlcMV);
  921. m_pentrdecMCBPCintra = new CHuffmanDecoder (bitStream, g_rgVlcMCBPCintra);
  922. m_pentrdecMCBPCinter = new CHuffmanDecoder (bitStream, g_rgVlcMCBPCinter);
  923. m_pentrdecCBPY = new CHuffmanDecoder (bitStream, g_rgVlcCBPY);
  924. m_pentrdecCBPY1 = new CHuffmanDecoder (bitStream, g_rgVlcCBPY1);
  925. m_pentrdecCBPY2 = new CHuffmanDecoder (bitStream, g_rgVlcCBPY2);
  926. m_pentrdecCBPY3 = new CHuffmanDecoder (bitStream, g_rgVlcCBPY3);
  927. m_pentrdecIntraDCy = new CHuffmanDecoder (bitStream, g_rgVlcIntraDCy);
  928. m_pentrdecIntraDCc = new CHuffmanDecoder (bitStream, g_rgVlcIntraDCc);
  929. m_pentrdecMbTypeBVOP = new CHuffmanDecoder (bitStream, g_rgVlcMbTypeBVOP);
  930.   m_pentrdecWrpPnt = new CHuffmanDecoder (bitStream, g_rgVlcWrpPnt);
  931. m_ppentrdecShapeMode [0] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode0);
  932. m_ppentrdecShapeMode [1] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode1);
  933. m_ppentrdecShapeMode [2] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode2);
  934. m_ppentrdecShapeMode [3] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode3);
  935. m_ppentrdecShapeMode [4] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode4);
  936. m_ppentrdecShapeMode [5] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode5);
  937. m_ppentrdecShapeMode [6] = new CHuffmanDecoder (bitStream, g_rgVlcShapeMode6);
  938. m_pentrdecShapeMV1 = new CHuffmanDecoder (bitStream, g_rgVlcShapeMV1);
  939. m_pentrdecShapeMV2 = new CHuffmanDecoder (bitStream, g_rgVlcShapeMV2);
  941. /* ifstream istrmTableDCT;
  942. ifstream istrmTableDCTIntra;
  943. ifstream istrmTableMV;
  944. ifstream istrmTableMCBPCintra;
  945. ifstream istrmTableMCBPCinter;
  946. ifstream istrmTableCBPY;
  947. ifstream istrmTableCBPY2;
  948. ifstream istrmTableCBPY3;
  949. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  950. ifstream istrmTableCBPY1DP;
  951. ifstream istrmTableCBPY2DP;
  952. ifstream istrmTableCBPY3DP;
  953. // End Toshiba(1998-1-16:DP+RVLC)
  954. ifstream istrmTableIntraDCy;
  955. ifstream istrmTableIntraDCc;
  956. ifstream istrmMbTypeBVOP;
  957. ifstream istrmWrpPnt;
  958. ifstream istrmShapeMode [7];
  959. ifstream istrmShapeMv1;
  960. ifstream istrmShapeMv2;
  961.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  962.   ifstream istrmTableDCTRVLC;
  963.   ifstream istrmTableDCTIntraRVLC;
  964.   // End Toshiba(1998-1-16:DP+RVLC)
  966. // get the vm_home value
  967. Char *rgchVmHome = getenv ( "VM_HOME" );
  968. assert (rgchVmHome != NULL );
  969. Char rgchFile [100];
  970. strcpy (rgchFile, rgchVmHome);
  971. Int iLength = strlen (rgchFile);
  972. Char* pch = rgchFile + iLength;
  974. FULLNAME (sys, vlcdct.txt);
  975. istrmTableDCT.open (rgchFile);
  976. FULLNAME (sys, dctin.txt);
  977. istrmTableDCTIntra.open (rgchFile);
  978. FULLNAME (sys, vlcmvd.txt);
  979. istrmTableMV.open (rgchFile);
  980. FULLNAME (sys, mcbpc1.txt);
  981. istrmTableMCBPCintra.open (rgchFile);
  982. FULLNAME (sys, mcbpc2.txt);
  983. istrmTableMCBPCinter.open (rgchFile);
  984. FULLNAME (sys, cbpy.txt);
  985. istrmTableCBPY.open (rgchFile);
  986. FULLNAME (sys, cbpy2.txt);
  987. istrmTableCBPY2.open (rgchFile);
  988. FULLNAME (sys, cbpy3.txt);
  989. istrmTableCBPY3.open (rgchFile);
  990. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  991. FULLNAME (sys, cbpy1dp.txt);
  992. istrmTableCBPY1DP.open (rgchFile);
  993. FULLNAME (sys, cbpy2dp.txt);
  994. istrmTableCBPY2DP.open (rgchFile);
  995. FULLNAME (sys, cbpy3dp.txt);
  996. istrmTableCBPY3DP.open (rgchFile);
  997. // End Toshiba(1998-1-16:DP+RVLC)
  998. FULLNAME (sys, dcszy.txt);
  999. istrmTableIntraDCy.open (rgchFile);
  1000. FULLNAME (sys, dcszc.txt);
  1001. istrmTableIntraDCc.open (rgchFile);
  1002. FULLNAME (sys, mbtyp.txt);
  1003. istrmMbTypeBVOP.open (rgchFile);
  1004. FULLNAME (sys, wrppnt.txt);
  1005. istrmWrpPnt.open (rgchFile);
  1006. FULLNAME (sys, shpmd0.txt);
  1007. istrmShapeMode[0].open (rgchFile);
  1008. FULLNAME (sys, shpmd1.txt);
  1009. istrmShapeMode[1].open (rgchFile);
  1010. FULLNAME (sys, shpmd2.txt);
  1011. istrmShapeMode[2].open (rgchFile);
  1012. FULLNAME (sys, shpmd3.txt);
  1013. istrmShapeMode[3].open (rgchFile);
  1014. FULLNAME (sys, shpmd4.txt);
  1015. istrmShapeMode[4].open (rgchFile);
  1016. FULLNAME (sys, shpmd5.txt);
  1017. istrmShapeMode[5].open (rgchFile);
  1018. FULLNAME (sys, shpmd6.txt);
  1019. istrmShapeMode[6].open (rgchFile);
  1020. FULLNAME (sys, shpmv1.txt);
  1021. istrmShapeMv1.open (rgchFile);
  1022. FULLNAME (sys, shpmv2.txt);
  1023. istrmShapeMv2.open (rgchFile);
  1024.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  1025.   FULLNAME (sys, rvlcdct.txt);
  1026.   istrmTableDCTRVLC.open (rgchFile);
  1027.   FULLNAME (sys, rvlcin.txt);
  1028.   istrmTableDCTIntraRVLC.open (rgchFile);
  1029.   // End Toshiba(1998-1-16:DP+RVLC)
  1031. m_pentrdecDCT -> loadTable (istrmTableDCT);
  1032. m_pentrdecDCTIntra -> loadTable (istrmTableDCTIntra);
  1033.     m_pentrdecMV -> loadTable (istrmTableMV);
  1034.     m_pentrdecMCBPCintra -> loadTable (istrmTableMCBPCintra);
  1035.     m_pentrdecMCBPCinter -> loadTable (istrmTableMCBPCinter);
  1036.     m_pentrdecCBPY -> loadTable (istrmTableCBPY);
  1037.     m_pentrdecCBPY2 -> loadTable (istrmTableCBPY2);
  1038.     m_pentrdecCBPY3 -> loadTable (istrmTableCBPY3);
  1039. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  1040.     m_pentrdecCBPY1DP -> loadTable (istrmTableCBPY1DP);
  1041.     m_pentrdecCBPY2DP -> loadTable (istrmTableCBPY2DP);
  1042.     m_pentrdecCBPY3DP -> loadTable (istrmTableCBPY3DP);
  1043. // End Toshiba(1998-1-16:DP+RVLC)
  1044.     m_pentrdecIntraDCy -> loadTable (istrmTableIntraDCy);
  1045.     m_pentrdecIntraDCc -> loadTable (istrmTableIntraDCc);
  1046.     m_pentrdecMbTypeBVOP -> loadTable (istrmMbTypeBVOP);
  1047. m_pentrdecWrpPnt  -> loadTable (istrmWrpPnt);
  1048. for (iShapeMd = 0; iShapeMd < 7; iShapeMd++)
  1049. m_ppentrdecShapeMode [iShapeMd]->loadTable (istrmShapeMode[iShapeMd]);
  1050. m_pentrdecShapeMV1->loadTable (istrmShapeMv1);
  1051. m_pentrdecShapeMV2->loadTable (istrmShapeMv2);
  1052.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  1053.   m_pentrdecDCTRVLC -> loadTable (istrmTableDCTRVLC);
  1054.   m_pentrdecDCTIntraRVLC -> loadTable (istrmTableDCTIntraRVLC);
  1055.   // End Toshiba(1998-1-16:DP+RVLC)
  1056. */
  1057. }
  1059. CEntropyDecoderSet::~CEntropyDecoderSet()
  1060. {
  1061. delete m_pentrdecDCT;
  1062. delete m_pentrdecDCTIntra;
  1063. delete m_pentrdecMV;
  1064. delete m_pentrdecMCBPCintra;
  1065. delete m_pentrdecMCBPCinter;
  1066. delete m_pentrdecCBPY;
  1067. delete m_pentrdecCBPY1;
  1068. delete m_pentrdecCBPY2;
  1069. delete m_pentrdecCBPY3;
  1070. delete m_pentrdecIntraDCy;
  1071. delete m_pentrdecIntraDCc;
  1072. delete m_pentrdecMbTypeBVOP;
  1073. delete m_pentrdecWrpPnt ;
  1074. for (UInt iShapeMd = 0; iShapeMd < 7; iShapeMd++)
  1075. delete m_ppentrdecShapeMode [iShapeMd];
  1076. delete m_pentrdecShapeMV1;
  1077. delete m_pentrdecShapeMV2;
  1078.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  1079.   delete m_pentrdecDCTRVLC;
  1080.   delete m_pentrdecDCTIntraRVLC;
  1081.   // End Toshiba(1998-1-16:DP+RVLC)
  1082. }