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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
chxfgbuf.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：21k
源码类别：

Symbian

开发平台：

C/C++

chxfgbuf.cpp：源码内容
  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 ***** */ 
  36. #include "hxtypes.h"
  37. #include "hxresult.h"
  38. #include "hxcom.h"
  39. #include "chxfgbuf.h"
  41. #include "hxheap.h"
  42. #ifdef _DEBUG
  43. #undef HX_THIS_FILE
  44. static const char HX_THIS_FILE[] = __FILE__;
  45. #endif
  47. IMPLEMENT_INTERFACE_ARRAY_ENUMERATOR(IHXEnumFragmentedBuffer)
  49. BEGIN_INTERFACE_LIST(_CBufferFragment)
  50.     INTERFACE_LIST_ENTRY(IID_IHXBuffer, IHXBuffer)
  51. END_INTERFACE_LIST
  53. BEGIN_INTERFACE_LIST(CHXFragmentedBuffer)
  54.     INTERFACE_LIST_ENTRY(IID_IHXFragmentedBuffer, IHXFragmentedBuffer)
  55.     INTERFACE_LIST_ENTRY(IID_IHXBuffer, IHXBuffer)
  56. END_INTERFACE_LIST
  58. /* IHXFragmentedBuffer Methods
  59.  */
  61. STDMETHODIMP 
  62. CHXFragmentedBuffer::_FindFragment(UINT32 ulFindIndex, REF(_CFragment*) pfrgCurrent, REF(UINT32) ulCurrentSize, REF(UINT32) ulCurrentStart)
  63. {
  64.     pfrgCurrent = m_frglstThis.First();
  66.     ulCurrentStart = 0;
  68.     while(pfrgCurrent)
  69.     {
  70. ulCurrentSize = pfrgCurrent->GetData()->GetSize();
  72. if(ulCurrentStart+ulCurrentSize > ulFindIndex)
  73. {
  74.     break;
  75. }
  77. ulCurrentStart += ulCurrentSize;
  79. pfrgCurrent = pfrgCurrent->Next();
  80.     }
  82.     return HXR_OK;
  83. }
  86. STDMETHODIMP
  87. CHXFragmentedBuffer::GetEnumerator(IHXEnumFragmentedBuffer** ppefbNewEnum)
  88. {
  89.     if(!ppefbNewEnum)
  90.         return HXR_POINTER;
  92.     *ppefbNewEnum = NULL;
  94.     IHXBuffer** arrpbufData = NULL;
  96.     if(m_frglstThis.GetTotal())
  97.     {
  98.         _CFragment* pfrgCurrent;
  99.         UINT32 ulIndex;
  101.         arrpbufData = (IHXBuffer**)new IHXBuffer*[m_frglstThis.GetTotal()];
  103.         for 
  104.         (
  105.             pfrgCurrent = m_frglstThis.First(), ulIndex = 0;
  106.             pfrgCurrent;
  107.             pfrgCurrent = pfrgCurrent->Next(), ++ulIndex
  108.         )
  109.         {
  110.             arrpbufData[ulIndex] = pfrgCurrent->GetData();
  111.             (arrpbufData[ulIndex])->AddRef();
  112.         }
  113.     }
  115.     CREATE_INTERFACE_ARRAY_ENUMERATOR
  116.     (
  117.         IHXEnumFragmentedBuffer, 
  118.         arrpbufData,
  119.         m_frglstThis.GetTotal(),
  120.         ppefbNewEnum
  121.     )
  122.     
  123.     
  124.     return HXR_OK;
  125. }
  128. /* Use these to scatter the buffers
  129.  */
  131. STDMETHODIMP 
  132. CHXFragmentedBuffer::Prepend(IHXBuffer* pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom)
  133. {
  134.     if(!pBufferFrom)
  135.     {
  136. return HXR_UNEXPECTED;
  137.     }
  139.     m_frglstThis.Insert
  140.     (
  141. (new _CFragment())->SetData
  142. (
  143.     pBufferFrom, 
  144.     ulStartFrom, 
  145.     ulLengthFrom
  146. )
  147.     );
  149.     return HXR_OK;
  150. }
  152. STDMETHODIMP 
  153. CHXFragmentedBuffer::Append(IHXBuffer* pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom)
  154. {
  155.     if(!pBufferFrom)
  156.     {
  157. return HXR_UNEXPECTED;
  158.     }
  160.     m_frglstThis.Append
  161.     (
  162. (new _CFragment())->SetData
  163. (
  164.     pBufferFrom, 
  165.     ulStartFrom, 
  166.     ulLengthFrom
  167. )
  168.     );
  170.     return HXR_OK;
  171. }
  173. STDMETHODIMP 
  174. CHXFragmentedBuffer::Insert(IHXBuffer* pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom, UINT32 ulStartTo)
  175. {
  176.     if(!pBufferFrom)
  177.     {
  178. return HXR_UNEXPECTED;
  179.     }
  181.     _CFragment* pfrgFirst;
  182.     UINT32 ulTotalFirst=0, ulSizeFirst=0;
  183.     UINT32 ulFirstIndx;
  185.     /* Find First affected fragment
  186.      */
  187.     _FindFragment(ulStartTo, pfrgFirst, ulSizeFirst, ulTotalFirst);
  189.     ulFirstIndx = ulStartTo - ulTotalFirst;
  191.     if(pfrgFirst)
  192.     {
  193. IHXBuffer* phxbufBuffy;
  195. phxbufBuffy = pfrgFirst->GetData();
  196. phxbufBuffy->AddRef();
  198. /* Reset existing fragment to contain first part of phxbufBuffy
  199.  */
  200. pfrgFirst->SetData(phxbufBuffy, 0, ulFirstIndx);
  202. /* Append new fragment to contain last part of phxbufBuffy (if any)
  203.  */
  204. if((ulSizeFirst-ulFirstIndx) > 0)
  205. {
  206.     m_frglstThis.Append
  207.     (
  208. (
  209.     (_CFragment*) new _CFragment()
  210. )
  211. ->SetData
  212. (
  213.     phxbufBuffy, 
  214.     ulFirstIndx, 
  215.     UINT32(-1)
  216. )
  217. , pfrgFirst
  218.     );
  219. }
  221. HX_RELEASE(phxbufBuffy);
  222.     }
  223.     else
  224.     {
  225. /* The existing buffers are not big enough
  226.  * Need to make an empty Buffer sizeof ulFirstIndx-1
  227.  */
  228. IHXBuffer* phxbufTemp = (IHXBuffer*)(new CHXBuffer());
  230. phxbufTemp->AddRef();
  231. phxbufTemp->SetSize(ulFirstIndx-1);
  233. pfrgFirst = new _CFragment();
  234. pfrgFirst->SetData(phxbufTemp);
  236. m_frglstThis.Append(pfrgFirst);
  238. HX_RELEASE(phxbufTemp);
  239.     }
  241.     _CFragment* pfrgNew;
  243.     /* Make new fragment to hold the new data
  244.      */
  245.     pfrgNew = new _CFragment();
  247.     /* Set the new data into the fragment
  248.      */
  249.     pfrgNew->SetData(pBufferFrom, ulStartFrom, ulLengthFrom);
  251.     /* Append the New fragment
  252.      */
  253.     m_frglstThis.Append(pfrgNew, pfrgFirst);
  255.     return HXR_OK;
  256. }
  258. STDMETHODIMP 
  259. CHXFragmentedBuffer::Replace(IHXBuffer* pBufferFrom, UINT32 ulStartFrom, UINT32 ulLengthFrom, UINT32 ulStartTo)
  260. {
  261.     if(!pBufferFrom)
  262.     {
  263. return HXR_UNEXPECTED;
  264.     }
  266.     _CFragment* pfrgFirst;
  267.     _CFragment* pfrgLast;
  268.     _CFragment* pfrgTmp;
  269.     UINT32 ulTotalFirst=0, ulSizeFirst=0, ulTotalLast=0, ulSizeLast=0;
  270.     UINT32 ulFirstIndx, ulLastIndx;
  272.     /* Find First affected fragment
  273.      */
  274.     _FindFragment(ulStartTo, pfrgFirst, ulSizeFirst, ulTotalFirst);
  276.     ulFirstIndx = ulStartTo - ulTotalFirst;
  278.     /* Find Last affected fragment
  279.      * search for ulStartTo+ulLengthFrom
  280.      * Release any buffers contained in that byte range.
  281.      */
  282.     pfrgLast = pfrgFirst;
  283.     ulTotalLast = 0;
  284.     while (pfrgLast)
  285.     {
  286. ulSizeLast = pfrgLast->GetData()->GetSize();
  288. if(ulLengthFrom <= ulTotalLast+ulSizeLast)
  289. {
  290.     break;
  291. }
  293. ulTotalLast += ulSizeLast;
  295. pfrgTmp = pfrgLast;
  297. pfrgLast = pfrgLast->Next();
  299. if (pfrgTmp != pfrgFirst)
  300. {
  301.     m_frglstThis.Remove(pfrgTmp);
  302. }
  303.     }
  305.     if(pfrgFirst == pfrgLast)
  306. ulLastIndx = ulFirstIndx + ulLengthFrom - 1;
  307.     else
  308. ulLastIndx = ulLengthFrom - ulTotalLast;
  310.     if(pfrgFirst)
  311.     {
  312. IHXBuffer* phxbufBuffy;
  314. phxbufBuffy = pfrgFirst->GetData();
  315. phxbufBuffy->AddRef();
  317. /* Reset existing fragment to contain first part of phxbufBuffy
  318.  */
  319. if(ulFirstIndx)
  320. {
  321.     pfrgFirst->SetData(phxbufBuffy, 0, ulFirstIndx);
  322. }
  323. else
  324. {
  325.     if(pfrgFirst == pfrgLast)
  326.     {
  327. pfrgFirst = NULL;
  328.     }
  329.     else
  330.     {
  331. /* Remove pfrgFirst..
  332.  */
  334. pfrgTmp = pfrgFirst->Prev();
  336. m_frglstThis.Remove(pfrgFirst);
  338. pfrgFirst = pfrgTmp;
  339.     }
  340. }
  342. if(pfrgLast)
  343. {
  344.     if (pfrgLast == pfrgFirst)
  345.     {
  346. /* Need to create new fragment. 
  347.  */
  348. pfrgLast = new _CFragment();
  350. m_frglstThis.Append(pfrgLast, pfrgFirst);
  351.     }
  352.     else
  353.     {
  354. HX_RELEASE(phxbufBuffy);
  356. /* Reuse existing fragment.
  357.  */
  358. (phxbufBuffy = pfrgLast->GetData())->AddRef();
  359.     }
  361.     if(ulLastIndx < phxbufBuffy->GetSize())
  362.     {
  363. /* Need to fragment the Last Fragment. :)
  364.  */
  365. pfrgLast->SetData(phxbufBuffy, ulLastIndx+1, UINT32(-1));
  366.     }
  367.     else
  368.     {
  369. /* Need to discard the Last Fragment.
  370.  */
  371. pfrgTmp = pfrgLast->Prev();
  373. m_frglstThis.Remove(pfrgLast);
  375. pfrgLast = pfrgTmp;
  376.     }
  377. }
  379. HX_RELEASE(phxbufBuffy);
  380.     }
  381.     else if (ulFirstIndx)
  382.     {
  383. /* The existing buffers are not big enough
  384.  * Need to make an empty Buffer sizeof ulFirstIndx-1
  385.  */
  386. IHXBuffer *phxbufTemp = (IHXBuffer*)(new CHXBuffer());
  388. phxbufTemp->AddRef();
  389. phxbufTemp->SetSize(ulFirstIndx-1);
  391. pfrgFirst = new _CFragment();
  392. pfrgFirst->SetData(phxbufTemp);
  394. m_frglstThis.Append(pfrgFirst);
  396. HX_RELEASE(phxbufTemp);
  397.     }
  399.     _CFragment* pfrgNew;
  401.     /* Make new fragment to hold the new data
  402.      */
  403.     pfrgNew = new _CFragment();
  405.     /* Set the new data into the fragment
  406.      */
  407.     pfrgNew->SetData(pBufferFrom, ulStartFrom, ulLengthFrom);
  409.     /* Append the New fragment
  410.      */
  411.     if (pfrgFirst)
  412.     {
  413. m_frglstThis.Append(pfrgNew, pfrgFirst);
  414.     }
  415.     else
  416.     {
  417. m_frglstThis.Insert(pfrgNew, pfrgLast);
  418.     }
  420.     return HXR_OK;
  421. }
  423. /* These will gather and return the specified area
  424.  */
  426. STDMETHODIMP 
  427. CHXFragmentedBuffer::Get(UINT32 ulStartFrom, UINT32 ulLengthFrom, REF(UCHAR*) pData, REF(UINT32) ulLength)
  428. {
  429.     /* Gather from start to start+length
  430.      */
  431.     
  432.     pData = NULL;
  433.     ulLength = 0;
  434.     
  435.     _CFragment* pfrgFirst=NULL;
  436.     _CFragment* pfrgCurrent=NULL;
  437.     IHXBuffer* phxbufBuffy=NULL;
  438.     UINT32 ulTotalFirst=0, ulSizeFirst=0;
  439.     UINT32 ulFirstStartIndex;
  441.     if (ulLengthFrom == (UINT32)(-1))
  442.     {
  443. ulLengthFrom = GetSize() - ulStartFrom;
  444.     }
  446.     /* Find First fragment
  447.      */
  448.     _FindFragment(ulStartFrom, pfrgFirst, ulSizeFirst, ulTotalFirst);
  450.     ulFirstStartIndex = ulStartFrom-ulTotalFirst;
  451.     
  452.     if (pfrgFirst)
  453.     {
  454. /* If the range is in one fragment, then just return that fragment.
  455.  */
  456. if(pfrgFirst->GetData()->GetSize() >= ulFirstStartIndex+ulLengthFrom)
  457. {
  458.     (phxbufBuffy = pfrgFirst->GetData())->AddRef();
  459. }
  460. else
  461. {
  462.     UCHAR* pucBuffy;
  463.     UINT32 ulStartIndex;
  464.     UINT32 ulSize;
  465.     UINT32 ulRemainingLength;
  467.     phxbufBuffy = (IHXBuffer*)(new CHXBuffer());
  469.     phxbufBuffy->AddRef();
  470.     phxbufBuffy->SetSize(ulLengthFrom);
  471.     pucBuffy = phxbufBuffy->GetBuffer();
  473.     ulStartIndex = ulFirstStartIndex;
  474.     ulSize = ulSizeFirst;
  475.     ulRemainingLength = ulLengthFrom;
  476.     pfrgCurrent = pfrgFirst;
  477.     while(pfrgCurrent && ulRemainingLength > 0)
  478.     {
  479. _RecursiveBufferCopy
  480. (
  481.     pucBuffy+(ulLengthFrom-ulRemainingLength),
  482.     pfrgCurrent->GetData(),
  483.     ulStartIndex,
  484.     ulSize
  485. );
  487. ulRemainingLength -= ulSize-ulStartIndex;
  489. pfrgCurrent = pfrgCurrent->Next();
  491. if (pfrgCurrent)
  492. {
  493.     ulSize = pfrgCurrent->GetData()->GetSize();
  495.     if (ulRemainingLength < ulSize)
  496.     {
  497. ulSize = ulRemainingLength;
  498.     }
  499. }
  501. ulStartIndex = 0;
  502.     }
  503.     
  504.     Replace(phxbufBuffy, 0, ulLengthFrom, ulStartFrom);
  506.     /* This forces the correct offset below..
  507.      */
  508.     ulFirstStartIndex = 0;
  509. }
  510.     }
  512.     if(phxbufBuffy)
  513.     {
  514. phxbufBuffy->Get(pData, ulLength);
  515.     
  516. pData = pData+ulFirstStartIndex;
  517. ulLength = ulLengthFrom;
  518.     }
  520.     HX_RELEASE(phxbufBuffy);
  522.     return HXR_OK;
  523. }
  525. void 
  526. CHXFragmentedBuffer::_RecursiveBufferCopy
  527. (
  528.     UCHAR* pucDestBuffer,
  529.     IHXBuffer* pbufSource,
  530.     UINT32 ulStartIndex,
  531.     UINT32 ulSize
  532. )
  533. {
  534.     IHXFragmentedBuffer* pfgbufCurrent = NULL;
  536.     /* Optimized by directly enumerating nested 
  537.      * fragmented buffers.
  538.      * (instead of "pfrgCurrent->GetData()->GetBuffer()")
  539.      */
  540.     if (!(pbufSource->QueryInterface(IID_IHXFragmentedBuffer, (void**)&pfgbufCurrent)) || pfgbufCurrent)
  541.     {
  542. IHXEnumFragmentedBuffer* pefbCurrent = NULL;
  543. IHXBuffer* pbufCurrent = NULL;
  544. UINT32 ulSizeCurrent=0;
  545. UINT32 ulCopied=0;
  546. UINT32 ulTotal=0;
  548. pfgbufCurrent->GetEnumerator(&pefbCurrent);
  550. pefbCurrent->Reset();
  552. while(!(pefbCurrent->Next(1, &pbufCurrent, NULL)) && ulSize>0)
  553. {
  554.     ulSizeCurrent =  pbufCurrent->GetSize();
  555.     
  556.     if ((ulTotal+ulSizeCurrent) < ulStartIndex)
  557.     {
  558. ulTotal += ulSizeCurrent;
  559.     }
  560.     else
  561.     {
  562. _RecursiveBufferCopy
  563. (
  564.     pucDestBuffer+ulCopied,
  565.     pbufCurrent,
  566.     ulStartIndex-ulTotal,
  567.     min(ulSize, ulSizeCurrent)
  568. );
  570. ulSize -= ulSizeCurrent;
  571. ulCopied += ulSizeCurrent;
  572. ulStartIndex = 0;
  573. ulTotal=0;
  574.     }
  576.     HX_RELEASE(pbufCurrent);
  577. }
  579. HX_RELEASE(pefbCurrent);
  580. HX_RELEASE(pfgbufCurrent);
  581.     }
  582.     else
  583.     {
  584. memcpy /* Flawfinder: ignore */
  585. (
  586.     pucDestBuffer, 
  587.     pbufSource->GetBuffer()+ulStartIndex, 
  588.     HX_SAFESIZE_T(ulSize-ulStartIndex)
  589. );
  590.     }
  591. }
  593. STDMETHODIMP_(UCHAR*) 
  594. CHXFragmentedBuffer::GetBuffer(UINT32 ulStartFrom, UINT32 ulLengthFrom)
  595. {
  596.     UCHAR* pData;
  597.     UINT32 ulLength;
  599.     /* Gather from start to start+length
  600.      */
  601.     Get(ulStartFrom, ulLengthFrom, pData, ulLength);
  603.     return pData;
  604. }
  607. /* IHXBuffer Methods
  608.  */ 
  610. /* XXX I am not doing memcopies into existing space as I cannot guarantee write access.
  611.  * An acceptable Optimization is to try to memcopy, and fragment only if that fails.
  612.  */
  613. STDMETHODIMP 
  614. CHXFragmentedBuffer::Set(const UCHAR* pData, ULONG32 ulLength)
  615. {
  616.     /* Need to make an empty Buffer sizeof ulLength
  617.      */
  618.     IHXBuffer* phxbufTemp = (IHXBuffer*)(new CHXBuffer());
  620.     phxbufTemp->AddRef();
  621.     phxbufTemp->SetSize(ulLength);
  622.     phxbufTemp->Set(pData, ulLength);
  623.     
  624.     Replace(phxbufTemp, 0, ulLength, 0);
  626.     HX_RELEASE(phxbufTemp);
  628.     return HXR_OK;
  629. }
  631. STDMETHODIMP 
  632. CHXFragmentedBuffer::Get(REF(UCHAR*) pData, REF(ULONG32) ulLength)
  633. {
  634.     return Get(0,UINT32(-1), pData, ulLength);
  635. }
  637. /* adds/removes fragment(s) to the end to set the size to the requested length
  638.  */
  639. STDMETHODIMP 
  640. CHXFragmentedBuffer::SetSize(ULONG32 ulLength)
  641. {
  642.     UINT32 ulSize;
  644.     ulSize = GetSize();
  645.     
  646.     if (ulLength > ulSize)
  647.     {
  648. /* The existing buffers are not big enough
  649.  * Need to make an empty Buffer sizeof ulLength-GetSize()
  650.  */
  651. IHXBuffer* phxbufTemp = (IHXBuffer*)(new CHXBuffer());
  652. _CFragment* pfrgNew;
  654. phxbufTemp->AddRef();
  655. phxbufTemp->SetSize(ulLength-ulSize);
  657. pfrgNew = new _CFragment();
  658. pfrgNew->SetData(phxbufTemp);
  660. m_frglstThis.Append(pfrgNew);
  662. HX_RELEASE(phxbufTemp);
  663.     }
  664.     else if (ulLength < ulSize)
  665.     {
  666. _CFragment* pfrgFirst;
  667. _CFragment* pfrgCurrent;
  668. _CFragment* pfrgTmp;
  669. UINT32 ulTotalFirst=0, ulSizeFirst=0;
  671. /* Find First affected fragment
  672.  */
  673. _FindFragment(ulLength, pfrgFirst, ulSizeFirst, ulTotalFirst);
  675. if(pfrgFirst)
  676. {
  677.     IHXBuffer* phxbufBuffy;
  679.     pfrgCurrent = pfrgFirst->Next();
  681.     phxbufBuffy = pfrgFirst->GetData();
  682.     phxbufBuffy->AddRef();
  684.     if(ulLength-ulTotalFirst > 0)
  685.     {
  686. /* Reset existing fragment to contain first part of phxbufBuffy
  687.  */
  688. pfrgFirst->SetData(phxbufBuffy, 0, ulLength-ulTotalFirst);
  689.     }
  690.     else
  691.     {
  692. m_frglstThis.Remove(pfrgFirst);
  693.     }
  695.     HX_RELEASE(phxbufBuffy);
  697.     /* Remove the truncated items.
  698.      */
  699.     while(pfrgCurrent)
  700.     {
  701. pfrgTmp = pfrgCurrent;
  702. pfrgCurrent = pfrgCurrent->Next();
  703. m_frglstThis.Remove(pfrgTmp);
  704.     }
  705. }
  706.     }
  708.     return HXR_OK;
  709. }
  711. /* returns the sum of all the fragments sizes
  712.  */
  713. STDMETHODIMP_(ULONG32) 
  714. CHXFragmentedBuffer::GetSize()
  715. {
  716.     _CFragment* pfrgCurrent;
  717.     UINT32 ulTotal = 0;
  719.     pfrgCurrent = m_frglstThis.First();
  721.     while (pfrgCurrent)
  722.     {
  723. ulTotal += pfrgCurrent->GetData()->GetSize();
  725. pfrgCurrent = pfrgCurrent->Next();
  726.     }
  728.     return ulTotal;
  729. }
  731. STDMETHODIMP_(UCHAR*) 
  732. CHXFragmentedBuffer::GetBuffer()
  733. {
  734.     return GetBuffer(0,UINT32(-1));
  735. }
  737. CHXFragmentedBuffer::_CFragment* 
  738. CHXFragmentedBuffer::_CFragment::SetData(IHXBuffer* pData)
  739. {
  740.     HX_RELEASE(m_pData); 
  741.     m_pData=pData; 
  742.     m_pData->AddRef(); 
  743.     return this;
  744. }
  746. CHXFragmentedBuffer::_CFragment* 
  747. CHXFragmentedBuffer::_CFragment::SetData(IHXBuffer* pData, UINT32 ulStartFrom, UINT32 ulLengthFrom)
  748. {
  749.     HX_RELEASE(m_pData); 
  750.     
  751.     if(!ulStartFrom && ulLengthFrom >= pData->GetSize())
  752.     {
  753. /* Use whole Buffer
  754.  */
  755. m_pData=pData;
  756.         m_pData->AddRef();
  757.     }
  758.     else
  759.     {
  760. /* Use Part of Buffer
  761.  */
  762. (
  763.     _CBufferFragment::CreateObject()
  764. )
  765. ->_SetBuffer
  766. (
  767.     pData, 
  768.     ulStartFrom, 
  769.     ulLengthFrom
  770. )
  771. ->QueryInterface
  772. (
  773.     IID_IHXBuffer,
  774.     (void**)&m_pData
  775. );
  776.     }
  778.     return this;
  779. }
  781. CHXFragmentedBuffer::_CFragment* 
  782. CHXFragmentedBuffer::_CFragment::Insert(_CFragment* pNewPrev)
  783. {
  784.     if(pNewPrev == m_pPrev)
  785.     {
  786. return this;
  787.     }
  789.     if(m_pPrev)
  790.     {
  791. m_pPrev->_SetNext(pNewPrev);
  792.     }
  794.     if(pNewPrev)
  795.     {
  796. pNewPrev->_SetNext(this);
  797. pNewPrev->_SetPrev(m_pPrev);
  798.     }
  800.     _SetPrev(pNewPrev);
  802.     return pNewPrev;
  803. }
  805. CHXFragmentedBuffer::_CFragment* 
  806. CHXFragmentedBuffer::_CFragment::Append(_CFragment* pNewNext)
  807. {
  808.     if(pNewNext == m_pNext)
  809.     {
  810. return this;
  811.     }
  813.     if(m_pNext)
  814.     {
  815. m_pNext->_SetPrev(pNewNext);
  816.     }
  818.     if(pNewNext)
  819.     {
  820. pNewNext->_SetPrev(this);
  821. pNewNext->_SetNext(m_pNext);
  822.     }
  824.     _SetNext(pNewNext);
  825.     
  826.     return pNewNext;
  827. }
  829. CHXFragmentedBuffer::_CFragment* 
  830. CHXFragmentedBuffer::_CFragment::Remove()
  831. {
  832.     _CFragment* pfrgRet;
  833.     
  834.     if(m_pNext)
  835.     {
  836. pfrgRet = m_pNext;
  837.     }
  838.     else 
  839.     {
  840. pfrgRet = m_pPrev;
  841.     }
  842.     
  843.     delete this;
  845.     return pfrgRet;
  846. }
  848. void 
  849. CHXFragmentedBuffer::_CFragmentList::Remove(_CFragment* pfrgObsolete)
  850. {
  851.     if(pfrgObsolete)
  852.     {
  853. if (pfrgObsolete == m_pfrgListEnd)
  854. {
  855.     m_pfrgListEnd = pfrgObsolete->Prev();
  856. }
  857. if (pfrgObsolete == m_pfrgListStart)
  858. {
  859.     m_pfrgListStart = pfrgObsolete->Next();
  860. }
  862. pfrgObsolete->Remove();
  863.         --m_ulTotal;
  864.     }
  865. }
  867. void 
  868. CHXFragmentedBuffer::_CFragmentList::Insert(_CFragment* pfrgNew, _CFragment* pfrgRelative)
  869. {
  870.     if (!pfrgNew)
  871.     {
  872. return;
  873.     }
  875.     if(pfrgRelative)
  876.     {
  877. pfrgRelative->Insert(pfrgNew);
  879. if (pfrgRelative == m_pfrgListStart)
  880. {
  881.     m_pfrgListStart = pfrgNew;
  882. }
  883.     }
  884.     else if (m_pfrgListStart)
  885.     {
  886. m_pfrgListStart->Insert(pfrgNew);
  887. m_pfrgListStart = pfrgNew;
  888.     }
  889.     else
  890.     {
  891. m_pfrgListStart = m_pfrgListEnd = pfrgNew;
  892.     }
  894.     ++m_ulTotal;
  895. }
  897. void 
  898. CHXFragmentedBuffer::_CFragmentList::Append(_CFragment* pfrgNew, _CFragment* pfrgRelative)
  899. {
  900.     if (!pfrgNew)
  901.     {
  902. return;
  903.     }
  905.     if(pfrgRelative)
  906.     {
  907. pfrgRelative->Append(pfrgNew);
  909. if (pfrgRelative == m_pfrgListEnd)
  910. {
  911.     m_pfrgListEnd = pfrgNew;
  912. }
  913.     }
  914.     else if (m_pfrgListEnd)
  915.     {
  916. m_pfrgListEnd->Append(pfrgNew);
  917. m_pfrgListEnd = pfrgNew;
  918.     }
  919.     else
  920.     {
  921. m_pfrgListStart = m_pfrgListEnd = pfrgNew;
  922.     }
  924.     ++m_ulTotal;
  925. }
  927. _CBufferFragment* 
  928. _CBufferFragment::_SetBuffer(IHXBuffer* pData, UINT32 ulStart, UINT32 ulLength)
  929. {
  930.     HX_RELEASE(m_pData); 
  932.     m_pData = pData; 
  933.     
  934.     if(m_pData)
  935.     {
  936. m_pData->AddRef();
  938. m_ulStart=ulStart;
  940. if(m_pData->GetSize()-ulStart < ulLength)
  941. {
  942.     m_ulLength=m_pData->GetSize()-ulStart;
  943. }
  944. else
  945. {
  946.     m_ulLength=ulLength;
  947. }
  948.     }
  949.     else
  950.     {
  951. m_ulStart=0;
  952. m_ulLength=0;
  953.     }
  955.     return this;
  956. }
  958. STDMETHODIMP 
  959. _CBufferFragment::Set(const UCHAR* pData, UINT32 ulLength)
  960. {
  961.     if(!m_pData)
  962.     {
  963. return HXR_UNEXPECTED;
  964.     }
  966.     return m_pData->Set(pData+m_ulStart, ulLength);
  967. }
  969. STDMETHODIMP
  970. _CBufferFragment::Get(REF(UCHAR*) pData, REF(UINT32) ulLength)
  971. {
  972.     if(!m_pData)
  973.     {
  974. return HXR_UNEXPECTED;
  975.     }
  977.     if(ulLength > m_ulLength)
  978.     {
  979. return HXR_INVALID_PARAMETER;
  980.     }
  982.     pData = GetBuffer();
  983.     ulLength = GetSize();
  984.     
  985.     return HXR_OK;
  986. }
  988. STDMETHODIMP
  989. _CBufferFragment::SetSize(UINT32 ulLength)
  990. {
  991.     HX_RESULT hxrRet = HXR_FAIL;
  993.     if(!m_pData)
  994.     {
  995. /* Make New Buffer
  996.  */
  997. m_pData = (IHXBuffer*)(new CHXBuffer());
  998. m_pData->AddRef();
  999. m_ulStart = 0;
  1000.     }
  1001.     
  1002.     hxrRet = m_pData->SetSize(ulLength+m_ulStart);
  1003.     m_ulLength = ulLength;
  1004.     
  1005.     return hxrRet;
  1006. }
  1008. STDMETHODIMP_(UINT32)
  1009. _CBufferFragment::GetSize()
  1010. {
  1011.     if(!m_pData)
  1012.     {
  1013. return 0;
  1014.     }
  1016.     return min(m_pData->GetSize()-m_ulStart, m_ulLength);
  1017. }
  1019. STDMETHODIMP_(UCHAR*)
  1020. _CBufferFragment::GetBuffer()
  1021. {
  1022.     if(!m_pData)
  1023.     {
  1024. return NULL;
  1025.     }
  1027.     return m_pData->GetBuffer()?m_pData->GetBuffer()+m_ulStart:NULL;
  1028. }