rvxvideo.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 326 行

/* ***** 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 ***** */ 

/****************************************************************************
 *  Defines
 */
// #define ASYNC_RESIZE_OK
// #define ENABLE_TRACE

#define RVX_VIDEO_RENDERER_NAME	"RealVideo"


/****************************************************************************
 *  Includes
 */
#include "hlxclib/stdio.h"
#include "hlxclib/string.h"

#include "rvxrend.ver"

#include "hxtypes.h"
#include "hxwintyp.h"
#include "hxresult.h"
#include "hxcom.h"
#include "hxmime.h"
#include "hxevent.h"
#include "hxcomm.h"
#include "ihxpckts.h"
#include "hxcore.h"
#include "hxrendr.h"
#include "hxhyper.h"
#include "hxplugn.h"
#include "hxasm.h"
#include "hxupgrd.h"
#include "hxengin.h"
#include "hxprefs.h"
#include "hxerror.h"
#include "hxwin.h"
#include "hxvsurf.h"
#include "hxvctrl.h"
#include "hxsite2.h"
#include "hxthread.h"
#include "hxmon.h"
#include "hxformt.h"
#include "ihxfgbuf.h"

#include "rvxvideo.h"
#include "rvxvdfmt.h"

#include "dllpath.h"
#include "hxheap.h"

#ifndef WIDTHBYTES
#define WIDTHBYTES(i)	((ULONG32)((i+31)&(~31))/8)	/* ULONG aligned ! */
#endif

/************************************************************************
 *  CRVXVideoRenderer class
 */
/************************************************************************
 *  Constants
 */
const char* const CRVXVideoRenderer::zm_pDescription = "RealNetworks RealVideo Renderer Plugin";


const char* const CRVXVideoRenderer::zm_pStreamMimeTypes[] =
{
    REALVIDEO_MIME_TYPE,
    REALVIDEO_MULTIRATE_MIME_TYPE,
    NULL
};


/************************************************************************
 *  Constructor/Destructor
 */
CRVXVideoRenderer::CRVXVideoRenderer(void)
    : m_pOutputAllocator(NULL)
    , m_ulPadWidthLeft(0)
    , m_ulPadWidthRight(0)
    , m_ulPadHeightTop(0)
    , m_ulPadHeightBottom(0)
{
    ;
}

CRVXVideoRenderer::~CRVXVideoRenderer()
{
    if (m_pActiveVideoPacket)
    {
	m_pActiveVideoPacket->Clear();
	delete m_pActiveVideoPacket;
	m_pActiveVideoPacket = NULL;
    }

    if (m_pOutputAllocator)
    {
        m_pOutputAllocator->Release();
        m_pOutputAllocator = NULL;
    }
}


HX_RESULT STDAPICALLTYPE CRVXVideoRenderer::HXCreateInstance(IUnknown** ppIUnknown)
{
    *ppIUnknown = (IUnknown*)(IHXPlugin*) new CRVXVideoRenderer();
    if (*ppIUnknown)
    {
	(*ppIUnknown)->AddRef();
	return HXR_OK;
    }

    return HXR_OUTOFMEMORY;
}

HX_RESULT STDAPICALLTYPE CRVXVideoRenderer::CanUnload(void)
{
    return CanUnload2();
}

HX_RESULT STDAPICALLTYPE CRVXVideoRenderer::CanUnload2(void)
{
    return ((CHXBaseCountingObject::ObjectsActive() > 0) ? HXR_FAIL : HXR_OK);
}


/************************************************************************
 *  Method:
 *    IHXPlugin::GetPluginInfo
 *  Purpose:
 *    Returns the basic information about this plugin. Including:
 *
 *    bLoadMultiple	whether or not this plugin DLL can be loaded
 *			multiple times. All File Formats must set
 *			this value to TRUE.
 *    pDescription	which is used in about UIs (can be NULL)
 *    pCopyright	which is used in about UIs (can be NULL)
 *    pMoreInfoURL	which is used in about UIs (can be NULL)
 */
STDMETHODIMP CRVXVideoRenderer::GetPluginInfo
(
   REF(BOOL)        /*OUT*/ bLoadMultiple,
   REF(const char*) /*OUT*/ pDescription,
   REF(const char*) /*OUT*/ pCopyright,
   REF(const char*) /*OUT*/ pMoreInfoURL,
   REF(ULONG32)     /*OUT*/ ulVersionNumber
)
{
    HX_RESULT retVal;

    retVal = CVideoRenderer::GetPluginInfo(bLoadMultiple,
					   pDescription,
					   pCopyright,
					   pMoreInfoURL,
					   ulVersionNumber);

    if (SUCCEEDED(retVal))
    {
	pDescription    = zm_pDescription;
	ulVersionNumber = TARVER_ULONG32_VERSION;
    }
    
    return retVal;
}


/************************************************************************
 *  Method:
 *    IHXRenderer::GetRendererInfo
 *  Purpose:
 *    If this object is a file format object this method returns
 *    information vital to the instantiation of file format plugins.
 *    If this object is not a file format object, it should return
 *    HXR_UNEXPECTED.
 */
STDMETHODIMP CRVXVideoRenderer::GetRendererInfo
(
    REF(const char**) /*OUT*/ pStreamMimeTypes,
    REF(UINT32)       /*OUT*/ unInitialGranularity
)
{
    HX_RESULT retVal;

    retVal = CVideoRenderer::GetRendererInfo(pStreamMimeTypes,
					     unInitialGranularity);

    if (SUCCEEDED(retVal))
    {
	pStreamMimeTypes = (const char**)zm_pStreamMimeTypes;
    }
    
    return retVal;
}


/****************************************************************************
 *  CreateFormatObject
 */
CVideoFormat* CRVXVideoRenderer::CreateFormatObject(IHXValues* pHeader)
{
    return new CRVXVideoFormat(m_pCommonClassFactory, this);
}


/****************************************************************************
 *  GetRendererName
 */
const char* CRVXVideoRenderer::GetRendererName(void)
{
    return RVX_VIDEO_RENDERER_NAME;
}


/****************************************************************************
 *  SetupBitmapDefaults
 */
void CRVXVideoRenderer::SetupBitmapDefaults(IHXValues* pHeader,
					     HXBitmapInfoHeader &bitmapInfoHeader)
{
    // size calculation is taken from crvvideo
    bitmapInfoHeader.biSize = sizeof (HXBitmapInfoHeader);
    bitmapInfoHeader.biWidth = 0;	// 352;		// unknown
    bitmapInfoHeader.biHeight = 0;	// 288;		// unknown
    bitmapInfoHeader.biPlanes = 1;
    bitmapInfoHeader.biBitCount = RVXV_PIXEL_SIZE;
    bitmapInfoHeader.biCompression = RVXV_PIXEL_FORMAT;
    bitmapInfoHeader.biSizeImage = bitmapInfoHeader.biWidth * 
				     bitmapInfoHeader.biHeight * 
				     bitmapInfoHeader.biBitCount / 
				     8;
    bitmapInfoHeader.biXPelsPerMeter = 0; 
    bitmapInfoHeader.biYPelsPerMeter = 0;
    bitmapInfoHeader.biClrUsed = 0;
    bitmapInfoHeader.biClrImportant = 0;
    bitmapInfoHeader.rcolor	= 0;
    bitmapInfoHeader.gcolor	= 0;
    bitmapInfoHeader.bcolor	= 0;    
}


/****************************************************************************
 *  AdjustVideoMapping
 */
void CRVXVideoRenderer::AdjustVideoMapping(HXxRect &destRect, 
					   HXxRect &sorcRect,
					   CMediaPacket*pActiveVideoPacket)
{
    sorcRect.left = m_ulPadWidthLeft;
    sorcRect.top = m_ulPadHeightTop;
    sorcRect.right -= m_ulPadWidthRight;
    sorcRect.bottom -= m_ulPadHeightBottom;
}


/****************************************************************************
 *  Method:
 *    CRVXVideoRenderer::OnOptimizedVideo
 *
 */
HX_RESULT CRVXVideoRenderer::OnOptimizedVideo(HX_RESULT status,
					      const HXBitmapInfoHeader& sourceBIH,
					      HXBitmapInfoHeader &targetBIH, 
					      ULONG32 &ulTargetBufCount)
{
    HX_RESULT retVal = HXR_FAIL;

#ifdef _WIN32
    SetDecodePriority(THREAD_PRIORITY_NORMAL);
#endif	// _WIN32

    retVal = CVideoRenderer::OnOptimizedVideo(status,
					      sourceBIH,
					      targetBIH, 
					      ulTargetBufCount);

    return retVal;
}


/****************************************************************************
 *  Method:
 *    CRVXVideoRenderer::OffOptimizedVideo
 *
 */
void CRVXVideoRenderer::OffOptimizedVideo(void)
{
#ifdef _WIN32
    SetDecodePriority(THREAD_PRIORITY_BELOW_NORMAL);
#endif	// _WIN32

    return;
}