pxff2.cpp

linux下的一款播放器

            {
                bShutdownCalled = TRUE;
                pHandler->Shutdown();
            }
        }
    }

    // If we are coming from GetFileHeader() and we had all the sizes of
    // all the images provided for us, then we might not be shutting down
    // any file handlers here. Therefore, if we didn't call Shutdown()
    // on any file handlers here, then we need to short-circuit the
    // async loop and call ShutdownDone() here.
    if (!bShutdownCalled)
    {
        ShutdownDone(HXR_OK, 0);
    }
}

void CRealPixFileFormat::ReleaseAllFileHandlers()
{
    if (m_pFileHandlerArray)
    {
        UINT32 ulNumHandlers = (UINT32) m_pFileHandlerArray->GetSize();
        for (UINT32 i = 0; i < ulNumHandlers; i++)
        {
            PXFileHandler* pHandler = (PXFileHandler*) m_pFileHandlerArray->GetAt(i);
            HX_RELEASE(pHandler);
        }
        m_pFileHandlerArray->RemoveAll();
    }
}

void CRealPixFileFormat::ReportError(UINT32 ulErrorID, const char* pszArg1, const char* pszArg2,
                                     const UINT8 ucSeverity, HX_RESULT ulHXCode)
{
    if (m_pContext)
    {
        IHXBuffer* pErrStr = NULL;
        PXError     cErr(m_pContext);
        cErr.SetError(ulErrorID, pszArg1, pszArg2, pErrStr);
        if (pErrStr)
        {
            ReportError(ucSeverity, ulHXCode, pErrStr);
        }
        HX_RELEASE(pErrStr);
    }
}

void CRealPixFileFormat::ReportError(const UINT8 ucSeverity,
                                     HX_RESULT   ulHXCode,
                                     IHXBuffer* pErrorStr)
{
    if (pErrorStr)
    {
        if (m_pContext)
        {
            IHXErrorMessages* pErrorMessages = NULL;
            m_pContext->QueryInterface(IID_IHXErrorMessages, (void**) &pErrorMessages);
            if (pErrorMessages)
            {
                pErrorMessages->Report(ucSeverity,                           // severity
                                       ulHXCode,                            // RMA result (i.e. - HXR_FAIL, HXR_OUTOFMEMORY, etc.)
                                       0,                                    // user code (not used here)
                                       (const char*) pErrorStr->GetBuffer(), // string to be displayed
                                       NULL);                                // more info string (not used here)
            }
            HX_RELEASE(pErrorMessages);
        }
    }
}

HX_RESULT CRealPixFileFormat::GetRegistrySettings(REF(BOOL)   rbLicensed,
                                                  REF(UINT32) rulStrictnessLevel)
{
    HX_RESULT retVal = HXR_OK;

    // Set defaults
    rbLicensed         = FALSE;
    rulStrictnessLevel = REALPIX_STRICTNESS_LOW;

    IHXRegistry* pRegistry = NULL;
    retVal                    = m_pContext->QueryInterface(IID_IHXRegistry, (void**) &pRegistry);
    if (SUCCEEDED(retVal))
    {
        // Figure out if RealPix is licensed
        IHXPlayer* pPlayer = NULL;
        m_pContext->QueryInterface(IID_IHXPlayer, (void**) &pPlayer);
        if (pPlayer)
        {
            // RealPix is always licensed on the player
            rbLicensed = TRUE;
        }
        else
        {
            // On the Server, check the license section of the registry
            INT32     lLicensed = 0;
            HX_RESULT rv        = pRegistry->GetIntByName(REGISTRY_REALPIX_ENABLED, lLicensed);
            if (FAILED(rv))
            {
                lLicensed = LICENSE_REALPIX_ENABLED;
            }
            rbLicensed = (lLicensed ? TRUE : FALSE);
        }
        HX_RELEASE(pPlayer);

        INT32     lLevel = 0;
        HX_RESULT rv     = pRegistry->GetIntByName("config.RealPixStrictnessLevel", lLevel);
        if (SUCCEEDED(rv))
        {
            rulStrictnessLevel = (UINT32) lLevel;
        }
    }
    HX_RELEASE(pRegistry);

    return retVal;
}

HX_RESULT CRealPixFileFormat::CheckForCodecs(REF(IHXBuffer*) rpImageNameStr)
{
    HX_RESULT retVal = HXR_OK;

    if (m_pRealPixFile && m_pCodecManager)
    {
        if (m_pRealPixFile->GetNumImages() > 0)
        {
            // Loop through all the images, checking to make sure
            // we have all the codecs we need
            IHXBuffer* pImageName         = NULL;
            IHXBuffer* pImageFileMimeType = NULL;
            void*       pItr               = NULL;
            retVal                         = m_pRealPixFile->GetImageIterator(pItr);
            if (SUCCEEDED(retVal))
            {
                UINT32    ulHandle = 0;
                HX_RESULT rv       = m_pRealPixFile->GetNextImageHandle(pItr, ulHandle);
                while (SUCCEEDED(rv) && SUCCEEDED(retVal))
                {
                    // Get the image name
                    HX_RELEASE(pImageName);
                    m_pRealPixFile->GetImageName(ulHandle, pImageName);
                    // Get the image file mime type
                    HX_RELEASE(pImageFileMimeType);
                    m_pRealPixFile->GetImageFileMimeType(ulHandle, pImageFileMimeType);
                    // Check if this codec is present
                    if (m_pCodecManager->IsCodecPresent((pImageFileMimeType ? (const char*) pImageFileMimeType->GetBuffer() : (const char *)NULL),
                                                        (pImageName ? (const char*) pImageName->GetBuffer() : (const char*)NULL),
                                                        NULL))
                    {
                        rv = m_pRealPixFile->GetNextImageHandle(pItr, ulHandle);
                    }
                    else
                    {
                        // Copy the bad image to the out param
                        if (pImageName)
                        {
                            HX_RELEASE(rpImageNameStr);
                            rpImageNameStr = pImageName;
                            rpImageNameStr->AddRef();
                        }
                        retVal = HXR_FAIL;
                    }
                }
            }
            HX_RELEASE(pImageName);
            HX_RELEASE(pImageFileMimeType);
        }
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

HX_RESULT CRealPixFileFormat::AddCodecsToWireFormatManager()
{
    HX_RESULT retVal = HXR_OK;

    if (m_pRealPixFile && m_pCodecManager && m_pWireFormatManager)
    {
        if (m_pRealPixFile->GetNumImages() > 0)
        {
            // Run through the list, adding codecs to the wire format manager
            void* pItr = NULL;
            retVal     = m_pRealPixFile->GetImageIterator(pItr);
            if (SUCCEEDED(retVal))
            {
                UINT32    ulHandle = 0;
                HX_RESULT rv       = m_pRealPixFile->GetNextImageHandle(pItr, ulHandle);
                while (SUCCEEDED(rv) && SUCCEEDED(retVal))
                {
                    IHXRealPixFileFormatCodec* pCodec = NULL;
                    retVal = m_pCodecManager->GetCodec(m_pRealPixFile->GetImageFileMimeType(ulHandle),
                                                       m_pRealPixFile->GetImageName(ulHandle),
                                                       NULL,
                                                       pCodec);
                    if (SUCCEEDED(retVal))
                    {
                        const char** ppszFileExt       = NULL;
                        const char** ppszFileMime      = NULL;
                        const char*  pszStreamMimeType = NULL;
                        UINT32       ulStreamVersion   = 0;
                        UINT32       ulMaxPerImg       = 0;
                        UINT32       ulMaxPerPckt      = 0;
                        retVal = pCodec->GetFileFormatCodecInfo(ppszFileExt, ppszFileMime,
                                                                pszStreamMimeType, ulStreamVersion,
                                                                ulMaxPerImg, ulMaxPerPckt);
                        if (SUCCEEDED(retVal))
                        {
                            // Set the stream mime back into the image
                            retVal = m_pRealPixFile->SetImageStreamMimeType(ulHandle, pszStreamMimeType);
                            if (SUCCEEDED(retVal))
                            {
                                // Add it to the wire format codec list
                                retVal = m_pWireFormatManager->AddCodecMime(pszStreamMimeType);
                                if (SUCCEEDED(retVal))
                                {
                                    // Tell the codec manager that this codec is active
                                    retVal = m_pCodecManager->SetActiveComponent(pszStreamMimeType);
                                    if (SUCCEEDED(retVal))
                                    {
                                        // Get the next image
                                        rv = m_pRealPixFile->GetNextImageHandle(pItr, ulHandle);
                                    }
                                }
                            }
                        }
                    }
                    HX_RELEASE(pCodec);
                }
            }
        }
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

HX_RESULT CRealPixFileFormat::ParseRealPixFile(IHXBuffer*    pBuffer,
                                               PXRealPixFile* pRealPixFile,
                                               UINT32         ulStrictnessLevel)
{
    HX_RESULT retVal = HXR_OK;

    if (pBuffer && pRealPixFile)
    {
#ifdef XXXMEH_USE_NEW_PARSER
        // Create a PXRealPixParser object
        PXRealPixParser* pParser = NULL;
        retVal                   = PXRealPixParser::CreateObject(&pParser);
        if (SUCCEEDED(retVal))
        {
            // AddRef the parser object
            pParser->AddRef();
            // Init the parser
            retVal = pParser->Init(m_pContext, m_pRealPixFile, ulStrictnessLevel);
            if (SUCCEEDED(retVal))
            {
                // Parse the file
                IHXBuffer* pErrorStr = NULL;
                retVal                = pParser->Parse(pBuffer, TRUE, pErrorStr);
                if (FAILED(retVal))
                {
                    ReportError(HXLOG_CRIT, retVal, pErrorStr);
                }
                HX_RELEASE(pErrorStr);
            }
        }
        HX_RELEASE(pParser);
#else
        // We found <imfl> so use the lax parser
        CIMFFileObject cOldParser;
        GString        cBuf((const char*) pBuffer->GetBuffer(),
                            pBuffer->GetSize(), GSTRING_REFMODE);
        UINT32         ulErrorID;
        CHXString      cErrorText;
        BOOL bRet = cOldParser.InitFromText(cBuf, ulErrorID, cErrorText);
        if (bRet)
        {
            retVal = cOldParser.ConvertToNewFileObject(m_pRealPixFile);
            if (SUCCEEDED(retVal))
            {
                retVal = m_pRealPixFile->PostParseInit();
            }
        }
        else
        {
            const char* pszErr = (const char*) cErrorText;
            const char* pszArg = (strlen(pszErr) > 0 ? pszErr : (const char*) NULL);
            ReportError(ulErrorID, pszArg, NULL, HXLOG_CRIT, HXR_FAIL);
            retVal = HXR_FAIL;
        }
#endif
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

void CRealPixFileFormat::SendFailPacket(HX_RESULT retVal)
{
    if (m_pCommonClassFactory && m_pFileFormatResponse)
    {
        // Create an IHXPacket
        IHXPacket* pPacket = NULL;
        m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket, (void**) &pPacket);
        if (pPacket)
        {
            // Set a NULL buffer and the stream number
            pPacket->Set(NULL, 0, 0, HX_ASM_SWITCH_ON, 0);
            // Call the response interface
            m_pFileFormatResponse->PacketReady(retVal, pPacket);
        }
        HX_RELEASE(pPacket);
    }
}
/************************************************************************
 *      Method:
 *          IHXThreadSafeMethods::IsThreadSafe
 */
STDMETHODIMP_(UINT32)
CRealPixFileFormat::IsThreadSafe()
{
    return HX_THREADSAFE_METHOD_FF_GETPACKET;
}