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

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

Symbian

开发平台：

Visual C++

mp4desc.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 _ATTEMPT_ALTERNATE_PARSING_MODES
  40. #define _ATTEMPT_PREOCR_SYNTAX
  41. #define _ALLOW_SHORT_SLCONFIG
  42. #define _SHORTCUT_ON_DECCONFIG
  45. /****************************************************************************
  46.  *  Includes
  47.  */
  48. #include "mp4desc.h"
  49. #include "netbyte.h"
  52. /****************************************************************************
  53.  *  Statics
  54.  */
  55. inline static int swapEndian(UCHAR* pInOut, UINT32 ulLen)
  56. {
  57.     UINT32 i = 0, j = 0;
  58.     UCHAR c;
  60.     for (j = ulLen-1; i < ulLen/2; ++i, --j)
  61.     {
  62.         c = pInOut[i];
  63.         pInOut[i] = pInOut[j];
  64.         pInOut[j] = c;
  65.     }
  67.     return 0;
  68. }
  70. inline static ULONG32 GetUL32(UINT8 *pData)
  71. {
  72.     return (*pData << 24) |
  73.    (*(pData + 1) << 16) |
  74.    (*(pData + 2) << 8 ) |
  75.    *(pData + 3);
  76. }
  78. inline static UINT16 GetUI16(UINT8 *pData)
  79. {
  80.     return (*pData << 8) |
  81.     *(pData + 1);
  82. }
  84. inline static ULONG32 GetUI24(UINT8 *pData)
  85. {
  86.     return  (*pData << 16) |
  87.     (*(pData + 1) << 8) |
  88.     *(pData + 2);
  89. }
  91. inline static ULONG32 RoundUp(double x)
  92. {
  93.     ULONG32 rx = (ULONG32) x;
  94.     
  95.     if (rx != x)
  96.     {
  97. rx++;
  98.     }
  99.     
  100.     return rx;
  101. }
  104. /****************************************************************************
  105.  *  MP4BaseDescriptor
  106.  */
  107. /****************************************************************************
  108.  *  Public functions
  109.  */
  110. MP4BaseDescriptor::DescType MP4BaseDescriptor::GetDescType(UINT8 uTag)
  111. {
  112.     DescType eDescType = DTYP_UNKNOWN;
  113.     
  114.     if (uTag == 0x03)
  115.     {
  116. eDescType = DTYP_ESTREAM;
  117.     }
  118.     else if (uTag == 0x04)
  119.     {
  120. eDescType = DTYP_DECODER_CONFIG;
  121.     }
  122.     else if (uTag == 0x05)
  123.     {
  124. eDescType = DTYP_DECODER_INFO_SHORT;
  125.     }
  126.     else if (uTag == 0x06)
  127.     {
  128. eDescType = DTYP_SL_CONFIG;
  129.     }
  130.     
  131.     return eDescType;
  132. }
  134. /****************************************************************************
  135.  *  Protected functions
  136.  */
  137. UINT8 MP4BaseDescriptor::GetTag(UINT8* &pData, 
  138. ULONG32 &ulDataSize,
  139. BOOL bAdvance)
  140. {
  141.     UINT8 uTag;
  142.     ULONG32 ulTagSize = 0;
  143.     
  144.     uTag = pData[ulTagSize];
  145.     ulTagSize++;
  146.         
  147.     if (bAdvance)
  148.     {
  149. pData += ulTagSize;
  150. ulDataSize -= ulTagSize;
  151.     }
  152.     
  153.     return uTag;
  154. }
  157. ULONG32 MP4BaseDescriptor::GetSize(UINT8* &pData, 
  158.    ULONG32 &ulDataSize,
  159.    BOOL bAdvance)
  160. {
  161.     ULONG32 ulSize = 0;
  162.     ULONG32 ulFieldSize = 0;
  164.     while (ulDataSize > ulFieldSize)
  165.     {
  166. ulSize = (ulSize << 7);
  167. ulSize += (pData[ulFieldSize] & 0x7f);
  168. if ((pData[ulFieldSize] & 0x80) == 0)
  169. {
  170.     ulFieldSize++;
  171.     break;
  172. }
  173. ulFieldSize++;
  174.     }
  175.     
  176.     if (bAdvance)
  177.     {
  178. pData += ulFieldSize;
  179. ulDataSize -= ulFieldSize;
  180.     }
  181.     
  182.     return ulSize;
  183. }
  186. /****************************************************************************
  187.  *  SLConfigPredefined
  188.  */
  189. /****************************************************************************
  190.  *  Constructor/Destructor
  191.  */
  194. /****************************************************************************
  195.  *  Public functions
  196.  */
  197. HX_RESULT SLConfigPredefined::Unpack(UINT8* &pData, 
  198.      ULONG32 &ulSize,
  199.      ULONG32 ulFlags)
  200. {
  201.     LD bitInfo;
  202.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  203.     
  204.     if (ulSize >= 14)
  205.     {
  206. retVal = HXR_OK;
  208. initbuffer(pData, &bitInfo);
  210. m_bUseAccessUnitStartFlag = getbits1(&bitInfo);
  211. m_bUseAccessUnitEndFlag = getbits1(&bitInfo);
  212. m_bUseRandomAccessPointFlag = getbits1(&bitInfo);
  213. m_bUsePaddingFlag = getbits1(&bitInfo);
  214. m_bUseTimeStampsFlag = getbits1(&bitInfo);
  215. m_bUseWallClockTimeStampFlag = getbits1(&bitInfo);
  216. m_bUseIdleFlag = getbits1(&bitInfo);
  217. m_bDurationFlag = getbits1(&bitInfo);
  219. pData++;
  221. m_ulTimeStampResolution = GetUL32(pData);
  222. pData += 4;
  223. m_ulOCRResolution = GetUL32(pData);
  224. pData += 4;
  226. m_uTimeStampLength = *(pData++);
  227. m_uOCRLength = *(pData++);
  228. m_AU_Length = *(pData++);
  229. m_uInstantBitrateLength = *(pData++);
  231. initbuffer(pData, &bitInfo);
  232. m_uDegradationPriorityLength = getbits(4, &bitInfo);
  233. m_uSeqNumLength = getbits(4, &bitInfo);
  234. pData++;
  236. ulSize -= 14;
  237.     }
  238.     
  239.     if ((retVal == HXR_OK) && 
  240. m_bDurationFlag)
  241.     {
  242. retVal = HXR_INVALID_PARAMETER;
  244. if (ulSize >= 8)
  245. {
  246.     m_ulTimeScale = GetUL32(pData);
  247.     pData += 4;
  248.     m_uAccessUnitDuration = GetUI16(pData);
  249.     pData += 2;
  250.     m_uCompositionUnitDuration = GetUI16(pData);
  251.     pData += 2;
  253.     ulSize -= 8;
  254. }
  255.     }
  257.     if ((retVal == HXR_OK) &&
  258. (!m_bUseTimeStampsFlag))
  259.     {
  260. retVal = HXR_INVALID_PARAMETER;
  261. ULONG32 ulSegmentSize = RoundUp(8.0 + m_uTimeStampLength / 4.0);
  263. m_ullStartDecodingTimeStamp = 0;
  264. m_ullStartCompositionTimeStamp = 0;
  266. if ((m_uTimeStampLength < 64) &&
  267.     (ulSize >= ulSegmentSize) &&
  268.     (sizeof(double) == 8))
  269. {     
  270.     memcpy(&m_dWallClockTimeStamp, pData, 8); /* Flawfinder: ignore */
  271.     if (!TestBigEndian())
  272.     {
  273. swapEndian((UINT8*) &m_dWallClockTimeStamp, 8);
  274.     }
  276.     // initialization of m_ullStartDecodingTimeStamp
  277.     // and m_ullStartCompositionTimeStamp needed
  278.     HX_ASSERT(HXR_OK == HXR_NOTIMPL);
  280.     pData += ulSegmentSize;
  281.     ulSize -= ulSegmentSize;
  283.     retVal = HXR_NOTIMPL;
  284. }
  285.     }
  287.     return retVal;
  288. }
  291. /****************************************************************************
  292.  *  SLConfigDescriptor
  293.  */
  294. /****************************************************************************
  295.  *  Constructor/Destructor
  296.  */
  297. SLConfigDescriptor::SLConfigDescriptor(void)
  298.     : m_uLength(0)
  299.     , m_pPredefined(NULL)
  300.     , m_bOCRstreamFlag(FALSE)
  301. {
  302.     ;
  303. }
  305. SLConfigDescriptor::~SLConfigDescriptor()
  306. {
  307.     HX_DELETE(m_pPredefined);
  308. }
  310. /****************************************************************************
  311.  *  Public functions
  312.  */
  313. HX_RESULT SLConfigDescriptor::Unpack(UINT8* &pData, 
  314.      ULONG32 &ulSize,
  315.      ULONG32 ulFlags)
  316. {
  317.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  318.     
  319.     if (ulSize >= 3)
  320.     {
  321. m_uTag = GetTag(pData, ulSize, TRUE);
  322. retVal = HXR_OK;
  323.     }
  324.     
  325.     if (retVal == HXR_OK)
  326.     {
  327. retVal = HXR_INVALID_PARAMETER;
  329. if (ulSize >= 2)
  330. {
  331.     m_uLength = (UINT8) GetSize(pData, ulSize, TRUE);
  333.     if (ulSize >= 1)
  334.     {
  335. m_uPredefined = *(pData++);
  337. ulSize--;
  339. retVal = HXR_OK;
  340.     }
  341. }
  342.     }
  344.     if ((retVal == HXR_OK) &&
  345. (m_uPredefined == 0))
  346.     {
  347. retVal = HXR_OUTOFMEMORY;
  348. m_pPredefined = new SLConfigPredefined;
  350. if (m_pPredefined)
  351. {
  352.     retVal = m_pPredefined->Unpack(pData, ulSize);
  353. }
  354.     }
  356.     if (retVal == HXR_OK)
  357.     {
  358. #ifndef _ALLOW_SHORT_SLCONFIG
  359. retVal = HXR_INVALID_PARAMETER;
  360. #endif // _ALLOW_SHORT_SLCONFIG
  362. if (ulSize >= 1)
  363. {
  364.     m_bOCRstreamFlag = ((((*pData) >> 7) & 0x01) == 1);
  365.     m_uReserved = ((*(pData++)) & 0x7F);
  366.     ulSize--;
  368.     retVal = HXR_OK;
  369. }
  370.     }
  372.     if ((retVal == HXR_OK) &&
  373. (m_bOCRstreamFlag))
  374.     {
  375. retVal = HXR_INVALID_PARAMETER;
  377. if (ulSize >= 2)
  378. {
  379.     m_OCR_ES_Id = GetUI16(pData);
  380.     pData += 2;
  381.     ulSize -= 2;
  383.     retVal = HXR_OK;
  384. }
  385.     }
  387.     return retVal;
  388. }
  389.     
  391. /****************************************************************************
  392.  *  DecoderSpecifcInfo
  393.  */
  394. /****************************************************************************
  395.  *  Constructor/Destructor
  396.  */
  397. DecoderSpecifcInfo::DecoderSpecifcInfo(void)
  398.     : m_ulLength(0)
  399.     , m_pData(NULL)
  400. {
  401.     ;
  402. }
  404. DecoderSpecifcInfo::~DecoderSpecifcInfo()
  405. {
  406.     HX_DELETE(m_pData);
  407. }
  409. /****************************************************************************
  410.  *  Public functions
  411.  */
  412. HX_RESULT DecoderSpecifcInfo::Unpack(UINT8* &pData, 
  413.      ULONG32 &ulSize,
  414.      ULONG32 ulFlags)
  415. {
  416.     ULONG32 ulTagSize = 1;
  417.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  419.     m_ulFlags = ulFlags;
  420.     
  421.     if (ulSize >= 1)
  422.     {
  423. m_uTag = GetTag(pData, ulSize, TRUE);
  424. retVal = HXR_OK;
  425.     }
  426.     
  427.     if (retVal == HXR_OK)
  428.     {
  429. switch (GetDescType(m_uTag))
  430. {
  431. case DTYP_DECODER_INFO_SHORT:
  432.     m_ulLength = GetSize(pData, ulSize, TRUE);
  433.     break;
  434. default:
  435.     retVal = HXR_INVALID_PARAMETER;
  436.     break;
  437. }
  438.     }
  440.     if ((ulFlags & SIZE_HEADER_INCLUSIVE) && (retVal == HXR_OK))
  441.     {
  442. if (m_ulLength > 2)
  443. {
  444.     m_ulLength -= 2;
  445. }
  446.     }
  448.     if ((retVal == HXR_OK) &&
  449. (m_ulLength > 0))
  450.     {
  451. retVal = HXR_INVALID_PARAMETER;
  453. if (ulSize >= m_ulLength)
  454. {
  455.     m_pData = new UINT8 [m_ulLength];
  457.     retVal = HXR_OUTOFMEMORY;
  458.     if (m_pData)
  459.     {
  460. memcpy(m_pData, pData, m_ulLength); /* Flawfinder: ignore */
  461. pData += m_ulLength;
  462. ulSize -= m_ulLength;
  463. retVal = HXR_OK;
  464.     }
  465. }
  466.     }
  468.     return retVal;
  469. }
  472. /****************************************************************************
  473.  *  DecoderConfigDescriptor
  474.  */
  475. /****************************************************************************
  476.  *  Constructor/Destructor
  477.  */
  478. DecoderConfigDescriptor::DecoderConfigDescriptor(void)
  479.     : m_uLength(0)
  480.     , m_pDecSpecificInfo(NULL)
  481. {
  482.     ;
  483. }
  485. DecoderConfigDescriptor::~DecoderConfigDescriptor()
  486. {
  487.     HX_DELETE(m_pDecSpecificInfo);
  488. }
  490. /****************************************************************************
  491.  *  Public functions
  492.  */
  493. HX_RESULT DecoderConfigDescriptor::Unpack(UINT8* &pData, 
  494.   ULONG32 &ulSize,
  495.   ULONG32 ulFlags)
  496. {
  497.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  498.     
  499.     m_ulFlags = ulFlags;
  501.     if (ulSize >= 15)
  502.     {
  503. m_uTag = GetTag(pData, ulSize, TRUE);
  504. retVal = HXR_OK;
  505.     }
  506.     
  507.     if (retVal == HXR_OK)
  508.     {
  509. retVal = HXR_INVALID_PARAMETER;
  511. if (ulSize >= 14)
  512. {
  513.     m_uLength = (UINT8) GetSize(pData, ulSize, TRUE);
  515.     if (ulSize >= 13)
  516.     {
  517. m_uObjectProfileIndication = *(pData++);
  518. m_uStreamType = ((*pData) >> 2);
  519. m_bUpStream = (((*pData) >> 1) & 0x01);
  520. m_bReservedBit = ((*pData) & 0x01);
  521. pData++;
  522. m_ulBufferSizeDB = GetUI24(pData);
  523. pData += 3;
  524. m_ulMaxBitrate = GetUL32(pData);
  525. pData += 4;
  526. m_ulAvgBitrate = GetUL32(pData);
  527. pData += 4;
  529. ulSize -= 13;
  531. retVal = HXR_OK;
  532.     }
  533. }
  534.     }
  536.     if (retVal == HXR_OK)
  537.     {
  538. if (ulSize > 0)
  539. {
  540.     UINT8 uTag = GetTag(pData, ulSize);
  542.     if (GetDescType(uTag) == DTYP_DECODER_INFO_SHORT)
  543.     {
  544. m_pDecSpecificInfo = new DecoderSpecifcInfo;
  545.     
  546. retVal = HXR_OUTOFMEMORY;
  547. if (m_pDecSpecificInfo)
  548. {
  549.     retVal = m_pDecSpecificInfo->Unpack(pData, 
  550. ulSize, 
  551. ulFlags);
  552. }
  553.     }
  554. }
  555.     }
  557.     return retVal;
  558. }
  559.     
  561. /****************************************************************************
  562.  *  ES_Descriptor
  563.  */
  564. /****************************************************************************
  565.  *  Constructor/Destructor
  566.  */
  567. ES_Descriptor::ES_Descriptor(void)
  568.     : m_uLength(0)
  569.     , m_pURLString(NULL)
  570.     , m_pExtDescrArray(NULL)
  571.     , m_pLangDescr(NULL)
  572.     , m_pDecConfigDescr(NULL)
  573.     , m_pSLConfigDescr(NULL)
  574.     , m_pIPIPtr(NULL)
  575.     , m_pIPIDS(NULL)
  576.     , m_pQOSDescr(NULL)
  577. {
  578.     ;
  579. }
  581. ES_Descriptor::~ES_Descriptor(void)
  582. {
  583.     HX_VECTOR_DELETE(m_pURLString);
  584.     HX_DELETE(m_pExtDescrArray);
  585.     HX_DELETE(m_pLangDescr);
  586.     HX_DELETE(m_pDecConfigDescr);
  587.     HX_DELETE(m_pSLConfigDescr);
  588.     HX_DELETE(m_pIPIPtr);
  589.     HX_DELETE(m_pIPIDS);
  590.     HX_DELETE(m_pQOSDescr);
  591. }
  594. /****************************************************************************
  595.  *  Public functions
  596.  */
  597. HX_RESULT ES_Descriptor::Unpack(UINT8* &pData, 
  598. ULONG32 &ulSize,
  599. ULONG32 ulFlags)
  600. {
  601.     LD bitInfo;
  602.     UINT8 uTag;
  603.     UINT8* pPreOCRData = NULL;
  604.     ULONG32 ulPreOCRSize = 0;
  605.     UINT8* pLastData = NULL;
  606.     ULONG32 ulLastSize = 0;
  607.     ULONG32 ulStartSize = ulSize;
  608.     BOOL bAlternateParseMode = FALSE;
  609.     BOOL bAttemptPreOCRSyntax = FALSE;
  610.     HX_RESULT retVal = HXR_INVALID_PARAMETER;
  611.     
  612.     m_ulFlags = ulFlags;
  614.     if (ulSize >= 5)
  615.     {
  616. m_uTag = GetTag(pData, ulSize, TRUE);
  617. retVal = HXR_OK;
  618.     }
  619.     
  620.     if (retVal == HXR_OK)
  621.     {
  622. retVal = HXR_INVALID_PARAMETER;
  623. if (ulSize >= 4)
  624. {   
  625.     m_uLength = (UINT16) GetSize(pData, ulSize, TRUE);
  626.     
  627.     if (ulSize >= 3)
  628.     {
  629. m_uESid = GetUI16(pData);
  630. pData += 2;
  631.     
  632. initbuffer(pData, &bitInfo);
  633. m_bStreamDependenceFlag = getbits1(&bitInfo);
  634. m_bURLflag = getbits1(&bitInfo);
  635. m_bOCRStreamFlag = (getbits1(&bitInfo) != 0);
  636. m_uStreamPriority = (UINT8) getbits(5, &bitInfo);
  637. pData++;
  638.     
  639. ulSize -= 3;
  641. retVal = HXR_OK;
  642.     }
  643. }
  644.     }
  645.     
  646.     if (retVal == HXR_OK)
  647.     {
  648. if (m_bStreamDependenceFlag)
  649. {
  650.     retVal = HXR_INVALID_PARAMETER;
  651.     if (ulSize >= 2)
  652.     {
  653. retVal = HXR_OK;
  655. m_uDependsOn_ES_ID = GetUI16(pData);
  656. pData += 2;
  658. ulSize -= 2;
  659.     }
  660. }
  661.     }
  662.     
  663.     if (retVal == HXR_OK)
  664.     {
  665. if (m_bURLflag)
  666. {
  667.     retVal = HXR_INVALID_PARAMETER;
  668.     if (ulSize >= 1)
  669.     {
  670. ULONG32 ulURLLength = pData[0];
  671. pData++;
  672. ulSize--;
  674. if (ulSize >= ulURLLength)
  675. {
  676.     m_pURLString = new UINT8 [ulURLLength + 1];
  677.     
  678.     retVal = HXR_OUTOFMEMORY;
  679.     if (m_pURLString)
  680.     {
  681. retVal = HXR_OK;
  682.     }
  683.     
  684.     if (retVal == HXR_OK)
  685.     {
  686. memcpy(m_pURLString, pData, ulURLLength); /* Flawfinder: ignore */
  687. m_pURLString[ulURLLength] = '';
  689. pData += ulURLLength;
  690. ulSize -= ulURLLength;
  691.     }
  692. }
  693.     }
  694. }
  695.     }
  696.     
  697.     do
  698.     {
  699. bAttemptPreOCRSyntax = FALSE;
  701. if (retVal == HXR_OK)
  702. {
  703.     if (m_bOCRStreamFlag)
  704.     {
  705. pPreOCRData = pData;
  706. ulPreOCRSize = ulSize;
  708. retVal = HXR_INVALID_PARAMETER;
  709. if (ulSize >= 2)
  710. {
  711.     retVal = HXR_OK;
  712.     
  713.     m_uOCR_ES_ID = GetUI16(pData);
  714.     pData += 2;
  715.     
  716.     ulSize -= 2;
  717. }
  718.     }
  719. }
  721. while ((retVal == HXR_OK) &&
  722.     (ulSize > 0))
  723. {
  724.     uTag = GetTag(pData, ulSize);
  725.     
  726.     switch (GetDescType(uTag))
  727.     {
  728.     case DTYP_DECODER_CONFIG:     
  729. pLastData = pData;
  730. ulLastSize = ulSize;
  732. HX_DELETE(m_pDecConfigDescr);
  733. m_pDecConfigDescr = new DecoderConfigDescriptor;
  734. if (bAlternateParseMode)
  735. {
  736.     m_ulFlags |= SIZE_HEADER_INCLUSIVE;
  737. }
  738. retVal = m_pDecConfigDescr->Unpack(pData, 
  739.     ulSize, 
  740.     m_ulFlags);
  741. #ifdef _SHORTCUT_ON_DECCONFIG
  742. if (SUCCEEDED(retVal))
  743. {
  744.     ulSize = 0;
  745. }
  746. #endif // _SHORTCUT_ON_DECCONFIG
  747. break;
  749.     case DTYP_SL_CONFIG:
  750. HX_DELETE(m_pSLConfigDescr);
  751. m_pSLConfigDescr = new SLConfigDescriptor;
  752. retVal = m_pSLConfigDescr->Unpack(pData, ulSize);
  753. break;
  755.     default:
  756. retVal = HXR_INVALID_PARAMETER;
  757. break;
  758.     }
  759.     
  760. #ifdef _ATTEMPT_ALTERNATE_PARSING_MODES
  761.     if (FAILED(retVal) &&
  762. pLastData &&
  763. (!bAlternateParseMode))
  764.     {
  765. bAlternateParseMode = TRUE;
  766. pData = pLastData;
  767. ulSize = ulLastSize;
  768. pLastData = NULL;
  769. ulLastSize = 0;
  770. retVal = HXR_OK;
  771.     }
  772. #endif // _ATTEMPT_ALTERNATE_PARSING_MODES
  773. }
  775. if (FAILED(retVal) && m_bOCRStreamFlag && pPreOCRData)
  776. {
  777. #ifdef _ATTEMPT_PREOCR_SYNTAX
  778.     // OCR was introduced later - after Phillips produced its files
  779.     // and thus some older files have OCR flag and no OCR_ES_ID
  780.     // since previously the OCR flag bit was considered reserved and
  781.     // had no meaning.
  782.     pData = pPreOCRData;
  783.     ulSize = ulPreOCRSize;
  784.     m_bOCRStreamFlag = FALSE;
  785.     bAttemptPreOCRSyntax = TRUE;
  786.     retVal = HXR_OK;
  787. #endif // _ATTEMPT_PREOCR_SYNTAX
  788. }
  789.     } while (bAttemptPreOCRSyntax);
  790.     
  791.     if (SUCCEEDED(retVal))
  792.     {
  793. if ((ulStartSize - ulSize) == m_uLength)
  794. {
  795.     m_ulFlags |= SIZE_HEADER_INCLUSIVE;
  796. }
  797.     }
  799.     return retVal;
  800. }