basehand.cpp

linux下的一款播放器

				   PropName3, PropVal3, pRetUnk, NULL );
}


STDMETHODIMP
BaseHandler::FindImplementationFromClassID
(
    REFGUID GUIDClassID,
    REF(IUnknown*) pIUnknownInstance
)
{
    // Defer to the new version
    return FindImplementationFromClassID( GUIDClassID, pIUnknownInstance, NULL, m_pContext );
}

STDMETHODIMP BaseHandler::Close ()
{
    CHXSimpleList::Iterator i = m_PluginList.Begin();

    // Release all Plugins and Their Associated DLLs
    for(; i!=m_PluginList.End(); ++i)
    {
	BaseHandler::Plugin* pPlug = (BaseHandler::Plugin*) *i;
	pPlug->Release();
    }
    m_PluginList.RemoveAll();

    for(i = m_PluginDLLList.Begin(); i!=m_PluginDLLList.End(); ++i)
    {
	BaseHandler::PluginDLL* pPlugDLL = (BaseHandler::PluginDLL*) *i;
	pPlugDLL->Release();
    }
    m_PluginDLLList.RemoveAll();

    for(i = m_MiscDLLList.Begin(); i!=m_MiscDLLList.End(); ++i)
    {
	BaseHandler::OtherDLL* pOtherDLL = (BaseHandler::OtherDLL*) *i;
	delete pOtherDLL;
    }
    m_MiscDLLList.RemoveAll();

    for(CHXMapStringToOb::Iterator mp = m_MountPoints.Begin(); mp!=m_MountPoints.End(); ++mp)
    {
	BaseHandler::PluginMountPoint* pMountPoint = (BaseHandler::PluginMountPoint*) *mp;
	pMountPoint->Release();
    }
    m_MountPoints.RemoveAll();

    // release all of the CORE stuff...
    HX_RELEASE(m_pContext);

    return HXR_OK;
}

STDMETHODIMP BaseHandler::SetRequiredPlugins (const char** ppszRequiredPlugins)
{
    return HXR_OK;
}


HX_RESULT BaseHandler::AddToValues(IHXValues* pValues, char* pPropName, char* pPropVal, eValueTypes eValueType)
{
    if (!pPropName || !pPropVal)
	return HXR_FAIL;
    // 1st make into a cstrig and to trim the buffer...
    CHXString theValue = (pPropVal);
    theValue.TrimLeft();
    theValue.TrimRight();

    switch (eValueType)
    {
	case eString:
	{
	    IHXBuffer* pBuffer;
	    CHXBuffer*	pCHXBuffer;
	    pCHXBuffer = new CHXBuffer;
	    pCHXBuffer->QueryInterface(IID_IHXBuffer, (void**) &pBuffer);
	    pBuffer->Set((const unsigned char*)(const char*)theValue, strlen(theValue)+1);
	    pValues->SetPropertyCString(pPropName, pBuffer);
	    pBuffer->Release();
	    return HXR_OK;
	}
	case eInt:
	{
	    int val = atoi(theValue);
	    pValues->SetPropertyULONG32(pPropName, (ULONG32)val);
	    return HXR_OK;
	}
    }
    return HXR_NOTIMPL;
}

STDMETHODIMP_(ULONG32) BaseHandler::GetNumOfPlugins()
{
    return m_PluginList.GetCount();
}

STDMETHODIMP BaseHandler::GetPlugin(ULONG32 ulIndex, REF(IUnknown*)  /*OUT*/ pInstance)
{
    return GetPlugin( ulIndex, pInstance, NULL );
}


STDMETHODIMP BaseHandler::FlushCache()
{
    return HXR_OK;
}

STDMETHODIMP BaseHandler::SetCacheSize(ULONG32 nSizeKB)
{
    return HXR_OK;
}

STDMETHODIMP BaseHandler::ReadFromRegistry()
{
    HX_RESULT result;
    IHXBuffer* pBuffer = NULL;

#if !defined(_STATICALLY_LINKED) || defined(HELIX_CONFIG_CONSOLIDATED_CORE)

    const char* pPath = GetDLLAccessPath()->GetPath(DLLTYPE_PLUGIN);
    if (pPath && *pPath)
    {
	pBuffer = new CHXBuffer;
	if (pBuffer)
	{
	    pBuffer->AddRef();
	    HX_VERIFY(SUCCEEDED(pBuffer->Set((UCHAR*)pPath,
					     strlen(pPath) + 1)));
	}
    }

#endif

    // Set up a mount point with the default plugin location
    result = AddPluginMountPoint(HXVER_SDK_PRODUCT, 0, 0, pBuffer);

    HX_RELEASE(pBuffer);

    return result;
}


BOOL BaseHandler::FindPlugin(const char* pFileName, UINT32 nDLLIndex, REF(UINT32) nIndex)
{
    UINT32 nTempIndex = 0;

    for(CHXSimpleList::Iterator i = m_PluginList.Begin(); i!=m_PluginList.End(); ++i)
    {
	BaseHandler::Plugin* pPlugin = (BaseHandler::Plugin*) *i;
	IHXBuffer* pBuffer = pPlugin->GetFileName();
	char* pPluginFileName = (char*) pBuffer->GetBuffer();

	if (!strcasecmp(pPluginFileName, pFileName))
	{
	    if (pPlugin->GetIndex() == nDLLIndex)
	    {
		nIndex = nTempIndex;
		HX_RELEASE(pBuffer);
		return TRUE;
	    }
	}
	HX_RELEASE(pBuffer);
	nTempIndex++;
    }
    return FALSE;
}

/**********************************************************************************
***		    BaseHandler::Plugin					***
***********************************************************************************/


BaseHandler::Plugin::Plugin(IUnknown* pContext) :
	m_lRefCount(0)
    ,	m_pValues(0)
    ,	m_pPluginDLL(0)
    ,	m_pContext(pContext)
    , 	m_bInfoNeedsRefresh(FALSE)
    ,	m_nPluginIndex(0)
    ,	m_pClassFactory(NULL)
{
    m_pValues = new CHXHeader();
    m_pValues->AddRef();
    m_pContext->AddRef();
    m_pContext->QueryInterface(IID_IHXCommonClassFactory,
    	(void**)&m_pClassFactory);
}

BaseHandler::Plugin::~Plugin()
{
    HX_RELEASE(m_pValues);
    HX_RELEASE(m_pPluginDLL);
    HX_RELEASE(m_pClassFactory);
    HX_RELEASE(m_pContext);
    //HX_RELEASE(m_pPluginWatcher);
}

void BaseHandler::Plugin::SetPluginProperty(const char* pszPluginType)
{
    IHXBuffer* pBuffer = NULL;
    m_pClassFactory->CreateInstance(CLSID_IHXBuffer,(void**)&pBuffer);
    pBuffer->Set((UCHAR*)pszPluginType, strlen(pszPluginType)+1);
    m_pValues->SetPropertyCString(PLUGIN_CLASS, pBuffer);
    pBuffer->Release();
}


BOOL BaseHandler::Plugin::DoesMatch(IHXValues* pValues)
{
    CHXSimpleList   PossibleValues1;
    CHXSimpleList   PossibleValues2;
    const char*	    pPropName = NULL;
    ULONG32	    nInValue;
    ULONG32	    nOutValue;
    IHXBuffer*	    pInBuffer = NULL;
    IHXBuffer*	    pOutBuffer = NULL;

    // Check ULONGS 1st
    if (HXR_OK == pValues->GetFirstPropertyULONG32(pPropName, nInValue))
    {
	if (HXR_OK==m_pValues->GetPropertyULONG32(pPropName, nOutValue))
	{
	    if (nInValue != nOutValue)
	    {
		goto notFoundexit;
	    }
	}
	else
	{
	    goto notFoundexit;
	}
	while (HXR_OK == pValues->GetNextPropertyULONG32(pPropName, nInValue))
	{
	    if (HXR_OK == m_pValues->GetPropertyULONG32(pPropName, nOutValue))
	    {
		if (nInValue != nOutValue)
		{
		    goto notFoundexit;
		}
	    }
	    else
	    {
		goto notFoundexit;
	    }
	}
    }

    // Test code to look at all of the data in the map.
#ifdef _DEBUG
    HX_RESULT tempresult;

    tempresult = HXR_OK;

    tempresult = m_pValues->GetFirstPropertyCString(pPropName, pInBuffer);
    HX_RELEASE(pInBuffer);

    while (tempresult == HXR_OK)
    {
	tempresult = m_pValues->GetNextPropertyCString(pPropName, pInBuffer);
	if (tempresult == HXR_OK)
	{
	    HX_RELEASE(pInBuffer);
	}
    }
#endif /*_DEBUG*/

    // Check String Props.
    if (HXR_OK == pValues->GetFirstPropertyCString(pPropName, pInBuffer))
    {
	if (HXR_OK == m_pValues->GetPropertyCString(pPropName, pOutBuffer))
	{
	    if (!AreBufferEqual(pOutBuffer, pInBuffer))
	    {
		goto notFoundexit;
	    }
	}
	else
	{
	    goto notFoundexit;
	}

	HX_RELEASE(pInBuffer);
	HX_RELEASE(pOutBuffer);

	while (HXR_OK == pValues->GetNextPropertyCString(pPropName, pInBuffer))
	{
	    if (HXR_OK == m_pValues->GetPropertyCString(pPropName, pOutBuffer))
	    {
		if ( !AreBufferEqual(pOutBuffer, pInBuffer))
		{
		    goto notFoundexit;
		}
	    }
	    else
	    {
		goto notFoundexit;
	    }

	    HX_RELEASE(pInBuffer);
	    HX_RELEASE(pOutBuffer);
	}
    }


     // Check Buffer Properties
    if (HXR_OK == pValues->GetFirstPropertyBuffer(pPropName, pInBuffer))
    {
	// XXXND  Make some utility functions for doing this...
	if (HXR_OK == m_pValues->GetPropertyBuffer(pPropName, pOutBuffer))
	{
	    if( pOutBuffer->GetSize() == pInBuffer->GetSize() )
	    {
		if( ::memcmp( pOutBuffer->GetBuffer(), pInBuffer->GetBuffer(), pOutBuffer->GetSize() ) )
		{
		    goto notFoundexit;
		}
	    }
	}
	else
	{
	    goto notFoundexit;
	}

	HX_RELEASE(pInBuffer);
	HX_RELEASE(pOutBuffer);

	while (HXR_OK == pValues->GetNextPropertyBuffer(pPropName, pInBuffer))
	{
	    if (HXR_OK == m_pValues->GetPropertyBuffer(pPropName, pOutBuffer))
	    {
		// XXXND  Make some utility functions for doing this...
		if( pOutBuffer->GetSize() == pInBuffer->GetSize() )
		{
		    if( ::memcmp( pOutBuffer->GetBuffer(), pInBuffer->GetBuffer(), pOutBuffer->GetSize() ) )
		    {
			goto notFoundexit;
		    }
		}
	    }
	    else
	    {
		goto notFoundexit;
	    }

	    HX_RELEASE(pInBuffer);
	    HX_RELEASE(pOutBuffer);
	}
    }

    return TRUE;    // we made it!

notFoundexit:
    HX_RELEASE(pInBuffer);
    HX_RELEASE(pOutBuffer);
    return FALSE;
}

void	BaseHandler::Plugin::SetDLL(PluginDLL * pPluginDll)
{
    m_pPluginDLL = pPluginDll;
    m_pPluginDLL->AddRef();

    IHXBuffer* pBuffer = pPluginDll->GetFileName();
    HX_ASSERT(pBuffer);

    m_pValues->SetPropertyCString(PLUGIN_FILENAME, pBuffer);
    HX_RELEASE(pBuffer);
}

void	BaseHandler::Plugin::SetIndex(UINT16 nIndex)
{
    m_nPluginIndex = nIndex;
    m_pValues->SetPropertyULONG32(PLUGIN_INDEX, nIndex);
}


void	BaseHandler::Plugin::SetPropertyULONG32(char* pName, char* pValue)
{
    if (m_pValues)
    {
	m_pValues->SetPropertyULONG32(pName, atoi(pValue));
    }
}

void	BaseHandler::Plugin::SetPropertyCString(char* pName, char* pValue)
{
    if (m_pValues)
    {
	IHXBuffer* pTempBuffer = new CHXBuffer();
	pTempBuffer->AddRef();
	pTempBuffer->Set((UCHAR*)pValue, strlen(pValue)+1);
	m_pValues->SetPropertyCString(pName, pTempBuffer);
	HX_RELEASE(pTempBuffer);
    }
}

void	BaseHandler::Plugin::SetPropertyBuffer(char* pName, BYTE* pData, UINT32 size )
{
    if (m_pValues)
    {
	// XXXND  FIX  THis really shouldn't have to do this copy
	IHXBuffer* pTempBuffer = new CHXBuffer();
	pTempBuffer->AddRef();
	pTempBuffer->Set( pData, size );
	m_pValues->SetPropertyBuffer(pName, pTempBuffer);
	HX_RELEASE(pTempBuffer);
    }
}

BOOL BaseHandler::Plugin::AreBufferEqual(IHXBuffer* pBigBuff,
					   IHXBuffer* pSmallBuff)
{
    char*   pTemp;
    BOOL    bRetVal = FALSE;

    pTemp = new char[pBigBuff->GetSize()];
    strcpy(pTemp, (char*)pBigBuff->GetBuffer()); /* Flawfinder: ignore */

    char* token;
    token = strtok(pTemp, zm_pszValueSeperator);
    while (token)
    {
	CHXString tokenCHXstring;
	CHXString smallCHXstring;

	tokenCHXstring = token;
	smallCHXstring = (char*)pSmallBuff->GetBuffer();
	tokenCHXstring.TrimLeft();
	tokenCHXstring.TrimRight();
	smallCHXstring.TrimLeft();
	smallCHXstring.TrimRight();

	if (!strcasecmp(tokenCHXstring, smallCHXstring))
	{
	    bRetVal = TRUE;
	    break;
	}
	token = strtok(NULL, zm_pszValueSeperator);
    }
    delete[] pTemp;

    return bRetVal;
}

BaseHandler::Errors BaseHandler::Plugin::GetValuesFromDLL(IHXPlugin* pHXPlugin)
{
    BaseHandler::Errors  retVal;

    retVal = GetBasicValues(pHXPlugin);
    if (retVal == NO_ERRORS)
    {
	retVal = GetExtendedValues(pHXPlugin);
    }
    return retVal;
}

BaseHandler::Errors BaseHandler::Plugin::GetPlugin(REF(IUnknown*) pUnknown )
{
    pUnknown = NULL;
    BaseHandler::Errors retVal = NO_ERRORS;

    if (!m_pPluginDLL)
    {
	return PLUGIN_NOT_FOUND;
    }
    if (!m_pPluginDLL->IsLoaded())
    {
	if (NO_ERRORS != (retVal = m_pPluginDLL->Load(m_pContext)))
	{
	    return retVal;
	}
    }
    if (HXR_OK != m_pPluginDLL->CreateInstance(&pUnknown, m_nPluginIndex))
    {
	return CREATE_INSTANCHXR_FAILURE;
    }

    return retVal;
}


BaseHandler::Errors BaseHandler::Plugin::GetInstance(REF(IUnknown*) pUnknown, IUnknown* pIUnkOuter )
{
    // Initialize out parameter
    pUnknown = NULL;

    IUnknown* pIUnkPlugin = NULL;
    BaseHandler::Errors retVal = GetPlugin( pIUnkPlugin );
    if( retVal == NO_ERRORS )
    {
	IHXComponentPlugin* pIComp = NULL;
	if( SUCCEEDED( pIUnkPlugin->QueryInterface( IID_IHXComponentPlugin, (void**) &pIComp ) ) )
	{
	    // Ask for the correct object by CLSID
	    IHXBuffer* pCLSID = NULL;
	    if( SUCCEEDED( m_pValues->GetPropertyBuffer( PLUGIN_COMPONENT_CLSID, pCLSID ) ) )
	    {
		if( FAILED( pIComp->CreateComponentInstance( *(GUID*) pCLSID->GetBuffer(), pUnknown, pIUnkOuter ) ) )
		{
		    retVal = CREATE_INSTANCHXR_FAILURE;
		}
		HX_RELEASE( pCLSID );
	    }
	    else
	    {
		// Hmmm...we have a component plugin without a CLSID.  Serious internal error
		retVal = BAD_PLUGIN;
	    }

	    // Release the interface, and destroy the plugin
	    HX_RELEASE( pIComp );
	    HX_RELEASE( pIUnkPlugin );
	}
	else