home *** CD-ROM | disk | FTP | other *** search
/ Netrunner 2004 October / NETRUNNER0410.ISO / regular / dctm.lzh / DCTM / source.lzh / source / BitStreamStruct.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2003-03-08  |  8.7 KB  |  404 lines
  1. /*************************************************************************
  2.     BitStreamStruct.cpp
  3.  
  4.     03/03/07    Xiaohong    CreateFile é╠ê°Éöé≡ OPEN_ALWAYS é⌐éτ CREATE_ALWAYS é╔ò╧ìX
  5.     03/02/08    Xiaohong
  6. *************************************************************************/
  7. #include "BitStreamStruct.h"
  8. #include <windows.h>
  9. #include <math.h>
  10.  
  11. #define _malloc(s) HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, (s) )
  12. #define _free(p) HeapFree( GetProcessHeap(), 0, (p))
  13.  
  14. #define         NULL_CHAR               '\0'
  15.  
  16. #define         BITS_IN_A_BYTE          8
  17. #define         WORD                    16
  18.  
  19. #define         MINIMUM         4    /* Minimum size of the buffer in bytes */
  20. #define         MAX_LENGTH      32   /* Maximum length of word written or
  21.                                         read from bit stream */
  22. #define         READ_MODE       0
  23. #define         WRITE_MODE      1
  24. #define         ALIGNING        8
  25. #define         BINARY          0
  26. #define         ASCII           1
  27. #define         BS_FORMAT       BINARY /* BINARY or ASCII = 2x bytes */
  28.  
  29. #define         MIN(A, B)       ((A) < (B) ? (A) : (B))
  30. #define         MAX(A, B)       ((A) > (B) ? (A) : (B))
  31.  
  32. static const int g_nPutMaskArray[9]={0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff};
  33.  
  34. BitStreamStruct::BitStreamStruct()
  35. {
  36.     m_hFile = NULL;
  37.     m_pBuffer = NULL;
  38. }
  39. BitStreamStruct::~BitStreamStruct()
  40. {
  41.     Clear();
  42. }
  43. void BitStreamStruct::Clear(void)
  44. {
  45.     if(m_hFile!=NULL)
  46.     {
  47.         CloseHandle(m_hFile);
  48.         m_hFile = NULL;
  49.     }
  50.  
  51.     if(m_pBuffer!=NULL)
  52.     {
  53.         _free(m_pBuffer);
  54.         m_pBuffer = NULL;
  55.     }
  56. }
  57. BSSRET BitStreamStruct::OpenBitStreamW(const char* szFile,const int nSize)
  58. {
  59.     Clear();
  60.  
  61.     if((m_hFile = CreateFile(szFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,NULL))
  62.         == INVALID_HANDLE_VALUE)
  63.     {
  64.         return BSSR_OPEN_FILE_ERR;
  65.     }
  66.     if(!AllocBuffer(nSize))
  67.     {
  68.         return BSSR_ALLOC_BUFFER_ERR;
  69.     }
  70.     m_nBufferByteIndex = nSize-1;
  71.     m_nBufferBitIndex = 8;
  72.     m_nBitCount = 0;
  73.     m_nMode = WRITE_MODE;
  74.     m_nEndOfBuffer = 0;
  75.     m_bEndOfBitStream = false;
  76.  
  77.     return BSSR_OK;
  78. }
  79. BSSRET BitStreamStruct::OpenBitStreamR(const char* szFile,const int nSize)
  80. {
  81.     register DWORD n;
  82.     register unsigned char flag = 1;
  83.     unsigned char val;
  84.  
  85.     Clear();
  86.  
  87.     if((m_hFile = CreateFile(szFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))
  88.         == INVALID_HANDLE_VALUE)
  89.     {
  90.         return BSSR_OPEN_FILE_ERR;
  91.     }
  92.     do
  93.     {
  94.         ReadFile(m_hFile,&val,sizeof(unsigned char), &n, NULL);
  95.         switch (val)
  96.         {
  97.             case 0x30:
  98.             case 0x31:
  99.             case 0x32:
  100.             case 0x33:
  101.             case 0x34:
  102.             case 0x35:
  103.             case 0x36:
  104.             case 0x37:
  105.             case 0x38:
  106.             case 0x39:
  107.             case 0x41:
  108.             case 0x42:
  109.             case 0x43:
  110.             case 0x44:
  111.             case 0x45:
  112.             case 0x46:
  113.             case 0xa:  /* \n */
  114.             case 0xd:  /* cr */
  115.             case 0x1a:  /* sub */
  116.             break;
  117.  
  118.         default: /* detection of an binary character */
  119.             flag--;
  120.             break;
  121.         }
  122.  
  123.     } while (flag & n);
  124.  
  125.     if(flag)
  126.     {
  127.     //printf ("the bit stream file %s is an ASCII file\n", bs_filenam);
  128.         m_nFormat = ASCII;
  129.     }
  130.     else
  131.     {
  132.         m_nFormat = BINARY;
  133.     //printf ("the bit stream file %s is a BINARY file\n", bs_filenam);
  134.     }
  135.  
  136.     CloseHandle(m_hFile);
  137.     if((m_hFile = CreateFile(szFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))
  138.         == INVALID_HANDLE_VALUE)
  139.     {
  140.         return BSSR_OPEN_FILE_ERR;
  141.     }
  142. /*
  143.     fclose(pt);
  144.  
  145.     if ((pt = fopen(szFile, "rb")) == NULL)
  146.     {
  147.         return BSSR_OPEN_FILE_ERR;
  148.     }
  149. */
  150.     if(!AllocBuffer(nSize))
  151.     {
  152.         return BSSR_ALLOC_BUFFER_ERR;
  153.     }
  154.     m_nBufferByteIndex=0;
  155.     m_nBufferBitIndex=0;
  156.     m_nBitCount=0;
  157.     m_nMode = READ_MODE;
  158.     m_nEndOfBuffer = 0;
  159.     m_bEndOfBitStream = false;
  160.  
  161.     return BSSR_OK;
  162. }
  163. void BitStreamStruct::CloseBitStreamW(void)
  164. {
  165.     EmptyBuffer(m_nBufferByteIndex);
  166.     
  167.     Clear();
  168. }
  169.  
  170. void BitStreamStruct::CloseBitStreamR(void)
  171. {
  172.     Clear();
  173. }
  174.  
  175. void BitStreamStruct::RefillBuffer(void)
  176. {
  177.     register int i=m_nBufSize-2-m_nBufferByteIndex;
  178.     register DWORD n=1;
  179.     register int index=0;
  180.     char val[2];
  181.  
  182.     while ((i>=0) && (!m_nEndOfBuffer))
  183.     {
  184.  
  185.         if (m_nFormat == BINARY)
  186.             ReadFile(m_hFile,&m_pBuffer[i--],sizeof(unsigned char), &n, NULL);
  187.             //n = fread(&m_pBuffer[i--], sizeof(unsigned char), 1, pt);
  188.         else
  189.         {
  190.             while((index < 2) && n)
  191.             {
  192.                 ReadFile(m_hFile,&val[index],sizeof(unsigned char), &n, NULL);
  193.                 //n = fread(&val[index], sizeof(char), 1, pt);
  194.                 switch (val[index])
  195.                 {
  196.                 case 0x30:
  197.                 case 0x31:
  198.                 case 0x32:
  199.                 case 0x33:
  200.                 case 0x34:
  201.                 case 0x35:
  202.                 case 0x36:
  203.                 case 0x37:
  204.                 case 0x38:
  205.                 case 0x39:
  206.                 case 0x41:
  207.                 case 0x42:
  208.                 case 0x43:
  209.                 case 0x44:
  210.                 case 0x45:
  211.                 case 0x46:
  212.                     index++;
  213.                     break;
  214.                 default:
  215.                     break;
  216.                 }
  217.             }
  218.  
  219.             if (val[0] <= 0x39)
  220.                 m_pBuffer[i] = (val[0] - 0x30) << 4;
  221.             else
  222.                 m_pBuffer[i] = (val[0] - 0x37) << 4;
  223.  
  224.             if (val[1] <= 0x39)
  225.                 m_pBuffer[i--] |= (val[1] - 0x30);
  226.             else
  227.                 m_pBuffer[i--] |= (val[1] - 0x37);
  228.             index = 0;
  229.         }
  230.  
  231.         if (!n)
  232.         {
  233.             m_nEndOfBuffer = i+1;
  234.         }
  235.  
  236.     }
  237. }
  238.  
  239. inline bool BitStreamStruct::AllocBuffer(const int nSize)
  240. {
  241.     m_pBuffer = (unsigned char *)_malloc(nSize*sizeof(unsigned char));
  242.     m_nBufSize = nSize;
  243.  
  244.     if(m_pBuffer == NULL)
  245.     {
  246.         return false;
  247.     }
  248.     ZeroMemory(m_pBuffer,m_nBufSize);
  249.  
  250.     return true;
  251. }
  252. void BitStreamStruct::PutBitStream(const unsigned int val,int N)
  253. {
  254.     register int j = N;
  255.     register int k, tmp;
  256.  
  257.     if (N > MAX_LENGTH)
  258.         N = MAX_LENGTH;
  259.     //printf("Cannot read or write more than %d bits at a time.\n", MAX_LENGTH);
  260.  
  261.     m_nBitCount += N;
  262.     while (j > 0)
  263.     {
  264.         k = MIN(j, m_nBufferBitIndex);
  265.         tmp = val >> (j-k);
  266.         m_pBuffer[m_nBufferByteIndex] |= (tmp&g_nPutMaskArray[k]) << (m_nBufferBitIndex-k);
  267.         m_nBufferBitIndex -= k;
  268.         if(!m_nBufferBitIndex)
  269.         {
  270.            m_nBufferBitIndex = 8;
  271.            m_nBufferByteIndex--;
  272.            if(m_nBufferByteIndex < 0)
  273.               EmptyBuffer(MINIMUM);
  274.            m_pBuffer[m_nBufferByteIndex] = 0;
  275.         }
  276.         j -= k;
  277.     }
  278. }
  279. void BitStreamStruct::EmptyBuffer(const int minimum)
  280. {
  281.     register int i;
  282.     DWORD dwResult;
  283.  
  284.     for (i=m_nBufSize-1;i>=minimum;i--)
  285.         WriteFile(m_hFile, &m_pBuffer[i], sizeof(unsigned char), &dwResult, NULL);
  286.         //fwrite(&m_pBuffer[i], sizeof(unsigned char), 1, pt);
  287.  
  288.     for (i=minimum-1; i>=0; i--)
  289.         m_pBuffer[m_nBufSize - minimum + i] = m_pBuffer[i];
  290.  
  291.     m_nBufferByteIndex = m_nBufSize -1 - minimum;
  292.     m_nBufferBitIndex = 8;
  293. }
  294. void BitStreamStruct::PutBit(const unsigned int bit)
  295. {
  296.     m_nBitCount++;
  297.  
  298.     m_pBuffer[m_nBufferByteIndex] |= (bit&0x1) << (m_nBufferBitIndex-1);
  299.     m_nBufferBitIndex--;
  300.     if(!m_nBufferBitIndex)
  301.     {
  302.         m_nBufferBitIndex = 8;
  303.         m_nBufferByteIndex--;
  304.         if (m_nBufferByteIndex < 0)
  305.             EmptyBuffer(MINIMUM);
  306.         m_pBuffer[m_nBufferByteIndex] = 0;
  307.     }
  308. }
  309. unsigned long BitStreamStruct::GetBitStream(int N)
  310. {
  311.     unsigned long val=0;
  312.     register int i;
  313.     register int j = N;
  314.     register int k, tmp;
  315.  
  316.     if (N > MAX_LENGTH)
  317.         N = MAX_LENGTH;
  318.  
  319.     m_nBitCount += N;
  320.     while (j > 0)
  321.     {
  322.         if (!m_nBufferBitIndex)
  323.         {
  324.             m_nBufferBitIndex = 8;
  325.             m_nBufferByteIndex--;
  326.             if ((m_nBufferByteIndex < MINIMUM) || (m_nBufferByteIndex < m_nEndOfBuffer))
  327.             {
  328.                 if (m_nEndOfBuffer)
  329.                     m_bEndOfBitStream = true;
  330.                 else
  331.                 {
  332.                     for (i=m_nBufferByteIndex; i>=0;i--)
  333.                         m_pBuffer[m_nBufSize-1-m_nBufferByteIndex+i] = m_pBuffer[i];
  334.                     RefillBuffer();
  335.                     m_nBufferByteIndex = m_nBufSize-1;
  336.                 }
  337.             }
  338.         }
  339.         k = MIN (j, m_nBufferBitIndex);
  340.         tmp = m_pBuffer[m_nBufferByteIndex]&g_nPutMaskArray[m_nBufferBitIndex];
  341.         tmp = tmp >> (m_nBufferBitIndex-k);
  342.         val |= tmp << (j-k);
  343.         m_nBufferBitIndex -= k;
  344.         j -= k;
  345.     }
  346.     return val;
  347. }
  348.  
  349. unsigned int BitStreamStruct::GetBit(void)
  350. {
  351.     unsigned int bit;
  352.     register int i;
  353.     static const int mask[8]={0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
  354.  
  355.     m_nBitCount++;
  356.  
  357.     if (!m_nBufferBitIndex)
  358.     {
  359.         m_nBufferBitIndex = 8;
  360.         m_nBufferByteIndex--;
  361.         if ((m_nBufferByteIndex < MINIMUM) || (m_nBufferByteIndex < m_nEndOfBuffer))
  362.         {
  363.             if (m_nEndOfBuffer)
  364.                 m_bEndOfBitStream = true;
  365.             else
  366.             {
  367.                 for (i=m_nBufferByteIndex; i>=0;i--)
  368.                     m_pBuffer[m_nBufSize-1-m_nBufferByteIndex+i] = m_pBuffer[i];
  369.                 RefillBuffer();
  370.                 m_nBufferByteIndex = m_nBufSize-1;
  371.             }
  372.         }
  373.     }
  374.     bit = m_pBuffer[m_nBufferByteIndex]&mask[m_nBufferBitIndex-1];
  375.     bit = bit >> (m_nBufferBitIndex-1);
  376.     m_nBufferBitIndex--;
  377.  
  378.     return bit;
  379. }
  380.  
  381. bool BitStreamStruct::SeekSync(const long sync,const int N)
  382. {
  383.     unsigned long val;
  384.     long maxi = (long)pow(2.0,N) - 1;
  385.  
  386.     const unsigned long aligning = sstell()%ALIGNING;
  387.  
  388.     if (aligning)
  389.         GetBitStream((int)(ALIGNING-aligning));
  390.  
  391.     val = GetBitStream(N);
  392.     while((((signed)val&maxi) != sync) && (!end_bs()))
  393.     {
  394.         val <<= ALIGNING;
  395.         val |= GetBitStream(ALIGNING);
  396.     }
  397.  
  398.     if(end_bs())
  399.         return false;
  400.  
  401.     return true;
  402. }
  403.  
  404.