3gppttrenderer.cpp

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

                // /XXXEH- handle possible time-offset!
                pTextContainer->GetNextActivityTime() <= ulTime)
        {
            bForceDraw = TRUE;
        }
    }

    if (bForceDraw)
    {
        UpdateDisplay(ulTime);

        // Draw the new text by damaging the entire area of our data
        HXxRect damageRect = {0, 0, m_size.cx, m_size.cy };
        m_pMISUSSite->DamageRect(damageRect);
        m_pMISUSSite->ForceRedraw();
    }

    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::OnPreSeek                                  ref:  hxrendr.h
 *
 *  This routine is called by the Helix core before a seek is about to occur.
 *  The stream's time value just before the seek, and the time value just
 *  after the seek are provided.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::OnPreSeek(UINT32 ulOldTime, UINT32 ulNewTime)
{
#if defined(XXXEH_DEBUGOUT_DRAW_3GPPTT)
pFile = fopen("c:\\3gppttdrawPos.txt", ulCount?"a+":"w");
if (pFile)
{
    fprintf(pFile, "[OnPreSeek] at %ld\tulNewTime=%lu,\tulOldTime=%lu,\n",
            HX_GET_BETTERTICKCOUNT(), ulOldTime, ulNewTime);
    fclose(pFile);
}
ulCount++;
#endif // /XXXEH_DEBUGOUT_DRAW_3GPPTT.

    m_bInSeekMode   = TRUE;
    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::OnPostSeek                                 ref:  hxrendr.h
 *
 *  This routine is called by the Helix core just after a seek has occured.
 *  The stream's time value just before the seek, and the time value just
 *  after the seek are provided.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::OnPostSeek(UINT32 ulOldTime, UINT32 ulNewTime)
{
#if defined(XXXEH_DEBUGOUT_DRAW_3GPPTT)
pFile = fopen("c:\\3gppttdrawPos.txt", ulCount?"a+":"w");
if (pFile)
{
    fprintf(pFile, "[OnPostSeek] at %ld\tulNewTime=%lu,\tulOldTime=%lu,\n",
            HX_GET_BETTERTICKCOUNT(), ulOldTime, ulNewTime);
    fclose(pFile);
}
ulCount++;
#endif // /XXXEH_DEBUGOUT_DRAW_3GPPTT.

    RecomputeTextContainerDrawList(ulNewTime);

    m_bInSeekMode   = FALSE;
    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::OnPause                                    ref:  hxrendr.h
 *
 *  This routine is called by the Helix core just after a pause has occured.
 *  The stream's time value just before pausing is provided.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::OnPause(UINT32 ulTime)
{
    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::OnBuffering                                ref:  hxrendr.h
 *
 *  This routine is called by the Helix core to inform the Renderer that
 *  buffering of data is occuring. The reason for buffering (e.g. start-up
 *  of stream, seek has occured, network congestion, etc.), as well as the
 *  percentage of the buffering process complete are provided.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::OnBuffering(UINT32 ulFlags, UINT16 unPercentComplete)
{
#if defined(XXXEH_DEBUGOUT_DRAW_3GPPTT)
pFile = fopen("c:\\3gppttdrawPos.txt", ulCount?"a+":"w");
if (pFile)
{
    fprintf(pFile, "[OnBuffering] at %ld\tunPercentComplete=%u",
            HX_GET_BETTERTICKCOUNT(), unPercentComplete);
    fclose(pFile);
}
ulCount++;
#endif // /XXXEH_DEBUGOUT_DRAW_3GPPTT.

    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::OnEndofPackets                             ref:  hxrendr.h
 *
 *  Called by client engine to inform the renderer that all the
 *  packets have been delivered. However, if the user seeks before
 *  EndStream() is called, renderer may start getting packets again
 *  and the client engine will eventually call this function again.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::OnEndofPackets(void)
{
    m_bGotAllPacketsAlready = TRUE;
    return HXR_OK;
}


/****************************************************************************
 *  IHXRenderer::EndStream                                  ref:  hxrendr.h
 *
 *  This routine is called by the Helix core when the rendering of the stream
 *  has completed. Deallocation of any resources should be done here.
 */
STDMETHODIMP
C3GPPTimedTextRenderer::EndStream()
{
    /* Send report of a mouse click to the fileformat if backchannel 
     * is supported
     */
    if (m_pBackChannel && m_pCommonClassFactory && m_pStream)
    {
        IHXPacket* pPacket = 0;
        IHXBuffer* pBuffer = 0;
        char tmpStr[100];
        if ((HXR_OK == m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                               (void**)&pBuffer)) &&
            (HXR_OK == m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
                                               (void**)&pPacket)))
        {
            ::sprintf(tmpStr, "Number of clicks = %lu\n", m_ulNumberOfClicks);

            pBuffer->Set((UCHAR*) tmpStr, ::strlen(tmpStr) + 1);
            pPacket->Set(pBuffer,0,m_pStream->GetStreamNumber(),
                         HX_ASM_SWITCH_ON, 0);
            pBuffer->Release();

            m_pBackChannel->PacketReady(pPacket);

            pPacket->Release();
        }

    }

    // You can't use IHXStream, IHXSourceStream, IHXBackChannel, or
    // IHXASMStream after EndStream has been called.
    HX_RELEASE(m_pStream);
    HX_RELEASE(m_pBackChannel);
    HX_RELEASE(m_pASMStream);

    return HXR_OK;
}


/****************************************************************************
 *  C3GPPTimedTextRenderer::ClearTextContainerLists      ref:  3gppttrender.h
 *
 *  Removes all contents of the list of text packets
 */
void
C3GPPTimedTextRenderer::ClearTextContainerLists(BOOL bDeleteListPtrWhenCleared)
{
    if (m_pTextContainerRedrawList)
    {
        // /We don't need to delete the text containers inside since they are
        // owned by (& will be cleaned up by) the m_pTextContainerList, below:
        m_pTextContainerRedrawList->RemoveAll();
    }

    if (m_pTextContainerList)
    {
        LISTPOSITION pos = m_pTextContainerList->GetHeadPosition();
        while (pos)
        {
            C3GPPTextContainer* pTextContainer =
                    (C3GPPTextContainer*)m_pTextContainerList->GetNext(pos);
            HX_ASSERT(pTextContainer);
            if (pTextContainer)
            {
                HX_DELETE(pTextContainer);
            }
        }
        m_pTextContainerList->RemoveAll();
    }

    if (bDeleteListPtrWhenCleared)
    {
        HX_DELETE(m_pTextContainerList);
        HX_DELETE(m_pTextContainerRedrawList);
    }
}

/****************************************************************************
 *  C3GPPTimedTextRenderer::C3GPPTimedTextRenderer       ref:  3gppttrender.h
 *
 *  Constructor
 */
C3GPPTimedTextRenderer::C3GPPTimedTextRenderer()
        : m_lRefCount(0)
        , m_pContext(NULL)
        , m_pStream(NULL)
        , m_pPlayer(NULL)
        , m_pHeader(NULL)
        , m_pLatestPacket(NULL)
        , m_bGotAllPacketsAlready(FALSE)
        , m_ulTimeOfLastTimeSync(HX_3GPPTT_INVALID_TIME)
        , m_ulLastPacketTime(HX_3GPPTT_INVALID_TIME)
        , m_ulLastRealPacketTime(HX_3GPPTT_INVALID_TIME)
        , m_pHyperNavigate(NULL)
        , m_pBackChannel(NULL)
        , m_pASMStream(NULL)
        , m_pCommonClassFactory(NULL)
        , m_ulNumberOfClicks(0)
        , m_bIsSubscribed(TRUE)
        , m_pMISUS(NULL)
        , m_pMISUSSite(NULL)
        , m_bInSeekMode(FALSE)
        , m_bRTPPacketTested(FALSE)
        , m_bUsesRTPPackets(FALSE)
        , m_ulDuration(0)
        , m_ulNumTextSampleEntries(0)
        , m_p3GPPTextSampleEntryPackedArray(NULL)
        , m_pTextContainerList(NULL)
        , m_pTextContainerListFutureTimePos(NULL)
        , m_pTextContainerRedrawList(NULL)
        , m_nLastMouseMoveXPos(0)
        , m_nLastMouseMoveYPos(0)
        , m_pEvent(NULL)
        , m_pDrawOutputBuffer(NULL)
        , m_ulDrawOutputBufferSizeInBytes(0)
        , m_ulBitsPerPixel(HX_3GPPTT_DEFAULT_bits_PER_PIXEL)
        , m_lXScrollOffset(0)
        , m_lYScrollOffset(0)
        , m_dScrollFactor(0.0)
        , m_bDrawInNonTextScrollArea(FALSE)
        , m_pRuleToFlagMap(NULL)
#if defined(HELIX_3GPPTT_USE_STATUS_BAR)
        , m_pStatusMessage(NULL)
        , m_bStatusMsgWillNeedErasing(FALSE)
        , m_pszHLinkToDisplay(NULL)
#endif // /HELIX_3GPPTT_USE_STATUS_BAR
#if defined(_WINDOWS) // /                                                     -----vvvvvvvvvvvvvvvvvvvvvvvvvv-----
        , m_bNeedToSetHyperlinkHandCursor(FALSE)
        , m_hPreHyperlinkCursor(NULL)
        , m_hHyperlinkCursor(NULL)
        , m_pDeviceContextMemory(NULL)
        , m_pFont(NULL)
        , m_pFontOld(NULL)

#if defined(USE_DIB_SECTION)
        , m_hBitmap(NULL)
        , m_hOldBitmap(NULL)
        , m_LPBITMAPINFO(NULL)
#endif /* USE_DIB_SECTION */
#elif defined(_MACINTOSH)
        , m_CurrentCursor(CURSOR_ARROW)
        , m_pOffScreenWorld(NULL)
#elif defined(_UNIX) && (!(defined(_BEOS)))
        , m_hHyperlinkCursor(0)
        , m_bHandActivated(FALSE)
        , m_pdisp(NULL)
        , m_window(NULL)
        , m_gc(NULL)
#elif defined(_SYMBIAN)
        , m_pBitMap(NULL)
        , m_pFont(NULL)
        , m_pScreenDevice(NULL)
        , m_pGCSite(NULL)
        , m_pGCOffscreen(NULL)

#endif // /_WINDOWS -else- _MACINTOSH -else- (_UNIX && !_BEOS)                 _____^^^^^^^^^^^^^^^^^^^^^^^^^^_____

    {
        m_originTransformXY.x = m_originTransformXY.y = 0;
        m_size.cx = 0;
        m_size.cy = 0;
        memset(&m_BitmapInfoHeader, 0, sizeof(HXBitmapInfoHeader));

#if defined(_WINDOWS) // /                                                     -----vvvvvvvvvvvvvvvvvvvvvvvvvv-----
        m_pDeviceContextMemory = (void*)CreateCompatibleDC(NULL);
#endif // /_WINDOWS                                                            _____^^^^^^^^^^^^^^^^^^^^^^^^^^_____
#if defined(_MACINTOSH)
        const short HAND_CURSOR = 1313;
        m_pResourceLoader = CResourceLoader::CreateInstance(g_DLLFSpec);
        m_hHyperlinkCursor = (CursHandle)m_pResourceLoader->LoadResource('CURS', HAND_CURSOR);
#endif // /_MACINTOSH
    }


/****************************************************************************
 *  C3GPPTimedTextRenderer::~C3GPPTimedTextRenderer      ref:  3gppttrender.h
 *
 *  Destructor
 */
C3GPPTimedTextRenderer::~C3GPPTimedTextRenderer()
{
    for ( UINT32 idx = 0; idx != m_textSampleEntries.GetCount(); ++idx )
    {
	C3GPPTextSampleEntry*& pEntry = (C3GPPTextSampleEntry*&)(m_textSampleEntries[idx]);
	delete pEntry;
    }

    m_textSampleEntries.Reset(0);


    // /TRUE = delete m_pTextContainerList & m_pTextContainerRedrawList:
    ClearTextContainerLists(TRUE);

    /* Free the draw output buffer (but not w/DIB section) */
#if !defined(USE_DIB_SECTION)  &&  !defined(_SYMBIAN)
    if (m_pDrawOutputBuffer) // /Note: in Symbian, this points into m_pBitMap:
    {
        HX_VECTOR_DELETE(m_pDrawOutputBuffer);
        m_pDrawOutputBuffer = NULL;
        m_ulDrawOutputBufferSizeInBytes = 0;
    }
#endif // /!USE_DIB_SECTION.

#if defined(_WINDOWS) // /                                                     -----vvvvvvvvvvvvvvvvvvvvvvvvvv-----
    // /Free the DIB-section-only data:
#if defined(USE_DIB_SECTION)
    if(m_hBitmap)
    {
        DeleteObject(m_hBitmap);
    }
    if(m_hOldBitmap  &&  m_pDeviceContextMemory)
    {
        SelectObject((HDC)m_pDeviceContextMemory, m_hOldBitmap);
    }
    m_hOldBitmap = NULL;