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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
atomizer.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：28k
源码类别：

Symbian

开发平台：

Visual C++

atomizer.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. /****************************************************************************
  37.  *  Defines
  38.  */
  39. #define ATMZR_SEEK_RELATIVE  TRUE
  40. #define ATMZR_SEEK_ABSOLUTE  FALSE
  42. #define ATMZR_MAX_RECURSION_LEVEL   20
  43. #ifdef HELIX_FEATURE_MIN_HEAP
  44. #define ATMZR_PAGING_THRESHOLD     0x00000400 // 1K
  45. #else // HELIX_FEATURE_MIN_HEAP
  46. #define ATMZR_PAGING_THRESHOLD     0x0000FFFF // 64K
  47. #endif // HELIX_FEATURE_MIN_HEAP
  49. #define ATMZR_MAX_FILE_SIZE     0xFFFFFFFF
  52. /****************************************************************************
  53.  *  Includes
  54.  */
  55. #include "atomizer.h"
  56. #include "qtatoms.h"
  57. #include "mempager.h"
  58. #include "qtffrefcounter.h"
  61. /****************************************************************************
  62.  *  Data Types
  63.  */
  64. struct QTHeader
  65. {
  66.     UINT8 pSize[4];
  67.     UINT8 pType[4];
  68. };
  70. struct QTNewHeader
  71. {
  72.     UINT8 pSize[4];
  73.     UINT8 pType[4];
  74.     UINT8 pAtomID[4];
  75.     UINT8 pRsvd1[2];
  76.     UINT8 pChildCount[2];
  77.     UINT8 pRsvd2[4];
  78. };
  81. /****************************************************************************
  82.  *  Class CAtomizer
  83.  */
  84. /****************************************************************************
  85.  *  Constructor/Destructor
  86.  */
  87. CAtomizer::CAtomizer(void)
  88.     : m_pFileSwitcher(NULL)
  89.     , m_pResponse(NULL)
  90.     , m_pCommander(NULL)
  91.     , m_pScheduler(NULL)
  92.     , m_pRoot(NULL)
  93.     , m_pCurrentRoot(NULL)
  94.     , m_pNewAtom(NULL)
  95.     , m_ulStartOffset(0)
  96.     , m_ulFinalOffset(0)
  97.     , m_ulCurrentOffset(0)
  98.     , m_ulNewAtomOffset(0)
  99.     , m_ulNewAtomDataSize(0)
  100.     , m_AtomType(0)
  101.     , m_ulTotalSize(0)
  102.     , m_State(ATMZR_Offline)
  103.     , m_bSyncAccessEnabled(FALSE)
  104.     , m_bPreferLinearAccess(FALSE)
  105.     , m_pRecursionCallback(NULL)
  106.     , m_ulRecursionCount(0)
  107.     , m_lRefCount(0)
  108. {
  109.     g_nRefCount_qtff++;
  110. }
  113. CAtomizer::~CAtomizer()
  114. {
  115.     Close();
  116.     g_nRefCount_qtff--;
  117. }
  120. /****************************************************************************
  121.  *  Main Interface
  122.  */
  123. /****************************************************************************
  124.  *  Init
  125.  */
  126. HX_RESULT CAtomizer::Init(IUnknown *pSource,
  127.   IUnknown *pResponse,
  128.   IUnknown *pCommander)
  129. {
  130.     HX_RESULT retVal;
  132.     if ((m_State != ATMZR_Offline) &&
  133. (m_State != ATMZR_Ready))
  134.     {
  135. return HXR_UNEXPECTED;
  136.     }
  138.     HX_ASSERT(pSource);
  139.     HX_ASSERT(pResponse);
  141.     // Reset
  142.     HX_RELEASE(m_pFileSwitcher);
  143.     HX_RELEASE(m_pResponse);
  144.     HX_RELEASE(m_pCommander);
  145.     HX_RELEASE(m_pRoot);
  146.     HX_RELEASE(m_pNewAtom);
  147.     HX_RELEASE(m_pRecursionCallback);
  148.     m_ulCurrentOffset = 0;
  149.     m_ulRecursionCount = 0;
  151.     // Find Input Interface
  152.     retVal = pSource->QueryInterface(IID_IHXFileSwitcher, (void**) &m_pFileSwitcher);
  154.     // Find out if syncrhonous use of input is possible
  155.     if (SUCCEEDED(retVal))
  156.     {
  157. if (SUCCEEDED(m_pFileSwitcher->Advise(HX_FILEADVISE_SYNCACCESS)))
  158. {
  159.     m_bSyncAccessEnabled = TRUE;
  160.     m_pFileSwitcher->Advise(HX_FILEADVISE_ASYNCACCESS);
  161. }
  163. HX_RESULT adviseRes = 
  164.     m_pFileSwitcher->Advise(HX_FILEADVISE_RANDOMACCESS);
  166. if (HXR_ADVISE_PREFER_LINEAR == adviseRes)
  167. {
  168.     m_bPreferLinearAccess = TRUE;
  169. }
  170.     }
  172.     // Find Output Interface
  173.     if (SUCCEEDED(retVal))
  174.     {
  175. retVal = pResponse->QueryInterface(IID_IHXAtomizerResponse, (void**) &m_pResponse);
  176.     }
  178.     // Find Scheduler Interface
  179.     if (SUCCEEDED(retVal))
  180.     {
  181. retVal = pResponse->QueryInterface(IID_IHXScheduler, (void **) &m_pScheduler);
  183. if (FAILED(retVal))
  184. {
  185.     retVal = pSource->QueryInterface(IID_IHXScheduler, (void **) &m_pScheduler);
  186. }
  187.     }
  189.     // See if the Atomization Commander is given
  190.     if (SUCCEEDED(retVal))
  191.     {
  192. if (pCommander)
  193. {
  194.     pCommander->QueryInterface(IID_IHXAtomizationCommander, (void**) &m_pCommander);
  195. }
  197. if (!m_pCommander)
  198. {
  199.     // No commander given, Atomizer will command itself
  200.     m_pCommander = (IHXAtomizationCommander *) this;
  201.     m_pCommander->AddRef();
  202. }
  204. m_State = ATMZR_Ready;
  205.     }
  207.     // Allocate Recursion breaker callback
  208. #ifdef QTCONFIG_RECURSION_PROTECTION
  209.     if (SUCCEEDED(retVal))
  210.     {
  211. m_pRecursionCallback = new CRecursionCallback(this);
  212. if (m_pRecursionCallback)
  213. {
  214.     m_pRecursionCallback->AddRef();
  215. }
  216. else
  217. {
  218.     retVal = HXR_OUTOFMEMORY;
  219. }
  220.     }
  221. #endif // QTCONFIG_RECURSION_PROTECTION
  223.     return retVal;
  224. }
  227. /****************************************************************************
  228.  *  Close
  229.  */
  230. void CAtomizer::Close(void)
  231. {
  232.     m_State = ATMZR_Offline;
  234.     HX_RELEASE(m_pFileSwitcher);
  235.     HX_RELEASE(m_pResponse);
  236.     HX_RELEASE(m_pCommander);
  237.     HX_RELEASE(m_pScheduler);
  238.     HX_RELEASE(m_pRoot);
  239.     HX_RELEASE(m_pNewAtom);
  240.     HX_RELEASE(m_pRecursionCallback);
  241. }
  244. /****************************************************************************
  245.  *  Atomize
  246.  */
  247. HX_RESULT CAtomizer::Atomize(ULONG32 ulOffset, ULONG32 ulSize)
  248. {
  249.     if (m_State != ATMZR_Ready)
  250.     {
  251. return HXR_UNEXPECTED;
  252.     }
  254.     if ((m_pFileSwitcher == NULL) ||
  255. (m_pResponse == NULL) ||
  256. (m_pCommander == NULL))
  257.     {
  258. return HXR_FAIL;
  259.     }
  261.     // Reset
  262.     HX_RELEASE(m_pRoot);
  263.     HX_RELEASE(m_pNewAtom);
  264.     m_ulCurrentOffset = 0;
  266.     // Take on parameters
  267.     m_ulStartOffset = ulOffset;
  268.     m_ulNewAtomOffset = ulOffset;
  269.     m_ulTotalSize = ulSize;
  270.     m_ulFinalOffset = (m_ulTotalSize == ATOMIZE_ALL) ? ATOMIZE_ALL : m_ulStartOffset + m_ulTotalSize;
  272.     // Prepare the root
  273.     m_pRoot = new CQTRootAtom();
  274.     if (m_pRoot == NULL)
  275.     {
  276. return HXR_OUTOFMEMORY;
  277.     }
  278.     m_pRoot->AddRef();
  280.     m_pRoot->SetSize(m_ulTotalSize);
  281.     m_pRoot->SetOffset(m_ulStartOffset);
  282.     m_pCurrentRoot = m_pRoot;
  284.     // Start of the atomization process
  285.     m_State = ATMZR_ProcHeader;
  286.     SeekDataCB(m_ulStartOffset);
  288.     return HXR_OK;
  289. }
  292. /****************************************************************************
  293.  *  Private Methods
  294.  */
  295. /****************************************************************************
  296.  *  SeekData
  297.  */
  298. HX_RESULT CAtomizer::SeekData(ULONG32 ulOffset, BOOL bRelative)
  299. {
  300.     if (m_State == ATMZR_Offline)
  301.     {
  302. return HXR_UNEXPECTED;
  303.     }
  305.     if (bRelative)
  306.     {
  307. m_ulCurrentOffset += ulOffset;
  308.     }
  309.     else
  310.     {
  311. m_ulCurrentOffset = ulOffset;
  312.     }
  314.     if (IsOffsetInRange(m_ulCurrentOffset))
  315.     {
  316. HX_RESULT retVal;
  318. // Initiate the Seek
  319. retVal = m_pFileSwitcher->Seek( ulOffset,
  320. bRelative,
  321. (IHXFileResponse *) this);
  323. if (FAILED(retVal))
  324. {
  325.     CompleteAtomization(retVal);
  326. }
  327.     }
  328.     else
  329.     {
  330. CompleteAtomization(HXR_OK);
  331.     }
  333.     return HXR_ABORT;
  334. }
  337. /****************************************************************************
  338.  *  ReadData
  339.  */
  340. HX_RESULT CAtomizer::ReadData(ULONG32 ulSize)
  341. {
  342.     HX_RESULT retVal = HXR_OK;
  344.     if (m_State == ATMZR_Offline)
  345.     {
  346. return HXR_UNEXPECTED;
  347.     }
  349.     if (m_State == ATMZR_ProcHeader)
  350.     {
  351. retVal = AdjustCurrentRoot();
  353. if (FAILED(retVal))
  354. {
  355.     if (retVal == HXR_CHUNK_MISSING)
  356.     {
  357. // udta Atom terminator encountered, must skip over the
  358. // terminator chunk
  359. m_ulNewAtomOffset = m_ulCurrentOffset +
  360.     QT_UDTA_TERMINATOR_LENGTH;
  361. return SeekDataCB(m_ulNewAtomOffset);
  362.     }
  363.     else
  364.     {
  365. CompleteAtomization(retVal);
  367. return HXR_ABORT;
  368.     }
  369. }
  370.     }
  372.     m_ulCurrentOffset += ulSize;
  374.     if (IsOffsetInRange(m_ulCurrentOffset - 1))
  375.     {
  376. HX_RESULT retVal;
  378. // Initiate the Read
  379. retVal = m_pFileSwitcher->Read( ulSize,
  380. (IHXFileResponse *) this);
  382. if (SUCCEEDED(retVal))
  383. {
  384.     return retVal;
  385. }
  386.     }
  388.     CompleteAtomization(retVal);
  390.     return HXR_ABORT;
  391. }
  394. /****************************************************************************
  395.  *  ReadDataCB
  396.  */
  397. HX_RESULT CAtomizer::ReadDataCB(ULONG32 ulSize)
  398. {
  399. #ifdef QTCONFIG_RECURSION_PROTECTION
  400.     if (m_ulRecursionCount < ATMZR_MAX_RECURSION_LEVEL)
  401.     {
  402. m_ulRecursionCount++;
  403. return ReadData(ulSize);
  404.     }
  405.     else
  406.     {
  407. CallbackHandle retVal;
  409. m_ulRecursionCount = 0;
  410. m_ulSize = ulSize;
  411. m_CallbackStep = ATMZR_CBSTEP_Read;
  412. retVal = m_pScheduler->RelativeEnter(m_pRecursionCallback, 0);
  413. if (!retVal)
  414. {
  415.     CompleteAtomization(HXR_FAIL);
  416. }
  418. return HXR_OK;
  419.     }
  420. #else // QTCONFIG_RECURSION_PROTECTION
  421.     return ReadData(ulSize);
  422. #endif // QTCONFIG_RECURSION_PROTECTION
  423. }
  426. /****************************************************************************
  427.  *  SeekDataCB
  428.  */
  429. HX_RESULT CAtomizer::SeekDataCB(ULONG32 ulOffset, BOOL bRelative)
  430. {
  431. #ifdef QTCONFIG_RECURSION_PROTECTION
  432.     if (m_ulRecursionCount < ATMZR_MAX_RECURSION_LEVEL)
  433.     {
  434. m_ulRecursionCount++;
  435. return SeekData(ulOffset, bRelative);
  436.     }
  437.     else
  438.     {
  439. CallbackHandle retVal;
  441. m_ulRecursionCount = 0;
  442. m_ulSize = ulOffset;
  443. m_bRelative = bRelative;
  444. m_CallbackStep = ATMZR_CBSTEP_Seek;
  445. retVal = m_pScheduler->RelativeEnter(m_pRecursionCallback, 0);
  446. if (!retVal)
  447. {
  448.     CompleteAtomization(HXR_FAIL);
  449. }
  451. return HXR_OK;
  452.     }
  453. #else // QTCONFIG_RECURSION_PROTECTION
  454.     return SeekData(ulOffset, bRelative);
  455. #endif // QTCONFIG_RECURSION_PROTECTION
  456. }
  459. /****************************************************************************
  460.  *  AdjustCurrentRoot
  461.  */
  462. HX_RESULT CAtomizer::AdjustCurrentRoot(void)
  463. {
  464.     CQTAtom *pRootParent;
  466.     HX_ASSERT(m_pCurrentRoot);
  468.     while ((m_pCurrentRoot->GetSize() != ATOMIZE_ALL) &&
  469.    ((m_pCurrentRoot->GetOffset() +
  470.      m_pCurrentRoot->GetSize() -
  471.      m_ulNewAtomOffset) <
  472.     QT_HEADER_SIZE))
  473.     {
  474. if (m_ulNewAtomOffset ==
  475.     (m_pCurrentRoot->GetOffset() + m_pCurrentRoot->GetSize()))
  476. {
  477.     // Current Atom is completed, move to the parent
  478.     pRootParent = m_pCurrentRoot->GetParent();
  480.     if (pRootParent)
  481.     {
  482. m_pCurrentRoot = pRootParent;
  483. continue;
  484.     }
  485.     else
  486.     {
  487. // We are at the absolute root
  488. break;
  489.     }
  490. }
  491. else
  492. {
  493.     // Not enough room in current parent to read a header, but
  494.     // still some data left over
  495.     if ((m_pCurrentRoot->GetType() == QT_udta) &&
  496. ((m_ulNewAtomOffset + QT_UDTA_TERMINATOR_LENGTH) ==
  497. (m_pCurrentRoot->GetOffset() + m_pCurrentRoot->GetSize())))
  498.     {
  499. // Legacy udta Atom termination - need to skip over the
  500. // terminator
  501. return HXR_CHUNK_MISSING;
  502.     }
  503.     else
  504.     {
  505. // Data is corrupted
  506. return HXR_PARSE_ERROR;
  507.     }
  508. }
  509.     }
  511.     return HXR_OK;
  512. }
  515. /****************************************************************************
  516.  *  CompleteAtomization
  517.  */
  518. void CAtomizer::CompleteAtomization(HX_RESULT status)
  519. {
  520.     CQTAtom* pRoot;
  522.     if (!m_pRoot)
  523.     {
  524. return;
  525.     }
  527.     if (SUCCEEDED(status))
  528.     {
  529. // Record the amount of data atomized
  530. CQTAtom *pRoot = m_pCurrentRoot;
  532. HX_ASSERT(pRoot);
  534. // If we have the position of where next atom would be,
  535. // compute unspecified atom sizes
  536. if (m_ulNewAtomOffset != ATOMIZE_ALL)
  537. {
  538.     while (pRoot)
  539.     {
  540. if (pRoot->GetSize() == ATOMIZE_ALL)
  541. {
  542.     pRoot->SetSize(m_ulNewAtomOffset - m_ulStartOffset);
  543. }
  545. // Move to the parent
  546. pRoot = pRoot->GetParent();
  547.     }
  549.     m_pRoot->SetSize(m_ulNewAtomOffset - m_ulStartOffset);
  550. }
  552. status = AdjustCurrentRoot();
  553.     }
  555.     if (SUCCEEDED(status))
  556.     {
  557. // See if parsing fully completed
  558. if (((m_ulFinalOffset != ATOMIZE_ALL) &&
  559.      (m_ulFinalOffset != m_ulCurrentOffset)) ||
  560.     (m_pRoot != m_pCurrentRoot))
  561. {
  562.     status = HXR_CORRUPT_FILE;
  563. }
  564.     }
  565.     else
  566.     {
  567. // Data compromizing failure occured during atomization
  568. HX_RELEASE(m_pRoot);
  569.     }
  571.     HX_RELEASE(m_pNewAtom);
  573.     m_State = ATMZR_Ready;
  575.     pRoot = m_pRoot;
  576.     m_pRoot = NULL;
  577.     m_pCurrentRoot = NULL;
  579.     m_pResponse->AtomReady(status, pRoot);
  581.     if (pRoot)
  582.     {
  583. pRoot->Release();
  584.     }
  585. }
  588. /****************************************************************************
  589.  *  IHXFileResponse methods
  590.  */
  591. /////////////////////////////////////////////////////////////////////////
  592. //  Method:
  593. // IHXFileResponse::ReadDone
  594. //  Purpose:
  595. // Notification interface provided by users of the IHXFileObject
  596. // interface. This method is called by the IHXFileObject when the
  597. // last read from the file is complete and a buffer is available.
  598. //
  599. STDMETHODIMP CAtomizer::ReadDone
  600. (
  601.     HX_RESULT status,
  602.     IHXBuffer* pBuffer
  603. )
  604. {
  605.     HX_RESULT retVal = HXR_OK;
  606.     QTAtomType AtomType = 0;
  607.     ULONG32 ulAtomSize = 0;
  608.     UINT8* pData = NULL;
  609.     ULONG32 ulDataLen = 0;
  610.     ULONG32 ulNormalizedLen = 0;
  611.     ULONG32 ulAtomID = 0;
  612.     UINT16 uChildCount = 0;
  613.     BOOL bLoop = FALSE;
  615.     if (SUCCEEDED(status) && (m_State != ATMZR_Offline))
  616.     {
  617. HX_ASSERT(pBuffer);
  619. pBuffer->Get(pData, ulDataLen);
  620. ulNormalizedLen = ulDataLen;
  622. do
  623. {
  624.     bLoop = FALSE;
  626.     switch (m_State)
  627.     {
  628.     case ATMZR_ProcNewHeader:
  629. ulNormalizedLen -= (QT_NEW_HEADER_SIZE - QT_HEADER_SIZE);
  630. {
  631.     QTNewHeader *pHeader = (QTNewHeader *) (pData);
  633.     ulAtomID = CQTAtom::GetUL32(pHeader->pAtomID);
  634.     uChildCount = CQTAtom::GetUI16(pHeader->pChildCount);
  635. }
  636. // drop to case below
  638.     case ATMZR_ProcHeader:
  639. if (ulNormalizedLen == QT_HEADER_SIZE)
  640. {
  641.     QTHeader *pHeader = (QTHeader *) (pData);
  643.     AtomType = CQTAtom::GetUL32(pHeader->pType);
  644.     ulAtomSize = CQTAtom::GetUL32(pHeader->pSize);
  646.     if (AtomType == 0)
  647.     {
  648. if (m_State == ATMZR_ProcHeader)
  649. {
  650.     // Try to interpret this as CQTNewAtom
  651.     m_State = ATMZR_ProcNewHeader;
  652.     SeekDataCB(QT_NEW_HEADER_GAP, ATMZR_SEEK_RELATIVE);
  653.     return retVal;
  654. }
  655. status = HXR_PARSE_ERROR;
  656.     }
  657.     else if (ulAtomSize == 1)
  658.     {
  659. // This must be the Atom with extended size
  660. m_State = ATMZR_ProcExtendedSize;
  661. m_AtomType = AtomType;
  662. ReadDataCB(QT_EXTENDED_SIZE);
  663. return retVal;
  664.     }
  665.     else if (ulAtomSize == 0)
  666.     {
  667. // This Atom extends to the of enclosing container
  668. ulAtomSize = ATOMIZE_ALL;
  669.     }
  671.     // drop to case below;
  672.     m_State = ATMZR_MakeAtom;
  673. }
  674. else
  675. {
  676.     break;
  677. }
  679.     case ATMZR_MakeAtom:
  680. {
  681.     QTAtomizerCmd AtomCmd;
  683.     HX_ASSERT(!m_pNewAtom);
  685.     AtomCmd = m_pCommander->GetAtomCommand( AtomType,
  686.     m_pCurrentRoot);
  688.     if (ulAtomSize == ATOMIZE_ALL)
  689.     {
  690. if (m_pCurrentRoot->GetSize() != ATOMIZE_ALL)
  691. {
  692.     ulAtomSize = m_pCurrentRoot->GetOffset() +
  693.  m_pCurrentRoot->GetSize() -
  694.  m_ulNewAtomOffset;
  696.     HX_ASSERT(ulAtomSize != 0);
  698.     if (ulAtomSize == 0)
  699.     {
  700. status = HXR_PARSE_ERROR;
  701. break;
  702.     }
  703. }
  704.     }
  706.     switch (AtomCmd)
  707.     {
  708.     case ATMZR_CMD_LOAD:
  709.     case ATMZR_CMD_OUTLINE:
  710. m_pNewAtom = CreateQTAtom(  AtomType,
  711.     m_ulNewAtomOffset,
  712.     ulAtomSize,
  713.     NULL, // no parent
  714.     ulAtomID,
  715.     uChildCount);
  717. if (m_pNewAtom != NULL)
  718. {
  719.     if (m_pNewAtom->IsLeafType())
  720.     {
  721. // A Leaf Atom
  722. if (AtomCmd == ATMZR_CMD_LOAD)
  723. {
  724.     m_ulNewAtomDataSize = 0;
  725.     if (ulAtomSize != ATOMIZE_ALL)
  726.     {
  727. m_ulNewAtomDataSize = ulAtomSize - ulDataLen;
  728.     }
  730. #ifndef QTCONFIG_NO_PAGING
  731.     if ((m_ulNewAtomDataSize > ATMZR_PAGING_THRESHOLD)
  732. && m_pNewAtom->IsPagingAtom()
  733. #ifdef QTCONFIG_NO_ASYNC_PAGING
  734. && m_bSyncAccessEnabled
  735. #endif // QTCONFIG_NO_ASYNC_PAGING
  736. && (m_ulNewAtomDataSize != ATOMIZE_ALL)
  737.        )
  738.     {
  739. CMemPager* pMemPager = new CMemPager;
  741. status = HXR_OUTOFMEMORY;
  742. if (pMemPager)
  743. {
  744.     pMemPager->AddRef();
  745.     status = pMemPager->Init(m_pFileSwitcher,
  746.      m_ulCurrentOffset,
  747.      m_ulNewAtomDataSize);
  748.     if (SUCCEEDED(status))
  749.     {
  750. m_pNewAtom->AddRef();
  751. m_State = ATMZR_ProcBody;
  752. m_pNewAtom->SetMemPager(pMemPager);
  753. status = pMemPager->LoadPage((IHXFileResponse*) this);
  754.     }
  756.     pMemPager->Release();
  758.     if (SUCCEEDED(status))
  759.     {
  760. return retVal;
  761.     }
  762. }
  763. // Failure
  764. HX_ASSERT(status != HXR_OK);
  765. break;
  766.     }
  767.     else
  768. #endif // QTCONFIG_NO_PAGING
  769.     if ((m_ulNewAtomDataSize != 0) ||
  770. (ulAtomSize == ATOMIZE_ALL))
  771.     {
  772. // Leaf atom with data
  773. m_pNewAtom->AddRef();
  774. m_State = ATMZR_ProcBody;
  775. if (m_ulNewAtomDataSize != 0)
  776. {
  777.     ReadDataCB(m_ulNewAtomDataSize);
  778.     return retVal;
  779. }
  780. else
  781. {
  782.     ReadDataCB(ATMZR_MAX_FILE_SIZE - m_ulCurrentOffset);
  783.     return retVal;
  784. }
  785.     }
  786.     else
  787.     {
  788. // Leaf atom with no data
  789. m_pCurrentRoot->AddPresentChild(m_pNewAtom);
  790. m_ulNewAtomOffset = m_ulCurrentOffset;
  791. m_pNewAtom = NULL;
  792. m_State = ATMZR_ProcHeader;
  793. ReadDataCB(QT_HEADER_SIZE);
  794.     }
  795. }
  796. else
  797. {
  798.     // We are not to load the data
  799.     // so we are ready to attach the atom shell
  800.     // to the atom tree.
  801.     m_pCurrentRoot->AddPresentChild(m_pNewAtom);
  802.     m_pNewAtom = NULL;
  804.     if (ulAtomSize != ATOMIZE_ALL)
  805.     {
  806. m_ulNewAtomOffset = m_ulCurrentOffset +
  807.     ulAtomSize -
  808.     ulDataLen;
  810. m_State = ATMZR_ProcHeader;
  811. SeekDataCB(m_ulNewAtomOffset);
  812. return retVal;
  813.     }
  815.     // Location of the end of file - unknown
  816.     m_ulNewAtomOffset = ATOMIZE_ALL;
  817. }
  818.     }
  819.     else
  820.     {
  821. // A Non Leaf Atom - has no direct data
  822. m_pCurrentRoot->AddPresentChild(m_pNewAtom);
  824. m_pCurrentRoot = m_pNewAtom;
  825. m_ulNewAtomOffset = m_ulCurrentOffset;
  826. m_pNewAtom = NULL;
  827. m_State = ATMZR_ProcHeader;
  828. ReadDataCB(QT_HEADER_SIZE);
  829. return retVal;
  830.     }
  832.     break;
  833. }
  835. // If we couldn't create the atom, skip it.
  836. // Drop down to case below.
  838.     case ATMZR_CMD_SKIP:
  839. if (ulAtomSize != ATOMIZE_ALL)
  840. {
  841.     m_ulNewAtomOffset = m_ulCurrentOffset +
  842. ulAtomSize -
  843. ulDataLen;
  844.     m_State = ATMZR_ProcHeader;
  846.     /* Check to see if we are trying to skip
  847.      * an mdat atom while using a file object
  848.      * that prefers linear access (ie. HTTP/1.0)
  849.      */
  850.     if (m_bPreferLinearAccess && (QT_mdat == AtomType))
  851.     {
  852. HX_RESULT completionRes = HXR_INVALID_FILE;
  854. if ((m_pCurrentRoot) &&
  855.     (m_pCurrentRoot->FindPresentChild(QT_moov)))
  856. {
  857.     /* We have the moov atom already so
  858.      * this file is likely formatted for 
  859.      * progressive download
  860.      */
  861.     completionRes = HXR_OK;
  862. }
  864. CompleteAtomization(completionRes);
  865.     }
  866.     else
  867.     {
  868. SeekDataCB(m_ulNewAtomOffset);
  869.     }
  870.     return retVal;
  871. }
  872. else
  873. {
  874.     m_ulNewAtomOffset = ATOMIZE_ALL;
  875.     break;
  876. }
  878. // If we couldn't skip the atom, stop.
  879. // Drop to case below
  881.     case ATMZR_CMD_STOP:
  882. break;
  884.     default:
  885. status = HXR_INVALID_PARAMETER;
  886. break;
  887.     }
  888. }
  889. break;
  891.     case ATMZR_ProcExtendedSize:
  892. if (ulNormalizedLen == QT_EXTENDED_SIZE)
  893. {
  894.     AtomType = m_AtomType;
  895.     ulAtomSize = CQTAtom::GetUL32(pData);
  897.     HX_ASSERT(ulAtomSize == 0);
  899.     if (ulAtomSize == 0)
  900.     {
  901. ulAtomSize = CQTAtom::GetUL32(pData + 4);
  902. m_State = ATMZR_MakeAtom;
  903. bLoop = TRUE;
  904.     }
  905.     else
  906.     {
  907. // can't handle atom size beyond 4GB
  908. status = HXR_ABORT;
  909.     }
  910. }
  911. break;
  913.     case ATMZR_ProcBody:
  914. HX_ASSERT(m_pNewAtom);
  916. if (m_ulNewAtomDataSize != ATOMIZE_ALL)
  917. {
  918.     if ((!m_pNewAtom->IsPagingEnabled()) &&
  919. (ulDataLen == m_ulNewAtomDataSize))
  920.     {
  921. HX_ASSERT(pBuffer);
  923. m_pNewAtom->SetBuffer(pBuffer);
  924. m_pCurrentRoot->AddPresentChild(m_pNewAtom);
  925. m_ulNewAtomOffset = m_ulCurrentOffset;
  926. m_pNewAtom->Release();
  927. m_pNewAtom = NULL;
  928. m_State = ATMZR_ProcHeader;
  929. ReadDataCB(QT_HEADER_SIZE);
  930. return retVal;
  931.     }
  932.     else if (m_pNewAtom->IsPagingEnabled() &&
  933.      (ulDataLen != 0))
  934.     {
  935. m_ulCurrentOffset += ulDataLen;
  936. m_pCurrentRoot->AddPresentChild(m_pNewAtom);
  937. HX_ASSERT(m_ulNewAtomDataSize >= ulDataLen);
  938. m_ulNewAtomOffset = m_ulCurrentOffset +
  939.     m_ulNewAtomDataSize -
  940.     ulDataLen;
  941. m_pNewAtom->Release();
  942. m_pNewAtom = NULL;
  943. m_State = ATMZR_ProcHeader;
  944. if (m_ulNewAtomOffset != m_ulCurrentOffset)
  945. {
  946.     SeekDataCB(m_ulNewAtomOffset);
  947. }
  948. else
  949. {
  950.     ReadDataCB(QT_HEADER_SIZE);
  951. }
  952. return retVal;
  953.     }
  954. }
  955. else if (ulDataLen > 0)
  956. {
  957.     // Body extended to the end of file - stop here
  958.     HX_ASSERT(pBuffer);
  960.     m_ulNewAtomDataSize = ulDataLen;
  962.     m_pNewAtom->SetBuffer(pBuffer);
  963.     m_pNewAtom->SetSize(m_ulNewAtomDataSize);
  964.     m_ulNewAtomOffset = m_ulCurrentOffset;
  965.     m_pNewAtom->Release();
  966.     m_pNewAtom = NULL;
  967. }
  969. break;
  971.     default:
  972. status = HXR_FAIL;
  973. retVal = HXR_UNEXPECTED;
  974. break;
  975.     }
  976. } while (bLoop);
  977.     }
  978.     else
  979.     {
  980. // Did not clear for processing
  981. if (m_State == ATMZR_Offline)
  982. {
  983.     return HXR_UNEXPECTED;
  984. }
  985. else
  986. {
  987.     // The read must have failed - complete atomization as is
  988.     status = HXR_OK;
  989. }
  990.     }
  992.     CompleteAtomization(status);
  994.     return retVal;
  995. }
  998. /////////////////////////////////////////////////////////////////////////
  999. //  Method:
  1000. // IHXFileResponse::SeekDone
  1001. //  Purpose:
  1002. // Notification interface provided by users of the IHXFileObject
  1003. // interface. This method is called by the IHXFileObject when the
  1004. // last seek in the file is complete.
  1005. //
  1006. STDMETHODIMP CAtomizer::SeekDone(HX_RESULT status)
  1007. {
  1008.     HX_RESULT retVal = HXR_OK;
  1010.     if (SUCCEEDED(status) && (m_State != ATMZR_Offline))
  1011.     {
  1012. // We seek headers only, so start the read of a header
  1013. switch(m_State)
  1014. {
  1015. case ATMZR_ProcHeader:
  1016.     ReadDataCB(QT_HEADER_SIZE);
  1017.     return retVal;
  1018. case ATMZR_ProcNewHeader:
  1019.     ReadDataCB(QT_NEW_HEADER_SIZE);
  1020.     return retVal;
  1021. default:
  1022.     status = HXR_FAIL;
  1023.     retVal = HXR_UNEXPECTED;
  1024.     break;
  1025. }
  1026.     }
  1027.     else
  1028.     {
  1029. // Did not clear for processing
  1030. if (m_State == ATMZR_Offline)
  1031. {
  1032.     return HXR_UNEXPECTED;
  1033. }
  1034. else
  1035. {
  1036.     // The seek must have failed - complete atomization as is
  1037.     status = HXR_OK;
  1038. }
  1039.     }
  1041.     CompleteAtomization(status);
  1043.     return retVal;
  1044. }
  1047. /****************************************************************************
  1048.  *  IUnknown methods
  1049.  */
  1050. /////////////////////////////////////////////////////////////////////////
  1051. //  Method:
  1052. // IUnknown::QueryInterface
  1053. //
  1054. STDMETHODIMP CAtomizer::QueryInterface(REFIID riid, void** ppvObj)
  1055. {
  1056.     if (IsEqualIID(riid, IID_IHXFileResponse))
  1057.     {
  1058. AddRef();
  1059. *ppvObj = (IHXFileResponse*) this;
  1060. return HXR_OK;
  1061.     }
  1062.     else if (IsEqualIID(riid, IID_IHXAtomizationCommander))
  1063.     {
  1064. AddRef();
  1065. *ppvObj = (IHXAtomizationCommander*) this;
  1066. return HXR_OK;
  1067.     }
  1068.     else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
  1069.     {
  1070. AddRef();
  1071. *ppvObj = (IHXThreadSafeMethods*) this;
  1072. return HXR_OK;
  1073.     }
  1074.     else if (IsEqualIID(riid, IID_IUnknown))
  1075.     {
  1076. AddRef();
  1077. *ppvObj = this;
  1078. return HXR_OK;
  1079.     }
  1081.     *ppvObj = NULL;
  1083.     return HXR_NOINTERFACE;
  1084. }
  1086. /////////////////////////////////////////////////////////////////////////
  1087. //  Method:
  1088. // IUnknown::AddRef
  1089. //
  1090. STDMETHODIMP_(ULONG32) CAtomizer::AddRef()
  1091. {
  1092.     return InterlockedIncrement(&m_lRefCount);
  1093. }
  1095. /////////////////////////////////////////////////////////////////////////
  1096. //  Method:
  1097. // IUnknown::Release
  1098. //
  1099. STDMETHODIMP_(ULONG32) CAtomizer::Release()
  1100. {
  1101.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1102.     {
  1103.         return m_lRefCount;
  1104.     }
  1106.     delete this;
  1107.     return 0;
  1108. }
  1110. ///////////////////////////////////////////////////////////////////////////////
  1111. //  Method:
  1112. // IHXThreadSafeMethods::IsThreadsafe
  1113. //
  1114. //  Purpose:
  1115. // This routine returns threadsafeness information about the file object
  1116. // which is used by the server for improved performance.
  1117. //
  1118. STDMETHODIMP_(UINT32)
  1119. CAtomizer::IsThreadSafe()
  1120. {
  1121.     return HX_THREADSAFE_METHOD_FF_GETPACKET | HX_THREADSAFE_METHOD_FSR_READDONE;
  1122. }
  1125. /****************************************************************************
  1126.  *  Class CAtomizer::RecursionCallback
  1127.  */
  1128. #ifdef QTCONFIG_RECURSION_PROTECTION
  1129. /****************************************************************************
  1130.  *  Constructor/Destructor
  1131.  */
  1132. CAtomizer::CRecursionCallback::CRecursionCallback(CAtomizer *pAtomizer)
  1133.     : m_pAtomizer(pAtomizer)
  1134.     , m_lRefCount(0)
  1135. {
  1136.     HX_ASSERT(m_pAtomizer);
  1137.     m_pAtomizer->AddRef();
  1138. }
  1140. CAtomizer::CRecursionCallback::~CRecursionCallback(void)
  1141. {
  1142.     HX_RELEASE(m_pAtomizer);
  1143. }
  1145. /****************************************************************************
  1146.  *  IHXCallback methods
  1147.  */
  1148. /****************************************************************************
  1149.  *  Func
  1150.  */
  1151. STDMETHODIMP CAtomizer::CRecursionCallback::Func(void)
  1152. {
  1153.     switch (m_pAtomizer->m_CallbackStep)
  1154.     {
  1155.     case ATMZR_CBSTEP_Read:
  1156. m_pAtomizer->ReadData(m_pAtomizer->m_ulSize);
  1157. return HXR_OK;
  1158.     case ATMZR_CBSTEP_Seek:
  1159. m_pAtomizer->SeekData(m_pAtomizer->m_ulSize,
  1160.       m_pAtomizer->m_bRelative);
  1161. return HXR_OK;
  1162.     default:
  1163. // nothing to do
  1164. break;
  1165.     }
  1167.     return HXR_UNEXPECTED;
  1168. }
  1170. /****************************************************************************
  1171.  *  IUnknown methods
  1172.  */
  1173. /////////////////////////////////////////////////////////////////////////
  1174. //  Method:
  1175. // IUnknown::QueryInterface
  1176. //
  1177. STDMETHODIMP CAtomizer::CRecursionCallback::QueryInterface(
  1178.     REFIID riid,
  1179.     void** ppvObj)
  1180. {
  1181.     if (IsEqualIID(riid, IID_IUnknown))
  1182.     {
  1183. AddRef();
  1184. *ppvObj = this;
  1185. return HXR_OK;
  1186.     }
  1187.     else if (IsEqualIID(riid, IID_IHXCallback))
  1188.     {
  1189.         AddRef();
  1190.         *ppvObj = (IHXCallback*)this;
  1191.         return HXR_OK;
  1192.     }
  1194.     *ppvObj = NULL;
  1196.     return HXR_NOINTERFACE;
  1197. }
  1199. /////////////////////////////////////////////////////////////////////////
  1200. //  Method:
  1201. // IUnknown::AddRef
  1202. //
  1203. STDMETHODIMP_(ULONG32) CAtomizer::CRecursionCallback::AddRef()
  1204. {
  1205.     return InterlockedIncrement(&m_lRefCount);
  1206. }
  1208. /////////////////////////////////////////////////////////////////////////
  1209. //  Method:
  1210. // IUnknown::Release
  1211. //
  1212. STDMETHODIMP_(ULONG32) CAtomizer::CRecursionCallback::Release()
  1213. {
  1214.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1215.     {
  1216.         return m_lRefCount;
  1217.     }
  1219.     delete this;
  1220.     return 0;
  1221. }
  1222. #endif // QTCONFIG_RECURSION_PROTECTION