pxgifrnd.cpp

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

        {
            // We are going to start receiving packets all over again, so
            // we need to blow away the CGIFCodec class and start over
            // again. We will need to reinit it with the stream header
            // buffer.
            //
            // Delete the old CGIFCodec
            HX_DELETE(m_pGIFCodec);
            // Create a new one
            m_pGIFCodec = new CGIFCodec();
            if (m_pGIFCodec)
            {
                // Get the stream header pointer
                BYTE* pData = m_pStreamHeaderBuffer->GetBuffer() + m_ulStreamHeaderOffset;
                // Initialize the CGIFCodec for decompression
                retVal = m_pGIFCodec->InitDecompress(m_pStreamHeaderBuffer->GetBuffer() + m_ulStreamHeaderOffset,
                                                     m_pStreamHeaderBuffer->GetSize()   - m_ulStreamHeaderOffset);
                if (SUCCEEDED(retVal))
                {
                    // Initialize the rendering members
                    m_ulCurImg           = 0;
                    m_ulCurImgRenderTime = 0;
                    m_ulCurDelayTime     = 0;
                    m_lLastImg           = -1;
                    // Initialize the loop done count
                    m_ulLoopsDone        = 0;
                    // Clear the ignore packets flag
                    m_bIgnorePackets     = FALSE;
                }
            }
            else
            {
                retVal = HXR_OUTOFMEMORY;
            }
        }
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }
    
    return retVal;
}

STDMETHODIMP CGIFRenderer::OnPause(UINT32 ulTimeBeforePause)
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::OnPause(%lu)\n",
              this, ulTimeBeforePause);

    // Set the paused flag
    m_bPaused = TRUE;

    return HXR_OK;
}

STDMETHODIMP CGIFRenderer::OnBuffering(UINT32 ulReason, UINT16 usPercentComplete)
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::OnBuffering(%lu,%u)\n",
              this, ulReason, usPercentComplete);
    return HXR_OK;
}

STDMETHODIMP CGIFRenderer::OnEndofPackets()
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::OnEndofPackets()\n",
              this);
    return HXR_OK;
}


STDMETHODIMP CGIFRenderer::EndStream()
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::EndStream()\n",
              this);
    // We're finished with the stream, but we may have
    // more rendering to do
    HX_RELEASE(m_pStream);

    return HXR_OK;
}

STDMETHODIMP CGIFRenderer::AttachSite(IHXSite *pSite)
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::AttachSite(0x%08x)\n",
              this, pSite);

    // Check for input error
    if (pSite == NULL)
    {
        return HXR_INVALID_PARAMETER;
    }

    // Check to see if we alredy have a site interface
    if (m_pMISUSSite)
    {
        return HXR_UNEXPECTED;
    }

    // Save a copy of the IHXSite interface
    m_pMISUSSite = pSite;
    m_pMISUSSite->AddRef();

    // Fill in the size
    m_cSize.cx = m_ulWidth;
    m_cSize.cy = m_ulHeight;

    // Tell the site of our size
    m_pMISUSSite->SetSize(m_cSize);

    // Lets see if we have a new site that supports sub rects.
    IHXSubRectSite* pSubRectSite = NULL;
    if(HXR_OK == m_pMISUSSite->QueryInterface(IID_IHXSubRectSite,
                                              (void**)&pSubRectSite))
    {
        //If so, since IHXSubRectSite inheirits from IHXSite, lets just
        //swap the pointers and sign up for the service.
        HX_RELEASE(m_pMISUSSite);
        m_pMISUSSite = pSubRectSite;
        pSubRectSite->SendSubRectMessages(TRUE);
        // Set the flag
        m_bCanBltSubRects = TRUE;
    }

    // Set the site attached flag
    m_bSiteAttached = TRUE;

    return HXR_OK;
}

STDMETHODIMP CGIFRenderer::DetachSite()
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::DetachSite()\n",
              this);

    if (m_pCallback)
    {
        if (m_pCallback->IsCallbackPending())
        {
            m_pCallback->RemovePendingCallback();
        }
    }
    if (m_pClientAdviseSink)
    {
        m_pClientAdviseSink->Close();
    }
    // Release the callback
    // XXXMEH - MUST DO THIS HERE or we'll have circular
    // dependency and leak CGIFRenderers
    HX_RELEASE(m_pCallback);

    // Release our site interface
    HX_RELEASE(m_pMISUSSite);

    // We're done with these...
    if (m_pMISUS)
    {
        m_pMISUS->ReleaseSingleSiteUser();
    }
    HX_RELEASE(m_pMISUS);

    // Clear the site attached flag
    m_bSiteAttached = FALSE;

    return HXR_OK;
}

STDMETHODIMP_(BOOL) CGIFRenderer::NeedsWindowedSites()
{
    return FALSE;
}

STDMETHODIMP CGIFRenderer::InitializeStatistics(UINT32 ulRegistryID)
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::InitializeStatistics(%lu)\n",
              this, ulRegistryID);

    // Add our renderer name to the HXRegistry
    IHXRegistry *pRegistry = NULL;
    HX_RESULT retVal = m_pContext->QueryInterface(IID_IHXRegistry, (void **) &pRegistry);
    if (retVal == HXR_OK)
    {
        // Get the current registry key name
        IHXBuffer *pszRegistryName = NULL;
        retVal                      = pRegistry->GetPropName(ulRegistryID, pszRegistryName);
        if (retVal == HXR_OK)
        {
            // Create an IHXBuffer to hold the name
        
            IHXBuffer* pValue = NULL;

            if (m_pCommonClassFactory)
            {
                IUnknown* pUnknown = NULL;
                m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pUnknown);
                if (pUnknown)
                {
                    pUnknown->QueryInterface(IID_IHXBuffer, (void**)&pValue);
                    HX_RELEASE(pUnknown);
                }
            }
            if (!pValue)
            {
                HX_RELEASE(pszRegistryName);
                HX_RELEASE(pRegistry);
                return HXR_OUTOFMEMORY;
            }
            pValue->AddRef();

            // Create the key name
            char szRegistryEntry[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
            SafeSprintf(szRegistryEntry, MAX_DISPLAY_NAME, "%s.name", pszRegistryName->GetBuffer());

            // Set the key value
            retVal = pValue->Set((const BYTE*) m_pszName, strlen(m_pszName) + 1);
            if (retVal != HXR_OK)
            {
                HX_RELEASE(pValue);
                HX_RELEASE(pszRegistryName);
                HX_RELEASE(pRegistry);
                return retVal;
            }

            // Add the key/value pair to the registry
            pRegistry->AddStr(szRegistryEntry, pValue);

            HX_RELEASE(pValue);
            HX_RELEASE(pszRegistryName);
        }
        HX_RELEASE(pRegistry);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::UpdateStatistics()
{
    MLOG_MISC(m_pErrorMessages,
              "0x%08x::UpdateStatistics()\n",
              this);
    return HXR_OK;
}

STDMETHODIMP CGIFRenderer::SetPropertyULONG32(const char* pName, ULONG32 ulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        // Clear the update needed flag
        BOOL bUpdateNeeded = FALSE;
        if (!strcmp(pName, "backgroundOpacity"))
        {
            if (ulVal > 255) ulVal = 255;
            if (ulVal != m_ulBackgroundOpacity) bUpdateNeeded = TRUE;
            m_ulBackgroundOpacity = ulVal;
        }
        else if (!strcmp(pName, "mediaOpacity"))
        {
            if (ulVal > 255) ulVal = 255;
            if (ulVal != m_ulMediaOpacity) bUpdateNeeded = TRUE;
            m_ulMediaOpacity = ulVal;
        }
        else if (!strcmp(pName, "chromaKey"))
        {
            if (ulVal != m_ulMediaChromaKey) bUpdateNeeded = TRUE;
            m_ulMediaChromaKey         = ulVal;
            m_bMediaChromaKeySpecified = TRUE;
        }
        else if (!strcmp(pName, "chromaKeyTolerance"))
        {
            if (ulVal != m_ulMediaChromaKeyTolerance) bUpdateNeeded = TRUE;
            m_ulMediaChromaKeyTolerance = ulVal;
        }
        else if (!strcmp(pName, "chromaKeyOpacity"))
        {
            if (ulVal != m_ulMediaChromaKeyOpacity) bUpdateNeeded = TRUE;
            m_ulMediaChromaKeyOpacity = ulVal;
        }
        // Did any values change?
        if (bUpdateNeeded)
        {
            // If we have not seen our first time sync yet, then
            // there is no need to update the buffer, since the first
            // copy has not been done yet
            if (!m_bFirstTimeSync && m_pGIFCodec)
            {
                // Compute the current frame we are on (note that
                // m_ulCurImg contains the index of the NEXT frame
                // that we are about to draw
                UINT32 ulCurFrame = (m_ulCurImg > 0 ? m_ulCurImg - 1 : 0);
                // Update the buffer
                // XXXMEH - optimization for later. In some cases if we 
                // just changed the media opacity, then it may not be necessary
                // to start back at the beginning and rebuild the frame buffer
                // from the first frame.
                m_pGIFCodec->GetRGBImageEx(-1,
                                           ulCurFrame,
                                           m_pOutputBuffer->GetBuffer(),
                                           m_pGIFCodec->GetLogicalScreenWidth(),
                                           m_pGIFCodec->GetLogicalScreenHeight(),
                                           m_ulPadWidth,
                                           m_ulBytesPerPixel,
                                           m_bRowsInverted,
                                           m_bRGBOrdering,
                                           m_ulBackgroundColor,
                                           (m_ulMediaOpacity == 255 ? FALSE : TRUE),
                                           m_ulMediaOpacity,
                                           m_bMediaChromaKeySpecified,
                                           m_ulMediaChromaKey,
                                           m_ulMediaChromaKeyTolerance,
                                           m_ulMediaChromaKeyOpacity);
                // XXXMEH - do dumb assignment for now. We should later check
                // chroma key to find if any colors were actually encountered.
                if (m_ulBackgroundOpacity < 255 ||
                    m_ulMediaOpacity < 255      ||
                    m_bMediaChromaKeySpecified)
                {
                    m_bUsesAlphaChannel = TRUE;
                }
            }
        }
        retVal = m_pValues->SetPropertyULONG32(pName, ulVal);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::GetPropertyULONG32(const char* pName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetPropertyULONG32(pName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::GetFirstPropertyULONG32(REF(const char*) rpName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetFirstPropertyULONG32(rpName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::GetNextPropertyULONG32(REF(const char*) rpName, REF(ULONG32) rulVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->GetNextPropertyULONG32(rpName, rulVal);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::SetPropertyBuffer(const char* pName, IHXBuffer* pVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {
        retVal = m_pValues->SetPropertyBuffer(pName, pVal);
    }

    return retVal;
}

STDMETHODIMP CGIFRenderer::GetPropertyBuffer(const char* pName, REF(IHXBuffer*) rpVal)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pValues)
    {