filehdlr.cpp

linux下的一款播放器

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

    if (IsEqualIID(riid, IID_IUnknown))
    {
        AddRef();
        *ppvObj = this;
    }
    else if (IsEqualIID(riid, IID_IHXFileSystemManagerResponse))
    {
        AddRef();
        *ppvObj = (IHXFileSystemManagerResponse*) this;
    }
    else if (IsEqualIID(riid, IID_IHXFileResponse))
    {
        AddRef();
        *ppvObj = (IHXFileResponse*) this;
    }
    else if (IsEqualIID(riid, IID_IHXFileStatResponse))
    {
        AddRef();
        *ppvObj = (IHXFileStatResponse*) this;
    }
    else if (IsEqualIID(riid, IID_IHXFileMimeMapperResponse))
    {
        AddRef();
        *ppvObj = (IHXFileMimeMapperResponse*) this;
    }
    else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
    {
        AddRef();
        *ppvObj = (IHXThreadSafeMethods*) this;
    }
    else
    {
        *ppvObj = NULL;
        retVal  = HXR_NOINTERFACE;
    }

    return retVal;
}

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

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

    delete this;

    return 0;
}

STDMETHODIMP PXFileHandler::InitDone(HX_RESULT status)
{
#ifdef XXXMEH_DEBUG_LOG
    DEBUG_OUTF("c:\\pxff.log", (s, "PXFileHandler::InitDone(0x%08X,0x%08x) ",
               this, status));
#endif
    HX_RESULT retVal = HXR_OK;

    if (m_ulState == kStateStatImageFileFSMInit)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileFSMInit\n"));
#endif
        if (SUCCEEDED(status))
        {
            // Set the state
            m_ulState  = kStateStatImageFileCreate;
            // Create the file
            retVal     = CreateImageFile((const char*) m_pImageNameStr->GetBuffer());
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(status, m_ulInstance, 0, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(retVal, m_ulInstance, 0, NULL);
        }
    }
    else if (m_ulState == kStateReadImageFileFSMInit)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadImageFileFSMInit\n"));
#endif
        if (SUCCEEDED(status))
        {
            // Set the state
            m_ulState  = kStateReadImageFileCreate;
            // Create the file
            retVal = CreateImageFile((const char*) m_pImageNameStr->GetBuffer());
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(status, m_ulInstance, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(retVal, m_ulInstance, NULL);
        }
    }
    else if (m_ulState == kStateReadRPFileInit)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadRPFileInit\n"));
#endif
        if (SUCCEEDED(status))
        {
            // Create an IHXFragmentedBuffer object
            HX_RELEASE(m_pFragBuffer);
            retVal = CHXFragmentedBuffer::CreateObject((CHXFragmentedBuffer**) &m_pFragBuffer);
            if (SUCCEEDED(retVal))
            {
                // Addref the object
                m_pFragBuffer->AddRef();
// XXXMEH - when IHXFragmentedBuffer gets added to the CCF, then
// reinstate this code
//            retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXFragmentedBuffer,
//                                                           (void**) &m_pFragBuffer);
//            if (SUCCEEDED(retVal))
//            {
                // Initialize the number of bytes read
                m_ulFileBytesRead = 0;
                // Set the new state
                m_ulState         = kStateReadRPFileRead;
		if (m_ulReadChunkSize < kRPMinFileReadSize)
		{
		    m_ulReadChunkSize = kRPMinFileReadSize;
		}
		else if (m_ulReadChunkSize > kRPMaxFileReadSize)
		{
		    m_ulReadChunkSize = kRPMaxFileReadSize;
		}
                // Read kRPFileReadSize bytes of the file at a time
                m_pRPFileObject->Read(m_ulReadChunkSize);
            }
        }
        else
        {
            retVal = status;
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->ReadRPFileDone(retVal, NULL);
        }
    }
    else if (m_ulState == kStateStatImageFileInit)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileInit\n"));
#endif
        if (SUCCEEDED(status))
        {
            // Get an IHXFileStat interface
            HX_RELEASE(m_pFileStat);
            retVal = m_pFileObject->QueryInterface(IID_IHXFileStat, (void**) &m_pFileStat);
            if (SUCCEEDED(retVal))
            {
                // Set the new state
                m_ulState = kStateStatImageFileStat;
                // Call Stat()
                m_pFileStat->Stat(this);
            }
        }
        else
        {
            // Set the state saying we failed to stat
            m_ulState = kStateStatImageFileFailClose;
            // Close the file
            m_pFileObject->Close();
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            retVal    = m_pResponse->StatImageFileDone(retVal, m_ulInstance, 0, NULL);
        }
    }
    else if (m_ulState == kStateReadImageFileInit)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadImageFileInit\n"));
#endif
        if (SUCCEEDED(status))
        {
            // Create an IHXFragmentedBuffer object
            HX_RELEASE(m_pFragBuffer);
            retVal = CHXFragmentedBuffer::CreateObject((CHXFragmentedBuffer**) &m_pFragBuffer);
            if (SUCCEEDED(retVal))
            {
                // Addref the object
                m_pFragBuffer->AddRef();
//            retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXFragmentedBuffer,
//                                                           (void**) &m_pFragBuffer);
//            if (SUCCEEDED(retVal))
//            {
                // Init the bytes read counter
                m_ulFileBytesRead = 0;
                // Set the state
                m_ulState         = kStateReadImageFileRead;
		if (m_ulReadChunkSize < kImageMinFileReadSize)
		{
		    m_ulReadChunkSize = kImageMinFileReadSize;
		}
		else if (m_ulReadChunkSize > kImageMaxFileReadSize)
		{
		    m_ulReadChunkSize = kImageMaxFileReadSize;
		}
                // Read the first kImageFileReadSize bytes of the file
                m_pFileObject->Read(m_ulReadChunkSize);
            }
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(status, m_ulInstance, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(retVal, m_ulInstance, NULL);
        }
    }
    else if (m_ulState == kStateShutdownClose ||
             m_ulState == kStateShutdownDone)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateShutdownClose\n"));
#endif
        // We got shutdown while we were waiting on a callback,
        // so we do nothing
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

STDMETHODIMP PXFileHandler::FileObjectReady(HX_RESULT status, IUnknown* pObject)
{
#ifdef XXXMEH_DEBUG_LOG
    DEBUG_OUTF("c:\\pxff.log", (s, "PXFileHandler::FileObjectReady(0x%08X,0x%08x,0x%08x) ",
               this, status, pObject));
#endif
    HX_RESULT retVal = HXR_OK;

    if (m_ulState == kStateStatImageFileCreate)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileCreate\n"));
#endif
        // We no longer need the IHXFileSystemManager interface
        HX_RELEASE(m_pFileSystemManager);
        if (SUCCEEDED(status))
        {
            // Get an IHXFileObject interface
            HX_RELEASE(m_pFileObject);
            retVal = pObject->QueryInterface(IID_IHXFileObject, (void**) &m_pFileObject);
            if (SUCCEEDED(retVal))
            {
                // Set the state
                m_ulState = kStateStatImageFileInit;
                // Init the file object
                m_pFileObject->Init(HX_FILE_READ | HX_FILE_BINARY, this);
            }
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(status, m_ulInstance, 0, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(retVal, m_ulInstance, 0, NULL);
        }
    }
    else if (m_ulState == kStateReadImageFileCreate)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadImageFileCreate\n"));
#endif
        // We no longer need the IHXFileSystemManager interface
        HX_RELEASE(m_pFileSystemManager);
        if (SUCCEEDED(status))
        {
            // Get an IHXFileObject interface
            retVal = pObject->QueryInterface(IID_IHXFileObject, (void**) &m_pFileObject);
            if (SUCCEEDED(retVal))
            {
                // Set the state
                m_ulState = kStateReadImageFileInit;
                // Init the file object
                m_pFileObject->Init(HX_FILE_READ | HX_FILE_BINARY, this);
            }
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(status, m_ulInstance, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->ReadImageFileDone(retVal, m_ulInstance, NULL);
        }
    }
    else if (m_ulState == kStateShutdownClose ||
             m_ulState == kStateShutdownDone)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateShutdownClose\n"));
#endif
        // We got shutdown while we were waiting on a pending
        // callback, so we do nothing here
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

STDMETHODIMP PXFileHandler::DirObjectReady(HX_RESULT status, IUnknown* pDirObject)
{
    return HXR_NOTIMPL;
}

STDMETHODIMP PXFileHandler::CloseDone(HX_RESULT status)
{
#ifdef XXXMEH_DEBUG_LOG
    DEBUG_OUTF("c:\\pxff.log", (s, "PXFileHandler::CloseDone(0x%08X,0x%08x) ",
               this, status));
#endif
    HX_RESULT retVal = HXR_OK;

    if (m_ulState == kStateReadRPFileClose)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadRPFileClose\n"));
#endif
        retVal = HXR_UNEXPECTED;

        if (FAILED(retVal))
        {
            m_pResponse->ReadRPFileDone(retVal, NULL);
        }
    }
    else if (m_ulState == kStateStatImageFileClose)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileClose\n"));
#endif
        // Now we can release the file object
        HX_RELEASE(m_pFileObject);

        if (SUCCEEDED(status))
        {
            // Set the state
            m_ulState = kStateStatImageFileDone;
            // Call the response back
            m_pResponse->StatImageFileDone(status, m_ulInstance, m_ulImageFileSize, m_pImageMimeTypeStr);
        }
        else
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(status, m_ulInstance, 0, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            m_pResponse->StatImageFileDone(retVal, m_ulInstance, 0, NULL);
        }
    }
    else if (m_ulState == kStateStatImageFileFailClose)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileFailClose\n"));
#endif
        // Now we can release the file object
        HX_RELEASE(m_pFileObject);

        // Set the state
        m_ulState = kStateError;

        // Call back - we don't care about the status,
        // caused we failed to stat the image anyway
        m_pResponse->StatImageFileDone(HXR_FAIL, m_ulInstance, 0, NULL);
    }
    else if (m_ulState == kStateReadImageFileClose)
    {