comimgrend.cpp

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

/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 

#include "hxtypes.h"
#include "hxwintyp.h"
#include "hxcom.h"
#include "hxcomm.h"
#include "ihxpckts.h"
#include "hxfiles.h"
#include "hxcore.h"
#include "hxrendr.h"
#include "hxplugn.h"
#include "hxwin.h"
#include "hxevent.h"
#include "hxvsurf.h"
#include "hxslist.h"
#include "hxver.h"
#include "baseobj.h"
#include "wbmphdr.h"
#include "hxtick.h"
#include "unifimg.h"
#include "nativeimgdec.h"
#include "comimgrend.h"
#include "comimgrend.ver"

#include "hxheap.h"
#ifdef _DEBUG
#undef HX_THIS_FILE
static const char HX_THIS_FILE[] = __FILE__;
#endif

const char* const CCommonImageRenderer::m_pszName              = "CommonImageRenderer";
const char* const CCommonImageRenderer::m_pszDescription       = "Helix Common Image Renderer Plugin";
const char* const CCommonImageRenderer::m_pszCopyright         = HXVER_COPYRIGHT;
const char* const CCommonImageRenderer::m_pszMoreInfoURL       = HXVER_MOREINFO;
const char* const CCommonImageRenderer::m_ppszStreamMimeType[] = {IMAGE_MIMETYPE_JPEG,
                                                                  IMAGE_MIMETYPE_PNG,
                                                                  IMAGE_MIMETYPE_WBMP,
                                                                  IMAGE_MIMETYPE_JPEG_STREAMED,
                                                                  IMAGE_MIMETYPE_PNG_STREAMED,
                                                                  IMAGE_MIMETYPE_WBMP_STREAMED,
                                                                  NULL};

CCommonImageRenderer::CCommonImageRenderer()
{
    m_lRefCount           = 0;
    m_pContext            = NULL;
    m_pSite               = NULL;
    m_pCommonClassFactory = NULL;
    m_pStreamHeader       = NULL;
    m_pMimeTypeStr        = NULL;
    m_ulImageWidth        = 0;
    m_ulImageHeight       = 0;
    m_pPacketList         = NULL;
    m_bHasForceRedraw     = FALSE;
    m_bDecodeComplete     = FALSE;
    m_pBitmapInfoHeader   = NULL;
    m_pOutputBuffer       = NULL;
    m_pNativeImageDecoder = NULL;
}

CCommonImageRenderer::~CCommonImageRenderer()
{
    ClearPacketList();
    HX_RELEASE(m_pContext);
    HX_RELEASE(m_pSite);
    HX_RELEASE(m_pCommonClassFactory);
    HX_RELEASE(m_pStreamHeader);
    HX_DELETE(m_pPacketList);
    HX_DELETE(m_pBitmapInfoHeader);
    HX_RELEASE(m_pOutputBuffer);
    HX_DELETE(m_pNativeImageDecoder);
}


STDMETHODIMP CCommonImageRenderer::QueryInterface(REFIID riid, void** ppvObj)
{
    HX_RESULT retVal = HXR_OK;

    if (ppvObj)
    {
        // Set default
        *ppvObj = NULL;
        // Check for IID type
        if (IsEqualIID(riid, IID_IUnknown))
        {
            AddRef();
            *ppvObj = (IUnknown*) (CHXBaseCountingObject*) (IHXPlugin*) this;
        }
        else if (IsEqualIID(riid, IID_IHXPlugin))
        {
            AddRef();
            *ppvObj = (IHXPlugin*) this;
        }
        else if (IsEqualIID(riid, IID_IHXRenderer))
        {
            AddRef();
            *ppvObj = (IHXRenderer*) this;
        }
        else if (IsEqualIID(riid, IID_IHXSiteUser))
        {
            AddRef();
            *ppvObj = (IHXSiteUser*) this;
        }
        else
        {
            retVal = HXR_NOINTERFACE;
        }
    }
    else
    {
        retVal = HXR_FAIL;
    }

    return retVal;
}

STDMETHODIMP_(UINT32) CCommonImageRenderer::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}


STDMETHODIMP_(UINT32) CCommonImageRenderer::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;

    return 0;
}


STDMETHODIMP CCommonImageRenderer::GetPluginInfo(REF(BOOL)        rbLoadMultiple,
                                                 REF(const char*) rpszDescription,
                                                 REF(const char*) rpszCopyright,
                                                 REF(const char*) rpszMoreInfoURL,
                                                 REF(UINT32)      rulVersionNumber)
{
    rbLoadMultiple   = TRUE;
    rpszDescription  = (const char*) m_pszDescription;
    rpszCopyright    = (const char*) m_pszCopyright;
    rpszMoreInfoURL  = (const char*) m_pszMoreInfoURL;
    rulVersionNumber = TARVER_ULONG32_VERSION;

    return HXR_OK;
}

STDMETHODIMP CCommonImageRenderer::InitPlugin(IUnknown* pContext)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pContext)
    {
        // Save a copy of the calling context
        HX_RELEASE(m_pContext);
        m_pContext = pContext;
        m_pContext->AddRef();
        // Get a IHXCommonClassFactory interface
        HX_RELEASE(m_pCommonClassFactory);
        retVal = m_pContext->QueryInterface(IID_IHXCommonClassFactory,
                                            (void**) &m_pCommonClassFactory);
    }

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::GetRendererInfo(REF(const char**) rppszStreamMimeType,
                                                   REF(UINT32)       rulInitialGranularity)
{
    rppszStreamMimeType   = (const char**) m_ppszStreamMimeType;
    rulInitialGranularity = 100;

    return HXR_OK;
}

STDMETHODIMP CCommonImageRenderer::StartStream(IHXStream* pStream, IHXPlayer* pPlayer)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnHeader(IHXValues* pHeader)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pHeader)
    {
        // Parse the stream header
        retVal = ParseStreamHeader(pHeader, m_ulImageWidth,
                                   m_ulImageHeight, m_pMimeTypeStr);
        if (SUCCEEDED(retVal))
        {
            // Save the stream header
            HX_RELEASE(m_pStreamHeader);
            m_pStreamHeader = pHeader;
            m_pStreamHeader->AddRef();
        }
    }

    return retVal;

}

STDMETHODIMP CCommonImageRenderer::OnBegin(UINT32 ulTimeAfterBegin)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::GetDisplayType(REF(HX_DISPLAY_TYPE) rDisplayType,
                                                  REF(IHXBuffer*)      rpDisplayInfo)
{
    HX_RESULT retVal = HXR_OK;

    rDisplayType = HX_DISPLAY_WINDOW          |
                   HX_DISPLAY_SUPPORTS_RESIZE |
                   HX_DISPLAY_SUPPORTS_FULLSCREEN;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnPacket(IHXPacket* pPacket, INT32 lTimeOffset)
{
    HX_RESULT retVal = HXR_FAIL;

    if (pPacket)
    {
        if (!m_pPacketList)
        {
            m_pPacketList = new CHXSimpleList();
        }
        if (m_pPacketList)
        {
            // AddRef the packet before going on the list
            pPacket->AddRef();
            // Add the packet to the list
            m_pPacketList->AddTail((void*) pPacket);
        }
        // Clear the return value
        retVal = HXR_OK;
    }

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnTimeSync(UINT32 ulTime)
{
    HX_RESULT retVal = HXR_OK;

    if (m_bDecodeComplete && !m_bHasForceRedraw )
        _ForceRedraw();
    
    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnPreSeek(UINT32 ulTimeBefore, UINT32 ulTimeAfter)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnPostSeek(UINT32 ulTimeBefore, UINT32 ulTimeAfter)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnPause(UINT32 ulTimeBeforePause)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnBuffering(UINT32 ulReason, UINT16 usPercentComplete)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP CCommonImageRenderer::OnEndofPackets()
{
    HX_RESULT retVal = HXR_OK;

    // Generate single image buffer from list of packets
    IHXBuffer* pBuffer = NULL;
    retVal = GenerateImageBuffer(m_pPacketList, m_pStreamHeader, pBuffer);
    if (SUCCEEDED(retVal))
    {
        // Now we can clear the packet list
        ClearPacketList();
        // Delete the list object
        HX_DELETE(m_pPacketList);
        // Create the native image decoder object
        HX_DELETE(m_pNativeImageDecoder);
        m_pNativeImageDecoder = CNativeImageDecoder::CreateNativeImageDecoder();
        if (m_pNativeImageDecoder)
        {
            // Decode the image asynchronously
            retVal = m_pNativeImageDecoder->Decode(m_pContext,
                                                   this,
                                                   pBuffer,
                                                   m_pMimeTypeStr);
        }
    }
    HX_RELEASE(pBuffer);

    return retVal;
}


STDMETHODIMP CCommonImageRenderer::EndStream()
{
    HX_RESULT retVal = HXR_OK;