pxrend.cpp

linux下的一款播放器

                        DEBUG_OUT(m_pErrorMessages, DOL_REALPIX_EXTENDED,
                                  (s, "Effect Packet (start=%lu,type=%lu,handle=%lu,lastuse=%lu) ts=%lu",
                                   pEffect->GetStart(), (UINT32) pEffect->GetEffectType(),
                                   pEffect->GetTarget(), pEffect->GetLastUse(), pPacket->GetTime()));
#endif
                        retVal = m_pEffectsManager->AddEffect(pEffect);
                    }
                    HX_RELEASE(pEffect);
                }
                else if (ulPacketType == PXWireFormatManager::kPacketTypeCookie)
                {
                    UINT32    ulNumCookies = 0;
                    HX_RESULT rv           = m_pWireFormatManager->GetNumCookies(pPacket, ulNumCookies);
                    if (SUCCEEDED(rv))
                    {
#ifdef XXXMEH_DEBUG_OUT
                        DEBUG_OUT(m_pErrorMessages, DOL_REALPIX_EXTENDED,
                                  (s, "Cookie Packet (%lu cookies) ts=%lu",
                                   ulNumCookies, pPacket->GetTime()));
#endif
                        if (ulNumCookies > 0)
                        {
                            // Get the IHXCookies interface
                            IHXCookies* pCookies = NULL;
                            m_pContext->QueryInterface(IID_IHXCookies, (void**) &pCookies);
                            if (pCookies)
                            {
                                // Go through each of the cookies
                                for (UINT32 i = 0; i < ulNumCookies; i++)
                                {
                                    IHXBuffer* pURLStr       = NULL;
                                    IHXBuffer* pCookieBuffer = NULL;
                                    rv                        = m_pWireFormatManager->GetCookie(pPacket,
                                                                                                i,
                                                                                                pURLStr,
                                                                                                pCookieBuffer);
                                    if (SUCCEEDED(rv))
                                    {
                                        IHXBuffer* pHostStr = NULL;
                                        IHXBuffer* pPathStr = NULL;
                                        rv                   = GetHostAndPathFromURL((const char*) pURLStr->GetBuffer(),
                                                                 m_pCommonClassFactory,
                                                                                     pHostStr,
                                                                                     pPathStr);
                                        if (SUCCEEDED(rv))
                                        {
                                            rv = pCookies->SetCookies((const char*) pHostStr->GetBuffer(),
                                                                      (const char*) pPathStr->GetBuffer(),
                                                                      pCookieBuffer);
                                        }
                                        HX_RELEASE(pHostStr);
                                        HX_RELEASE(pPathStr);
                                    }
                                    HX_RELEASE(pURLStr);
                                    HX_RELEASE(pCookieBuffer);
                                }
                            }
                            HX_RELEASE(pCookies);
                        }
                    }
                }
#ifdef XXXMEH_DEBUG_OUT
                else
                {
                    DEBUG_OUT(m_pErrorMessages, DOL_REALPIX_EXTENDED, (s, "Unknown packet type"));
                }
#endif
            }
        }
#ifdef XXXMEH_DEBUG_OUT
        else
        {
            DEBUG_OUT(m_pErrorMessages, DOL_REALPIX, (s, "***Packet Lost***"));
        }
#endif
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

STDMETHODIMP CRealPixRenderer::OnTimeSyncOffset(UINT32 ulTime)
{
    HX_RESULT retVal = UpdateDisplay(ulTime);
    if (SUCCEEDED(retVal))
    {
        // Determine if we need to send a backchannel notify
        // This is used with a particular kind of adserver
        if (m_pWireFormatManager->GetRealPixAdsFlag())
        {
            if (m_pWireFormatManager->GetRPACachingAdFlag() &&
                m_pEffectsManager->GetBackChannelNotify())
            {
                // Get a backchannel notify packet
                IHXPacket* pPacket = NULL;
                retVal = m_pWireFormatManager->SetBackChannelInfo(m_pEffectsManager->GetBackChannelHandle(),
                                                                  ulTime,
                                                                  pPacket);
                if (SUCCEEDED(retVal))
                {
                    if (m_pBackChannel)
                    {
#ifdef XXXMEH_DEBUG_OUT
                        DEBUG_OUT(m_pErrorMessages, DOL_REALPIX, (s, "Sending BackChannel packet at %lu", ulTime));
#endif
                        // Send the packet
                        m_pBackChannel->PacketReady(pPacket);
                    }
                }
                HX_RELEASE(pPacket);
            }
        }
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

STDMETHODIMP CRealPixRenderer::OnPreSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
{
    HX_RESULT retVal = HXR_OK;

    // We need to clear out all effects and delete all
    // current images. If we have seeked past the duration
    // of the presentation, we don't do this, since we won't
    // be getting any more packets.
    if (ulNewTime < m_pWireFormatManager->GetDuration())
    {
        m_pEffectsManager->ClearEffects();
        m_pImageManager->ReleasePresentationImages();
    }

    // Clear the hyperlink manager
    retVal = m_pHyperlinkManager->Init(m_pContext,
                                       m_pWireFormatManager->GetDisplayWidth(),
                                       m_pWireFormatManager->GetDisplayHeight());
    if (SUCCEEDED(retVal))
    {
        // Set the seeking flag
        m_bSeeking = TRUE;
    }

    return retVal;
}

STDMETHODIMP CRealPixRenderer::OnPostSeek(ULONG32 ulOldTime, ULONG32 ulNewTime)
{
    HX_RESULT retVal = HXR_OK;

    // Clear the seeking flag
    m_bSeeking = FALSE;

    return retVal;
}

STDMETHODIMP CRealPixRenderer::EndStream()
{
    // Call our base class's EndStream
    HX_RESULT retVal = CRNBaseRenderer::EndStream();

    if (SUCCEEDED(retVal) && m_pCodecManager && m_pEffectsManager)
    {
        // Now we can release the codec manager
        HX_RELEASE(m_pCodecManager);
        // Release the effects package manager
        HX_RELEASE(m_pEffectsPackageManager);
        // Determine if we need to have post-duration callbacks or not
        if (m_pEffectsManager->GetCheckIndefiniteDuration())
        {
            // We DO currently have indefinite-duration effects
            // executing. Therefore, we need to start getting callbacks
            //
            // Create the callback object
            HX_RELEASE(m_pCallback);
            m_pCallback = new PXCallback();
            if (m_pCallback)
            {
                // AddRef the callback
                m_pCallback->AddRef();
                // Init the callback object
                retVal = m_pCallback->Init(m_pContext, this, FALSE, m_ulLastTimeSync);
                if (SUCCEEDED(retVal))
                {
                    // Schedule a callback kCallbackInterval ms from now
                    retVal = m_pCallback->ScheduleRelativeCallback(kCallbackInterval);
                }
            }
            else
            {
                retVal = HXR_OUTOFMEMORY;
            }
        }
        else
        {
            // There are NOT currently any indefinite duration effects
            // executing. Therefore, we can shutdown as normal.
            //
            // Clear out all effects from the effects manager
            m_pEffectsManager->ClearEffects();
        }
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

STDMETHODIMP CRealPixRenderer::GetWindowSize(REF(HXxSize) rSize)
{
    HX_RESULT retVal = HXR_OK;

    if (m_pWireFormatManager)
    {
        rSize.cx = m_pWireFormatManager->GetDisplayWidth();
        rSize.cy = m_pWireFormatManager->GetDisplayHeight();
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

STDMETHODIMP CRealPixRenderer::IsMouseOverActiveLink(INT16 x, INT16 y, REF(BOOL) rbActive, REF(IHXBuffer*) rpLink)
{
    HX_RESULT retVal = HXR_OK;

    if (m_pHyperlinkManager)
    {
        HXxSize size;
        if (m_pSite)
        {
            m_pSite->GetSize(size);
        }
        else
        {
            if (m_pWireFormatManager)
            {
                size.cx = m_pWireFormatManager->GetDisplayWidth();
                size.cy = m_pWireFormatManager->GetDisplayHeight();
            }
            else
            {
                retVal = HXR_UNEXPECTED;
            }
        }

        if (SUCCEEDED(retVal))
        {
            rbActive = m_pHyperlinkManager->GetActiveLink(x, y, size.cx,
                                                          size.cy, rpLink);
        }
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}

STDMETHODIMP CRealPixRenderer::RMASurfaceUpdate(IHXVideoSurface* pSurface)
{
    HX_RESULT retVal = HXR_OK;

    if (pSurface)
    {
        if (m_pImageManager && m_pEffectsManager &&
            m_pSite         && m_pWireFormatManager)
        {
            // Was this redraw forced from the effects manager
            HXxRect cSrcRect;
            if (m_pEffectsManager->WasRedrawForced())
            {
                // Yes it was, so get the damage rect from the effects manager
                m_pEffectsManager->GetDamageRect(cSrcRect);
                // XXXMEH - hack for now - use the whole display window
                cSrcRect.left   = 0;
                cSrcRect.top    = 0;
                cSrcRect.right  = m_pWireFormatManager->GetDisplayWidth();
                cSrcRect.bottom = m_pWireFormatManager->GetDisplayHeight();
            }
            else
            {
                // No, it wasn't, so since we cannot get the actual
                // damage rect from the HXxEvent, then we must redraw the
                // whole src window.
                cSrcRect.left   = 0;
                cSrcRect.top    = 0;
                cSrcRect.right  = m_pWireFormatManager->GetDisplayWidth();
                cSrcRect.bottom = m_pWireFormatManager->GetDisplayHeight();
            }
            // Get the current size of the site
            HXxSize cSize;
            retVal = m_pSite->GetSize(cSize);
            if (SUCCEEDED(retVal))
            {
                // Scale the destination rect if necessary
                HXxRect cDstRect;
                if (cSize.cx == (INT32) m_pWireFormatManager->GetDisplayWidth() &&
                    cSize.cy == (INT32) m_pWireFormatManager->GetDisplayHeight())
                {
                    cDstRect = cSrcRect;
                    if (HXxRECT_WIDTH(cDstRect) == 0)
                    {
                        cDstRect.right = cDstRect.left + cSize.cx;
                    }
                    if (HXxRECT_HEIGHT(cDstRect) == 0)
                    {
                        cDstRect.bottom = cDstRect.top + cSize.cy;
                    }
                }
                else
                {
                    cDstRect.left   = cSrcRect.left   * cSize.cx / m_pWireFormatManager->GetDisplayWidth();
                    cDstRect.top    = cSrcRect.top    * cSize.cy / m_pWireFormatManager->GetDisplayHeight();
                    cDstRect.right  = cSrcRect.right  * cSize.cx / m_pWireFormatManager->GetDisplayWidth();
                    cDstRect.bottom = cSrcRect.bottom * cSize.cy / m_pWireFormatManager->GetDisplayHeight();
                }
                // Get the display image
                PXImage* pDisplayImage = NULL;
                retVal                 = m_pImageManager->GetDisplayImage(&pDisplayImage);
                if (SUCCEEDED(retVal))
                {
                    retVal = pDisplayImage->DrawToHXSurface(pSurface, cSrcRect, cDstRect);
                    if (SUCCEEDED(retVal))
                    {
                        // Now we can reset the effect manager's damage rect IF
                        // the redraw was forced from it
                        if (m_pEffectsManager->WasRedrawForced())
                        {
                            m_pEffectsManager->SetRedrawForced(FALSE);
                            m_pEffectsManager->ResetDamage();
                        }
                    }
                }
                HX_RELEASE(pDisplayImage);
            }
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

#ifdef XXXMEH_DEBUG_ASSERT
    // Debug-only assert
    HX_ASSERT(SUCCEEDED(retVal));
#endif

    return retVal;
}