3gppttstructs.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,345 行 · 第 1/3 页

{
    m_ulHighlightEndTime = ReadUL32(pData);
    m_uiStartCharOffset = ReadUI16(pData); 
    m_uiEndCharOffset = ReadUI16(pData);
    return HXR_OK;
}

HX_RESULT C3GPPTextContainer::BuildKROK(const UINT8*& pData, 
                                        UINT16& uiLowestPotentialNextTCStartOffsetFound,
                                        BOOL& bNeedToBreakTCsUpAtNewlines,
                                        UINT16& curEndCharOffset)
{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK()\n"));
    HX_ASSERT(!m_pTextKaraokeBox);
 
    m_pTextKaraokeBox = new C3GPPTextKaraokeBox();
    if(!m_pTextKaraokeBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextKaraokeBox->Build(pData);
    if(SUCCEEDED(hr))
    {
        BOOL bAssignBoxToCurrent = FALSE;
        m_uiTextKaraokeBoxIndex = HX_3GPPTT_INVALID_INDEX;
        // /Go through the array of C3GPPTextKaraokeControlEntry(s)
        // & look at their m_uiStartCharOffset & m_uiEndCharOffset.
        // If all are fully before or fully after, ignore the
        // whole enchilada:

        UINT16 uiEntryCount = m_pTextKaraokeBox->GetEntryCount();
        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): %u entries\n", uiEntryCount));
        for (UINT16 uiCurEntry = 0; uiCurEntry < uiEntryCount; uiCurEntry++)
        {
            const C3GPPTextKaraokeBox::C3GPPTextKaraokeControlEntry*
                    pCurKaraokeCtrlEntry =
                    m_pTextKaraokeBox->GetKaraokeControlEntry(uiCurEntry);
            HX_ASSERT(pCurKaraokeCtrlEntry);
            if (pCurKaraokeCtrlEntry)
            {
                UINT16 uiCurStartCharOffset =
                        pCurKaraokeCtrlEntry->GetStartOffset();
                curEndCharOffset =
                        pCurKaraokeCtrlEntry->GetEndOffset();
                DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): range %u, %u\n", uiCurStartCharOffset, curEndCharOffset));
                if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
                        uiCurStartCharOffset, curEndCharOffset,
                        /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
                        /*REF OUT*/ bAssignBoxToCurrent) )
                {
                    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): discarding entry %u \n", uiCurEntry));
                    continue; // /Ignore this entry; bad data.
                }
                if (bAssignBoxToCurrent)
                {
                    m_uiTextKaraokeBoxIndex = uiCurEntry;
                    break;
                }
            }
        }
        if (HX_3GPPTT_INVALID_INDEX == m_uiTextKaraokeBoxIndex)
        {
            // /All Karaoke control entries are before or after,
            // so ignore this entire karaoke modifier:
            HX_DELETE(m_pTextKaraokeBox);
        }
        bNeedToBreakTCsUpAtNewlines = TRUE;

    }
    else
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextKaraokeBox);
    }


    return hr;
}


HX_RESULT C3GPPTextContainer::BuildDLAY(const UINT8*& pData)
{        
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildDLAY()\n"));
    HX_ASSERT(!m_pTextScrollDelayBox);

    m_pTextScrollDelayBox = new C3GPPTextScrollDelayBox();
    if(!m_pTextScrollDelayBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextScrollDelayBox->Build(pData);
    if(FAILED(hr))
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextScrollDelayBox);
    }
    return hr;
    
}

HX_RESULT C3GPPTextContainer::BuildHCLR(const UINT8*& pData)
{        
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHCLR()\n"));
    HX_ASSERT(!m_pTextHilightColorBox);

    m_pTextHilightColorBox = new C3GPPTextHilightColorBox();
    if(!m_pTextHilightColorBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextHilightColorBox->Build(pData);
    if(FAILED(hr))
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextHilightColorBox);
    }
    return hr;
}

HX_RESULT C3GPPTextContainer::BuildTBOX(const UINT8*& pData)
{        
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildTBOX(): text box\n"));
    HX_ASSERT(!m_pTextboxBox);

    m_pTextboxBox = new C3GPPTextboxBox();
    if(!m_pTextboxBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextboxBox->Build(pData);
    if(FAILED(hr))
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextboxBox);
    }
    return hr;
}
  
HX_RESULT C3GPPTextContainer::BuildHLIT(const UINT8*& pData, 
                                        UINT16& uiLowestPotentialNextTCStartOffsetFound,
                                        BOOL& bNeedToBreakTCsUpAtNewlines,
                                        UINT16& curEndCharOffset)
{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT()\n"));
    HX_ASSERT(!m_pTextHighlightBox);
 
    m_pTextHighlightBox = new C3GPPTextHighlightBox();
    if(!m_pTextHighlightBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextHighlightBox->Build(pData);
    if(SUCCEEDED(hr))
    {
        BOOL bAssignBoxToCurrent = FALSE;
        UINT16 uiCurStartCharOffset = m_pTextHighlightBox->GetStartOffset();
        curEndCharOffset = m_pTextHighlightBox->GetEndOffset();

        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT(): range %u, %u\n", uiCurStartCharOffset, curEndCharOffset));

        // /If data is bad or if this is out of range, then
        // this hlit box is not this's modifier:
        if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
                uiCurStartCharOffset, curEndCharOffset,
                /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
                /*REF OUT*/ bAssignBoxToCurrent)
                // /FALSE means this is out of box's range:
                || !bAssignBoxToCurrent)
        {
            DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT(): discarding\n"));
            HX_DELETE(m_pTextHighlightBox);
        }
        
        bNeedToBreakTCsUpAtNewlines = TRUE;
    }
    else
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextBlinkBox);
    }

    return hr;
}



HX_RESULT C3GPPTextContainer::BuildHREF(const UINT8*& pData, 
                                        UINT16& uiLowestPotentialNextTCStartOffsetFound,
                                        BOOL& bNeedToBreakTCsUpAtNewlines,
                                        UINT16& curEndCharOffset)
{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF()\n"));
    HX_ASSERT(!m_pTextHyperTextBox);

    m_pTextHyperTextBox = new C3GPPTextHyperTextBox();
    if(!m_pTextHyperTextBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextHyperTextBox->Build(pData);
    if(SUCCEEDED(hr))
    {
        BOOL bAssignBoxToCurrent = FALSE;
        UINT16 uiCurStartCharOffset = m_pTextHyperTextBox->GetStartOffset();
        curEndCharOffset = m_pTextHyperTextBox->GetEndOffset();
            
        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF(): range %u, %u\n", uiCurStartCharOffset, curEndCharOffset));

        // /If data is bad or if this is out of range, then
        // this hlit box is not this's modifier:
        if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
                uiCurStartCharOffset, curEndCharOffset,
                /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
                /*REF OUT */ bAssignBoxToCurrent)
                // /FALSE means this is out of box's range:
                || !bAssignBoxToCurrent)
        {
            DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF(): discarding\n"));
            HX_DELETE(m_pTextHyperTextBox);
        }
        
        bNeedToBreakTCsUpAtNewlines = TRUE;
    }
    else
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextHyperTextBox);
    }

    return hr;
}


HX_RESULT C3GPPTextContainer::BuildBLNK(const UINT8*& pData, 
                                        UINT16& uiLowestPotentialNextTCStartOffsetFound,
                                        BOOL& bNeedToBreakTCsUpAtNewlines,
                                        UINT16& curEndCharOffset)

{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK()\n"));
    HX_ASSERT(!m_pTextBlinkBox);

    m_pTextBlinkBox = new C3GPPTextBlinkBox();
    if(!m_pTextBlinkBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextBlinkBox->Build(pData);
    if(SUCCEEDED(hr))
    {
        BOOL bAssignBoxToCurrent = FALSE;
        UINT16 uiCurStartCharOffset = m_pTextBlinkBox->GetStartOffset();
        curEndCharOffset = m_pTextBlinkBox->GetEndOffset();

        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK(): range %u, %u\n", uiCurStartCharOffset, curEndCharOffset));

        // /If data is bad or if this is out of range, then
        // this hlit box is not this's modifier:
        if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
                uiCurStartCharOffset, curEndCharOffset,
                /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
                /*REF OUT */ bAssignBoxToCurrent)
                // /FALSE means this is out of box's range:
                || !bAssignBoxToCurrent)
        {
            DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK(): discarding\n"));
            HX_DELETE(m_pTextBlinkBox);
        }
        
        bNeedToBreakTCsUpAtNewlines = TRUE;
    }
    else
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextBlinkBox);
    }

    return hr;
}

HX_RESULT C3GPPTextContainer::BuildSTYL(const UINT8*& pData, 
                                        UINT16& uiLowestPotentialNextTCStartOffsetFound,
                                        BOOL& bNeedToBreakTCsUpAtNewlines,
                                        UINT16& curEndCharOffset)
{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL()\n"));
    HX_ASSERT(!m_pTextStyleBox);

    m_pTextStyleBox = new C3GPPTextStyleBox();
    if(!m_pTextStyleBox)
    {
        return HXR_OUTOFMEMORY;
    }

    HX_RESULT hr = m_pTextStyleBox->Build(pData);
    if(SUCCEEDED(hr))
    {
        BOOL bAssignBoxToCurrent = FALSE;
        m_uiTextStyleBoxIndex = HX_3GPPTT_INVALID_INDEX;

        // /Go through the array of C3GPPStyleRecords and look
        // at their m_uiStartCharOffset and m_uiEndCharOffset.
        // If all are fully before or fully after, ignore the
        // whole shebang:
        UINT16 uiEntryCount = m_pTextStyleBox->GetEntryCount();
        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): %u entries\n", uiEntryCount));

        for (UINT16 uiCurEntry = 0; uiCurEntry < uiEntryCount; uiCurEntry++)
        {
            const C3GPPStyleRecord* pCurStyleRecord =
                    m_pTextStyleBox->GetStyleRecord(uiCurEntry);
            HX_ASSERT(pCurStyleRecord);
            if (pCurStyleRecord)
            {
                UINT16 uiCurStartCharOffset = pCurStyleRecord->GetStartOffset();
                curEndCharOffset = pCurStyleRecord->GetEndOffset();

                DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): [entry %u] range %u, %u\n", uiCurEntry, uiCurStartCharOffset, curEndCharOffset));


                if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
                        uiCurStartCharOffset, curEndCharOffset,
                        /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
                        /*REF OUT*/ bAssignBoxToCurrent) )
                {
                    // ignore, bad data
                    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): discarding\n"));
                    continue;
                }
                if (bAssignBoxToCurrent)
                {
                    m_uiTextStyleBoxIndex = uiCurEntry;
                    break;
                }
            }
        }
     
    
        if (HX_3GPPTT_INVALID_INDEX == m_uiTextStyleBoxIndex)
        {
            // /All style records are before or after, so
            // ignore entire style modifier:
            HX_DELETE(m_pTextStyleBox);
        }
        bNeedToBreakTCsUpAtNewlines = TRUE;
    }
    else
    {
        HX_ASSERT(false);
        HX_DELETE(m_pTextStyleBox);
    }


    return hr;
}

HX_RESULT C3GPPTextContainer::BuildSampleModifiers(BOOL& bNeedToBreakTCsUpAtNewlines)
{
    DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSampleModifiers()\n"));

    bNeedToBreakTCsUpAtNewlines = FALSE;

    HX_ASSERT(m_pTextSample);
    if (!m_pTextSample->GetModifierData())
    {
        // no modifiers; no work to do
        DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSampleModifiers(): no sample modifiers\n"));

        return HXR_OK;
    }
            
    HX_RESULT hr = HXR_OK;

    // /Walk the sampleModifier array and find the next start-
    // index boundary that is greater than m_uiStartCharOffset;
    // What we find, if any, is 1 + our end index:
    UINT16 uiLowestPotentialNextTCStartOffsetFound =
            HX_3GPPTT_MAX_CHAR_OFFSET;

    UINT16 curEndCharOffset = HX_3GPPTT_INVALID_INDEX;
    
    const UINT8* pData = m_pTextSample->GetModifierData();
    HX_ASSERT(m_pTextSample->GetModifierDataSize() > 0);
    const UINT8* pDataEnd = pData + m_pTextSample->GetModifierDataSize();

    while (pData < pDataEnd)
    {
        // get sample modifier type and size
        C3GPPTextSampleModifierBox box;
        
        hr = box.Build(pData);
        HX_ASSERT(HXR_OK == hr);

        if(pData + box.GetDataSize() > pDataEnd)
        {
            HX_ASSERT(false);
            hr = HXR_FAIL;
            break;
        }

        // create sample modifier object for this modifier type
        switch(box.GetType())
        {
        case C3GPPTextSampleModifierBox::STYL:
            hr = BuildSTYL(pData, 
                uiLowestPotentialNextTCStartOffsetFound, 
                bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
            break;
        case C3GPPTextSampleModifierBox::HLIT:
             hr = BuildHLIT(pData, 
                uiLowestPotentialNextTCStartOffsetFound, 
                bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
            break;
        case C3GPPTextSampleModifierBox::HCLR:
            hr = BuildHCLR(pData);
            break;
        case C3GPPTextSampleModifierBox::KROK:
            hr = BuildKROK(pData, 
                uiLowestPotentialNextTCStartOffsetFound, 
                bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
            break;
        case C3GPPTextSampleModifierBox::DLAY:
            hr = BuildDLAY(pData);
            break;
        case C3GPPTextSampleModifierBox::HREF:
            hr = BuildHREF(pData, 
                uiLowestPotentialNextTCStartOffsetFound,
                bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
            break;
        case C3GPPTextSampleModifierBox::TBOX:
            hr = BuildTBOX(pData);
            break;
        case C3GPPTextSampleModifierBox::BLNK:
            hr = BuildBLNK(pData, 
                uiLowestPotentialNextTCStartOffsetFound, 
                bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
            break;
        default:
            HX_ASSERT(false); //XXXLCM skip unknown types?
            hr = HXR_FAIL;
            break;
        }