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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

bitstrm.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-4 Video conforming products. 
  29. This copyright notice must be included in all copies or derivative works. 
  31. Copyright (c) 1996, 1997.
  33. Module Name:
  35. bitstrm.cpp
  37. Abstract:
  39. Classes for bitstream I/O.
  41. Revision History:
  43. *************************************************************************/
  45. #include <iostream.h>
  46. #include <stdio.h>
  47. #include <stdlib.h>
  48. #include "typeapi.h"
  49. #include "bitstrm.hpp"
  50. #include "inbits.h"
  53. #ifdef __MFC_
  54. #ifdef _DEBUG
  55. #undef THIS_FILE
  56. static char BASED_CODE THIS_FILE[] = __FILE__;
  57. #endif
  59. #define new DEBUG_NEW    
  60. #endif // __MFC_
  62. UInt getbit (UInt data, UInt position, UInt num) // get the num-bit field of x starting from position p
  63. {
  64. return ((data >> (position + 1 - num)) & ~(~0 << num));
  65. }
  67. Void print_bit (UInt x, UInt num, UInt startPos) // print num bits starting from startPos
  68. {
  69. for (Int k = 0; k <= (Int) (num - startPos); k++) {
  70. UInt y = getbit (x, num, 1);
  71. printf ("%u ", y);
  72. x = x << 1;
  73. }
  74. printf ("n");
  75. }
  78. unsigned int bit_msk[33] =
  79. {
  80.   0x00000000, 0x00000001, 0x00000003, 0x00000007,
  81.   0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
  82.   0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
  83.   0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
  84.   0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
  85.   0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
  86.   0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
  87.   0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
  88.   0xffffffff
  89. };
  92. COutBitStream::COutBitStream (Char* pchBuffer, Int iBitPosition, ostream* pstrmTrace) : 
  93. m_pstrmTrace (pstrmTrace),
  94. m_chEncBuffer (0),
  95. m_uEncNumEmptyBits (8)
  96. {
  97. assert (iBitPosition < 8);
  98. assert (iBitPosition >= 0);
  99. m_iBitPosition = iBitPosition;
  100. m_pchBuffer = pchBuffer;
  101. m_lCounter = 0;
  102. m_pchBufferRun = m_pchBuffer;
  103. m_iBuffer = 0;
  104. // Added for Data Partitioning mode by Toshiba(1998-1-16)
  105. m_bDontSendBits = FALSE;
  106. // End Toshiba(1998-1-16)
  107. }
  108.  
  110. Void COutBitStream::reset () //but keep the byte buffer
  111. {
  112. // m_uEncNumEmptyBits = 8;
  113. // m_chEncBuffer = 0;
  114. m_pchBufferRun = m_pchBuffer;
  115. m_iBuffer = 0;
  116. }
  118. Void COutBitStream::resetAll ()
  119. {
  120. m_iBitPosition = 0;
  121. m_lCounter = 0;
  122. m_uEncNumEmptyBits = 8;
  123. m_chEncBuffer = 0;
  124. m_pchBufferRun = m_pchBuffer;
  125. m_iBuffer = 0;
  126. }
  128. Void COutBitStream::setBookmark ()
  129. {
  130. bookmark (1);
  131. }
  133. Void COutBitStream::gotoBookmark ()
  134. {
  135. bookmark (0);
  136. }
  138. Void COutBitStream::bookmark (Bool bSet)
  139. {
  140. static Bool bBookmarkOn = FALSE;
  141. static Int iBitPosition;
  142. static Int lCounter;
  143. static UInt uEncNumEmptyBits;
  144. static U8 chEncBuffer;
  145. static Char* pchBufferRun;
  146. static Int iBuffer;
  148. if (bSet) {
  149. iBitPosition = m_iBitPosition;
  150. lCounter = m_lCounter;
  151. uEncNumEmptyBits = m_uEncNumEmptyBits;
  152. chEncBuffer = m_chEncBuffer;
  153. pchBufferRun = m_pchBufferRun;
  154. iBuffer = m_iBuffer;
  155. bBookmarkOn = TRUE;
  156. }
  157. else {
  158. m_iBitPosition = iBitPosition;
  159. m_lCounter = lCounter;
  160. m_uEncNumEmptyBits = uEncNumEmptyBits;
  161. m_chEncBuffer = chEncBuffer;
  162. m_pchBufferRun = pchBufferRun;
  163. m_iBuffer = iBuffer;
  164. bBookmarkOn = FALSE;
  165. }
  166. }
  168. Void COutBitStream::putBitsC (Char cBits,Int iNOfBits)
  169. {
  170. putBits ((Int) cBits, (UInt) iNOfBits); 
  171. }
  174. Void COutBitStream::putBits (Int data, UInt numBits, const Char* rgchSymbolName)
  175. {
  176. assert (numBits < 100); //usually not that large
  177. if (numBits == 0) return;
  179. // Added for Data Partitioning mode by Toshiba(1998-1-16)
  180. if(m_bDontSendBits) return;
  181. // End Toshiba(1998-1-16)
  183. #ifdef __TRACE_AND_STATS_
  184. if (m_pstrmTrace != NULL && rgchSymbolName != NULL) {
  185. Char* rgchBinaryForm = new Char [numBits + 1];
  186. assert (rgchBinaryForm != NULL);
  187. m_pstrmTrace->width (20);
  188. (*m_pstrmTrace) << rgchSymbolName << ": ";
  189. Int iMask = 0xFFFFFFFF;
  190. iMask = iMask << numBits;
  191. iMask = ~iMask;
  192. Int iCleanData = data & iMask;
  193. //_itoa (iCleanData, rgchBinaryForm, 2); // win32 only
  194. Int iBit;
  195. iMask = 0x00000001;
  196. for (iBit = (Int) numBits - 1; iBit >= 0; iBit--) {
  197. rgchBinaryForm [iBit] = ((iCleanData & iMask) == 0) ? '0' : '1';
  198. iMask = iMask << 1;
  199. }
  200. rgchBinaryForm [numBits] = '';
  201. m_pstrmTrace->width (numBits);
  202. m_pstrmTrace->fill ('0');
  203. (*m_pstrmTrace) << rgchBinaryForm;
  204. m_pstrmTrace->fill (' ');
  205. (*m_pstrmTrace) << " @" << m_lCounter << 'n';
  206. m_pstrmTrace->flush ();
  207. delete rgchBinaryForm;
  208. }
  209. #endif // __TRACE_AND_STATS_
  211. if (m_uEncNumEmptyBits > numBits) { // not ready to put the data to buffer since it's not full
  212. m_uEncNumEmptyBits -= numBits;
  213. Char mskData = (0xFF >> (8 - numBits)) & data; 
  214. mskData = mskData << m_uEncNumEmptyBits;
  215. m_chEncBuffer = m_chEncBuffer ^ mskData;
  216.         m_lCounter += numBits;
  217. }
  218. else if (m_uEncNumEmptyBits == numBits) { // ready
  219. Char mskData = (0xFF >> (8 - numBits)) & data; 
  220. m_chEncBuffer = m_chEncBuffer ^ mskData;
  221. *m_pchBufferRun++ = m_chEncBuffer;
  222. m_iBuffer++;
  223. m_chEncBuffer = 0;
  224. m_uEncNumEmptyBits = 8;
  225.         m_lCounter += numBits;
  226. }
  227. else { // ready, but need to handle the leftover part
  228. UInt temp = getbit (data, numBits - 1, m_uEncNumEmptyBits);
  229. numBits -= m_uEncNumEmptyBits; // length of unhandled part
  230. m_chEncBuffer = m_chEncBuffer ^ temp;
  231.         m_lCounter += m_uEncNumEmptyBits;
  232. *m_pchBufferRun++ = m_chEncBuffer;
  233. m_iBuffer++;
  234. m_chEncBuffer = 0;
  235. m_uEncNumEmptyBits = 8;
  236. data = data ^ (temp << numBits);
  237. putBits (data, numBits);
  238. }
  239. }
  242. Void COutBitStream::putBits (Char *pBits, Int lNOfBits)
  243. {
  244.     assert(lNOfBits>=0);
  245.     while(lNOfBits>0)
  246.     {
  247.         if(lNOfBits>8)
  248.         {
  249.             putBitsC((Int)(*pBits),8);
  250.             lNOfBits-=8;
  251.             pBits++;
  252.         }
  253.         else
  254.         {
  255.             putBitsC((Int)(*pBits),(UInt)lNOfBits);
  256.             break;
  257.         }
  258.     }
  259. }
  261. Void COutBitStream::putBitStream(COutBitStream &cStrm)
  262. {
  263. cStrm.m_pchBufferRun[0]=cStrm.m_chEncBuffer >> cStrm.m_uEncNumEmptyBits;
  264. putBits(cStrm.m_pchBuffer,cStrm.m_lCounter);
  265. }
  267. Int COutBitStream::flush ()
  268. {
  269. Int nBits = 0;
  270. if (m_uEncNumEmptyBits != 8) {
  271. nBits = m_uEncNumEmptyBits;
  272. putBits ((Int) 0, (UInt) 1);
  273. putBits ((Int) 0xFFFF, nBits - 1);
  275. /*
  276. *m_pchBufferRun++ = m_chEncBuffer;
  277. m_iBuffer++;
  278. m_lCounter += m_uEncNumEmptyBits;
  279. nBits = m_uEncNumEmptyBits;
  280. m_uEncNumEmptyBits = 8;
  281. m_chEncBuffer = 0;
  282. */
  283. }
  284. else {
  285. nBits = 8;
  286. putBits ((Int) 0x007F, nBits);
  287. }
  288. return nBits;
  289. }
  291. Void COutBitStream::trace (const Char* rgchSymbolName)
  292. {
  293. if (m_pstrmTrace != NULL) {
  294. m_pstrmTrace->width (20);
  295. (*m_pstrmTrace) << rgchSymbolName;
  296. m_pstrmTrace->flush ();
  297. }
  298. }
  300. Void COutBitStream::trace (Int iValue, const Char* rgchSymbolName)
  301. {
  302. if (m_pstrmTrace != NULL) {
  303. m_pstrmTrace->width (20);
  304. (*m_pstrmTrace) << rgchSymbolName << "= ";
  305. (*m_pstrmTrace) << iValue << "n";
  306. m_pstrmTrace->flush ();
  307. }
  308. }
  310. Void COutBitStream::trace (UInt uiValue, const Char* rgchSymbolName)
  311. {
  312. if (m_pstrmTrace != NULL) {
  313. m_pstrmTrace->width (20);
  314. (*m_pstrmTrace) << rgchSymbolName << "= ";
  315. (*m_pstrmTrace) << uiValue << "n";
  316. m_pstrmTrace->flush ();
  317. }
  318. }
  320. Void COutBitStream::trace (Float fltValue, const Char* rgchSymbolName)
  321. {
  322. if (m_pstrmTrace != NULL) {
  323. m_pstrmTrace->width (20);
  324. (*m_pstrmTrace) << rgchSymbolName << "= ";
  325. (*m_pstrmTrace) << fltValue << "n";
  326. m_pstrmTrace->flush ();
  327. }
  328. }
  330. #ifndef __DOUBLE_PRECISION_
  331. Void COutBitStream::trace (Double dblValue, const Char* rgchSymbolName)
  332. {
  333. if (m_pstrmTrace != NULL) {
  334. m_pstrmTrace->width (20);
  335. (*m_pstrmTrace) << rgchSymbolName << "= ";
  336. (*m_pstrmTrace) << dblValue << "n";
  337. m_pstrmTrace->flush ();
  338. }
  339. }
  340. #endif
  342. Void COutBitStream::trace (const CMotionVector& mvValue, const Char* rgchSymbolName)
  343. {
  344. if (m_pstrmTrace != NULL) {
  345. m_pstrmTrace->width (20);
  346. (*m_pstrmTrace) << rgchSymbolName << "= ";
  347. (*m_pstrmTrace) << mvValue.iMVX + mvValue.iMVX + mvValue.iHalfX << ", ";
  348. (*m_pstrmTrace) << mvValue.iMVY + mvValue.iMVY + mvValue.iHalfY << "n ";
  349. m_pstrmTrace->flush ();
  350. }
  351. }
  353. Void COutBitStream::trace (const CVector2D& vctValue, const Char* rgchSymbolName)
  354. {
  355. if (m_pstrmTrace != NULL) {
  356. m_pstrmTrace->width (20);
  357. (*m_pstrmTrace) << rgchSymbolName << "= ";
  358. (*m_pstrmTrace) << vctValue.x << ", ";
  359. (*m_pstrmTrace) << vctValue.y << "n ";
  360. m_pstrmTrace->flush ();
  361. }
  362. }
  364. Void COutBitStream::trace (const CSite& stValue, const Char* rgchSymbolName)
  365. {
  366. if (m_pstrmTrace != NULL) {
  367. m_pstrmTrace->width (20);
  368. (*m_pstrmTrace) << rgchSymbolName << "= ";
  369. (*m_pstrmTrace) << stValue.x << ", ";
  370. (*m_pstrmTrace) << stValue.y << "n ";
  371. m_pstrmTrace->flush ();
  372. }
  373. }
  375. Void COutBitStream::trace (const CFloatImage* pfi, const Char* rgchSymbolName, CRct rct)
  376. {
  377. if (m_pstrmTrace == NULL)
  378. return;
  379. Int iValue;
  380. (*m_pstrmTrace) << rgchSymbolName << "= n";
  381. if (rct.valid ()) {
  382. for (CoordI iY = rct.top; iY < rct.bottom; iY++) {
  383. const PixelF* ppxlf = pfi->pixels (rct.left, iY);
  384. for (CoordI iX = rct.left; iX < rct.right; iX++) {
  385. iValue = (Int) *ppxlf;
  386. (*m_pstrmTrace) << iValue << " ";
  387. ppxlf++;
  388. }
  389. (*m_pstrmTrace) << "n";
  390. }
  392. }
  393. else {
  394. const PixelF* ppxlf = pfi->pixels ();
  395. for (CoordI iY = pfi->where ().top; iY < pfi->where ().bottom; iY++) {
  396. for (CoordI iX = pfi->where ().left; iX < pfi->where ().right; iX++) {
  397. iValue = (Int) *ppxlf;
  398. (*m_pstrmTrace) << iValue << " ";
  399. ppxlf++;
  400. }
  401. (*m_pstrmTrace) << "n";
  402. }
  403. }
  404. m_pstrmTrace->flush ();
  405. }
  407. Void COutBitStream::trace (const Float* ppxlf, UInt cElem, const Char* rgchSymbolName)
  408. {
  409. if (m_pstrmTrace == NULL)
  410. return;
  411. Int iValue;
  412. (*m_pstrmTrace) << rgchSymbolName << ": n";
  413. for (UInt iElem = 0; iElem < cElem; iElem++) {
  414. iValue = (Int) *ppxlf;
  415. (*m_pstrmTrace) << iValue << " ";
  416. ppxlf++;
  417. }
  418. (*m_pstrmTrace) << "n";
  419. m_pstrmTrace->flush ();
  420. }
  422. Void COutBitStream::trace (const Int* rgi, UInt cElem, const Char* rgchSymbolName)
  423. {
  424. if (m_pstrmTrace == NULL)
  425. return;
  426. (*m_pstrmTrace) << rgchSymbolName << ": n";
  427. for (UInt iElem = 0; iElem < cElem; iElem++) {
  428. (*m_pstrmTrace) << *rgi++ << " ";
  429. }
  430. (*m_pstrmTrace) << "n";
  431. m_pstrmTrace->flush ();
  432. }
  434. Void COutBitStream::trace (const PixelC* rgpxlc, Int cCol, Int cRow, const Char* rgchSymbolName) //this is for tracing shape buffers
  435. {
  436. if (m_pstrmTrace == NULL)
  437. return;
  438. (*m_pstrmTrace) << rgchSymbolName << ": n";
  439. for (Int iRow = -1; iRow < cRow; iRow++) {
  440. for (Int iCol = -1; iCol < cCol; iCol++) {
  441. if (iRow == -1)
  442. (*m_pstrmTrace) << "-";
  443. else if (iCol == -1) {
  444. m_pstrmTrace->width (2);
  445. (*m_pstrmTrace) << iRow << "|"; 
  446. }
  447. else
  448. (*m_pstrmTrace) << (*rgpxlc++ == MPEG4_OPAQUE); 
  449. }
  450. (*m_pstrmTrace) << "n";
  451. }
  452. m_pstrmTrace->flush ();
  453. }
  455. CInBitStream::CInBitStream (void) 
  456. {
  457.   m_pistrm = -1;
  458.   init();
  459. }
  461. CInBitStream::CInBitStream (int istrm)
  462. {
  463.   m_pistrm = istrm;
  464.   init();
  465. }
  467. CInBitStream::~CInBitStream() 
  468. {
  469.   if (m_pistrm >= 0) {
  470.     free(m_buffer);
  471.   };
  472. }
  473.   
  474. void CInBitStream::init (void) {
  475.   m_bookmark = 0;
  476.   m_buffer = NULL;
  477.   m_framebits = m_framebits_max = 0;
  478. }
  481. uint32_t CInBitStream::getBits (uint32_t numBits)
  482. {
  483.   uint32_t ret = peekBits(numBits);
  484.   flushbits(numBits);
  485.   return ret;
  486. }
  488. int CInBitStream::peekOneBit (uint32_t numBits)
  489. {
  490.   return peekBits(numBits) & 0x1;
  491. }
  493. int CInBitStream::peekBitsTillByteAlign (int &nBitsToPeek)
  494. {
  495.   nBitsToPeek = 8 - m_bitcnt;
  496.   return peekBits(nBitsToPeek);
  497. }
  499. int CInBitStream::peekBitsFromByteAlign (int nBitsToPeek) 
  500. {
  501.   int ret;
  502.   if (nBitsToPeek == 0) return 0;
  503.   setBookmark();
  504.   getBits((uint32_t)8 - m_bitcnt);
  505.   ret = peekBits(nBitsToPeek);
  506.   gotoBookmark();
  507.   return ret;
  508. }
  510. void CInBitStream::bookmark (Bool bSet) 
  511. {
  512.   if (bSet) setBookmark();
  513.   else gotoBookmark();
  514. }
  517. void CInBitStream::read_ifstream_buffer (void)
  518. {
  519.   int left, offset, ret;
  520.   if (m_buffer == NULL) {
  521.     m_buffer = (unsigned char *)malloc(8092);
  522.     m_orig_buflen = read(m_pistrm, m_buffer, 8092);
  523.     m_framebits = 0;
  524.     m_bitcnt = 0;
  525.     m_rdptr = m_buffer;
  526.   } else {
  527.     if (m_bookmark == 0) {
  528.       left = m_orig_buflen - (m_framebits / 8);
  529.       offset = m_orig_buflen - left;
  530.       memmove(m_buffer,
  531.       m_buffer + offset,
  532.       left);
  533.       ret = read(m_pistrm, m_buffer + left, m_orig_buflen - left);
  534.       m_orig_buflen = left + ret;
  535.       m_framebits = m_bitcnt;
  536.       m_rdptr = m_buffer;
  537.     } else {
  538.       left = m_orig_buflen - (m_bookmark_framebits / 8);
  539.       offset = m_orig_buflen - left;
  540.       memmove(m_buffer,
  541.       m_buffer + offset,
  542.       left);
  543.       ret = read(m_pistrm, m_buffer + offset, m_orig_buflen - left);
  544.       m_orig_buflen = left + ret;
  545.       int framebits_past, rdptr_past;
  547.       framebits_past = m_framebits - m_bookmark_framebits;
  548.       rdptr_past = m_rdptr - m_bookmark_rdptr;
  549.       m_framebits = m_bitcnt + framebits_past;
  550.       m_bookmark_framebits = m_bitcnt;
  551.       m_bookmark_rdptr = m_buffer;
  552.       m_rdptr = m_buffer + rdptr_past;
  553.     }
  554.   }
  555.   m_framebits_max = m_orig_buflen * 8;
  556. }
  558. void CInBitStream::set_buffer (unsigned char *bptr, 
  559.        uint32_t blen) 
  560. {
  561.   m_buffer = bptr;
  562.   m_rdptr = bptr;
  563.   m_bitcnt = 0;
  564.   m_framebits = 0;
  565.   m_orig_buflen = blen;
  566.   m_framebits_max = blen * 8;
  567.   m_bookmark = 0;
  568. }
  570. Void CInBitStream::flush (int nExtraBits) 
  571. {
  572.   if (m_bitcnt == 0) getBits((uint32_t)nExtraBits);
  573.   if (m_bitcnt != 0)
  574.     flushbits(8 - m_bitcnt);
  575. }