ringbuf.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:7k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxtypes.h"
  36. #include "hxcom.h"
  37. #include "hlxclib/string.h"
  38. #include "hxcomm.h"
  39. #include "ihxpckts.h"
  40. #include "hxresult.h"
  41. #include "ringbuf.h"
  42. CIHXRingBuffer::CIHXRingBuffer(IHXCommonClassFactory *pClassFactory,
  43.                                  UINT32 ulBufSize,
  44.                                  UINT32 ulWrapSize)
  45.     : m_lRefCount(0),
  46.       m_pBuffer(NULL),
  47.       m_pVBufBegin(NULL),
  48.       m_ulBufBegin(0),
  49.       m_ulBufEnd(0),
  50.       m_ulWrite(0),
  51.       m_ulRead(0),
  52.       m_ulBytesWritten(0),
  53.       m_ulBytesRead(0),
  54.       m_ulBufSize(ulBufSize),
  55.       m_ulGuardSize(ulWrapSize),
  56.       m_pIhxBuffer(NULL),
  57.       m_ulError(0)
  58. {
  59.     // Create an IHXBuffer
  60.     pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&m_pIhxBuffer);
  61.     if (m_pIhxBuffer)
  62.     {
  63.         // 32-byte allign buffer
  64.         m_pIhxBuffer->SetSize(ulBufSize + ulWrapSize + 31);
  65.         if (m_pIhxBuffer->GetSize() != ulBufSize + ulWrapSize + 31)
  66.         {
  67.             m_pIhxBuffer->Release();
  68.             m_pIhxBuffer = NULL;
  69.             m_ulError = HXR_OUTOFMEMORY;
  70.             
  71.             return;
  72.         }
  73.         m_pBuffer = m_pIhxBuffer->GetBuffer();
  74.         m_pBuffer = (UCHAR*) (((PTR_INT) m_pBuffer + 31) & ~31);
  75.     
  76.         // Init members
  77.         m_pBufBegin = m_pBuffer + m_ulGuardSize;
  78.         m_ulBufEnd = m_ulBufBegin + m_ulBufSize;
  79.         m_pVBufBegin = m_pBufBegin;
  80.         m_pWrite =
  81.         m_pRead = m_pBufBegin;
  82.     }
  83.     else
  84.     {
  85.         m_ulError = HXR_OUTOFMEMORY;
  86.     }
  87. }
  88. CIHXRingBuffer::~CIHXRingBuffer()
  89. {
  90.     // Release the buffer
  91.     if (m_pIhxBuffer)
  92.         m_pIhxBuffer->Release();
  93. }
  94. ///////////////////////////////////////////////////////////////////////////////
  95. // IUnknown methods
  96. ///////////////////////////////////////////////////////////////////////////////
  97. STDMETHODIMP CIHXRingBuffer::QueryInterface(REFIID riid,
  98.              void** ppvObj)
  99. {
  100.     if (IsEqualIID(riid, IID_IUnknown))
  101.     {
  102.     AddRef();
  103.     *ppvObj = this;
  104.     return HXR_OK;
  105.     }
  106.     else if (IsEqualIID(riid, IID_IHXBuffer))
  107.     {
  108.     AddRef();
  109.     *ppvObj = (IHXBuffer*)this;
  110.     return HXR_OK;
  111.     }
  112.     *ppvObj = NULL;
  113.     return HXR_NOINTERFACE;
  114. }
  115. STDMETHODIMP_(ULONG32) 
  116. CIHXRingBuffer::AddRef()
  117. {
  118.     return InterlockedIncrement(&m_lRefCount);
  119. }
  120. STDMETHODIMP_(ULONG32) 
  121. CIHXRingBuffer::Release()
  122. {
  123.     return InterlockedIncrement(&m_lRefCount);
  124. }
  125. ///////////////////////////////////////////////////////////////////////////
  126. // IHXBuffer methods
  127. ///////////////////////////////////////////////////////////////////////////
  128. STDMETHODIMP
  129. CIHXRingBuffer::Get(REF(UCHAR*) pData, 
  130.                      REF(ULONG32) ulLength)
  131. {
  132.     return m_pIhxBuffer->Get(pData, ulLength);
  133. }
  134. STDMETHODIMP
  135. CIHXRingBuffer::Set(const UCHAR *pData, 
  136.                      ULONG32 ulLength)
  137. {
  138.     return m_pIhxBuffer->Set(pData, ulLength);
  139. }
  140. STDMETHODIMP
  141. CIHXRingBuffer::SetSize(ULONG32 ulLength)
  142. {
  143.     return m_pIhxBuffer->SetSize(ulLength);
  144. }
  145. STDMETHODIMP_(ULONG32) 
  146. CIHXRingBuffer::GetSize()
  147. {
  148.     return m_pIhxBuffer->GetSize();
  149. }
  150. STDMETHODIMP_(UCHAR*)
  151. CIHXRingBuffer::GetBuffer()
  152. {
  153.     return m_pIhxBuffer->GetBuffer();
  154. }
  155. void CIHXRingBuffer::Reset()
  156. {
  157.     m_pVBufBegin = m_pBufBegin;
  158.     m_pWrite =
  159.     m_pRead = m_pBufBegin;
  160.     m_ulBytesWritten =
  161.     m_ulBytesRead = 0;
  162. }
  163. UINT32 CIHXRingBuffer::CopyData(UCHAR *pData, UINT32 ulBytes)
  164. {
  165.     UINT32 ulCopy = min(ulBytes, GetFreeBufferSpace());
  166.     UINT32 ulWrap = 0;
  167.     // Handle buffer wrap
  168.     if (m_ulWrite + ulCopy >= m_ulBufEnd)
  169.     {
  170.         ulWrap = m_ulBufEnd - m_ulWrite;
  171.         memcpy(m_pWrite, pData, ulWrap); /* Flawfinder: ignore */
  172.         pData += ulWrap;
  173.         ulCopy -= ulWrap;
  174.         m_ulBytesWritten += ulWrap;
  175.         m_ulWrite = m_ulBufBegin;
  176.     }
  177.     memcpy(m_pWrite, pData, ulCopy); /* Flawfinder: ignore */
  178.     m_ulBytesWritten += ulCopy;
  179.     m_ulWrite += ulCopy;
  180.     // Number of bytes copied to the buffer
  181.     return ulCopy + ulWrap;
  182. }
  183. void CIHXRingBuffer::AdvanceRead(UINT32 ulBytes)
  184. {
  185.     m_ulRead += ulBytes;
  186.     if (m_ulRead >= m_ulBufEnd)
  187.         m_ulRead -= m_ulBufSize;
  188.     m_ulBytesRead += ulBytes;
  189. }
  190. void CIHXRingBuffer::DecrementRead(UINT32 ulBytes)
  191. {
  192.     m_ulRead -= ulBytes;
  193.     if (m_ulRead < m_ulBufBegin)
  194.         m_ulRead += m_ulBufSize;
  195.     m_ulBytesRead -= ulBytes;
  196. }
  197. UCHAR* CIHXRingBuffer::GetReadPointer(UINT32 &ulBytes)
  198. {
  199.     ulBytes = m_ulBufEnd - m_ulRead;
  200.     ulBytes = min((UINT32)ulBytes, GetBytesInBuffer());
  201.     return m_pRead;
  202. }
  203. void CIHXRingBuffer::Wrap(UINT32 ulOldBytes)
  204. {
  205.     // Ensures that distance from end of buffer
  206.     // to read from is less that our guard.
  207.     UINT32   ulSize = m_ulBufEnd - m_ulRead + ulOldBytes;
  208.     if (ulSize <= m_ulGuardSize)
  209.     {
  210.         memcpy(m_pBufBegin-ulSize, m_pRead-ulOldBytes, ulSize); /* Flawfinder: ignore */
  211.         m_pRead = m_pBufBegin-ulSize+ulOldBytes;
  212.         m_pVBufBegin = m_pBufBegin-ulSize;
  213.     }
  214. }