filehdlr.cpp

linux下的一款播放器

#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadImageFileClose\n"));
#endif
        // Check to make sure we have actually read some bytes
        if (SUCCEEDED(status) && m_ulFileBytesRead > 0)
        {
            // Get an IHXBuffer interface from the IHXFragmentedBuffer
            IHXBuffer* pWholeBuffer = NULL;
            retVal                   = m_pFragBuffer->QueryInterface(IID_IHXBuffer,
                                                                     (void**) &pWholeBuffer);
            if (SUCCEEDED(retVal))
            {
		// Now we can release the fragmented buffer interface
		HX_RELEASE(m_pFragBuffer);
                // Set the state
                m_ulState = kStateReadImageFileDone;
                // We're done, so inform the response interface
                m_pResponse->ReadImageFileDone(retVal, m_ulInstance, pWholeBuffer);
            }
            HX_RELEASE(pWholeBuffer);
        }
        else
        {
            retVal = HXR_FAIL;
        }

        if (FAILED(retVal))
        {
            m_pResponse->ReadImageFileDone(retVal, m_ulInstance, NULL);
        }
    }
    else if (m_ulState == kStateShutdownClose)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateShutdownClose\n"));
#endif
        // We got called with Shutdown() and then a 
        // Close() on the file object. Therefore, we need
        // to callback with ShutdownDone() instead of the
        // normal callback.
        //
        // Set the state to the final state
        m_ulState = kStateShutdownDone;
        // Call back with ShutdownDone()
        m_pResponse->ShutdownDone(status, m_ulInstance);
    }
    else if (m_ulState == kStateShutdownDone)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateShutdownDone\n"));
#endif
        retVal = HXR_OK;
    }
    else if (m_ulState == kStateReadRPFileHold)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadRPFileHold\n"));
#endif
        m_ulState = kStateShutdownDone;
    }
    else
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "UNEXPECTED STATE\n"));
#endif
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}


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

    if (m_ulState == kStateReadRPFileRead)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadRPFileRead\n"));
#endif
        if (SUCCEEDED(status))
        {
            retVal = m_pFragBuffer->Append(pBuffer, 0, pBuffer->GetSize());
            if (SUCCEEDED(retVal))
            {
                m_ulFileBytesRead += pBuffer->GetSize();
            }
        }

        if (SUCCEEDED(retVal))
        {
            if ((SUCCEEDED(status) && pBuffer->GetSize() < m_ulReadChunkSize) || FAILED(status))
            {
                if (m_ulFileBytesRead > 0)
                {
                    // Get an IHXBuffer interface from the IHXFragmentedBuffer
                    IHXBuffer* pWholeBuffer = NULL;
                    retVal                   = m_pFragBuffer->QueryInterface(IID_IHXBuffer,
                                                                             (void**) &pWholeBuffer);
                    if (SUCCEEDED(retVal))
                    {
			// Now we can release the fragmented buffer interface
			HX_RELEASE(m_pFragBuffer);
                        // Set the state
                        m_ulState = kStateReadRPFileHold;
                        // We're done, so inform the response interface
                        m_pResponse->ReadRPFileDone(retVal, pWholeBuffer);
                    }
                    HX_RELEASE(pWholeBuffer);
                }
                else
                {
                    retVal = HXR_FAIL;
                }
            }
            else
            {
                // Set the state (actually, we'll keep it the same)
                m_ulState = kStateReadRPFileRead;
                // Do another read
                m_pRPFileObject->Read(m_ulReadChunkSize);
            }
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            retVal    = m_pResponse->ReadRPFileDone(retVal, NULL);
        }
    }
    else if (m_ulState == kStateReadImageFileRead)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateReadImageFileRead\n"));
#endif
        if (SUCCEEDED(status))
        {
            retVal = m_pFragBuffer->Append(pBuffer, 0, pBuffer->GetSize());
            if (SUCCEEDED(retVal))
            {
                m_ulFileBytesRead += pBuffer->GetSize();
            }
        }

        if (SUCCEEDED(retVal))
        {
            if ((SUCCEEDED(status) && pBuffer->GetSize() < m_ulReadChunkSize) || FAILED(status))
            {
                // Set the state
                m_ulState = kStateReadImageFileClose;
                // Close the file
                m_pFileObject->Close();
            }
            else
            {
                // Set the state (actually, we'll keep it the same)
                m_ulState = kStateReadImageFileRead;
                // Do another read
                m_pFileObject->Read(m_ulReadChunkSize);
            }
        }

        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 called with a Shutdown() while we were
        // waiting on a pending ReadDone() call. Therefore,
        // we do nothing here.
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

STDMETHODIMP PXFileHandler::WriteDone(HX_RESULT status)
{
    HX_RESULT retVal = HXR_NOTIMPL;

    return retVal;
}

STDMETHODIMP PXFileHandler::SeekDone(HX_RESULT status)
{
    HX_RESULT retVal = HXR_NOTIMPL;

    return retVal;
}

STDMETHODIMP PXFileHandler::StatDone(HX_RESULT status, UINT32 ulSize, UINT32 ulCreationTime,
                                     UINT32 ulAccessTime, UINT32 ulModificationTime, UINT32 ulMode)
{
#ifdef XXXMEH_DEBUG_LOG
    DEBUG_OUTF("c:\\pxff.log", (s, "PXFileHandler::StatDone(0x%08X,0x%08x,%lu,...) ",
               this, status, ulSize));
#endif
    HX_RESULT retVal = HXR_OK;

    if (m_ulState == kStateStatImageFileStat)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileStat\n"));
#endif
        // We don't need the IHXFileStat interface anymore
        HX_RELEASE(m_pFileStat);

        // Save the size
        m_ulImageFileSize = ulSize;

        if (SUCCEEDED(status))
        {
            // See if we can get an IHXFileMimeMapper interface
            HX_RELEASE(m_pFileMimeMapper);
            HX_RESULT rv = m_pFileObject->QueryInterface(IID_IHXFileMimeMapper,
                                                         (void**) &m_pFileMimeMapper);
            if (SUCCEEDED(rv))
            {
                // Set the state
                m_ulState = kStateStatImageFileMime;
                // Get the mime type
                m_pFileMimeMapper->FindMimeType((const char*) m_pImageNameStr->GetBuffer(), this);
            }
            else
            {
                // Set the state
                m_ulState = kStateStatImageFileClose;
                // Make sure the mime type is NULL'd out
                HX_RELEASE(m_pImageMimeTypeStr);
                // We can close the file
                m_pFileObject->Close();
            }
        }
        else
        {
            m_ulState = kStateError;
            retVal    = m_pResponse->StatImageFileDone(status, m_ulInstance, 0, NULL);
        }

        if (FAILED(retVal))
        {
            m_ulState = kStateError;
            retVal    = m_pResponse->StatImageFileDone(retVal, m_ulInstance, 0, 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 called with a Shutdown() while we were
        // waiting on a pending StatDone() call. Therefore,
        // we do nothing here.
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

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

    if (m_ulState == kStateStatImageFileMime)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateStatImageFileMime\n"));
#endif
        // Make sure the mime type is NULL'd out
        HX_RELEASE(m_pImageMimeTypeStr);

        if (SUCCEEDED(status) && pMimeType)
        {
            // Put the mime type string into an IHXBuffer
            retVal = m_pCommonClassFactory->CreateInstance(CLSID_IHXBuffer,
                                                           (void**) &m_pImageMimeTypeStr);
            if (SUCCEEDED(retVal))
            {
                retVal = m_pImageMimeTypeStr->Set((const BYTE*) pMimeType,
                                                  strlen(pMimeType) + 1);
            }
        }

        // We no longer need the IHXFileMimeMapper interface
        HX_RELEASE(m_pFileMimeMapper);

        // Set the state
        m_ulState = kStateStatImageFileClose;
        // We can close the file
        m_pFileObject->Close();
    }
    else if (m_ulState == kStateShutdownClose ||
             m_ulState == kStateShutdownDone)
    {
#ifdef XXXMEH_DEBUG_LOG
        DEBUG_OUTF("c:\\pxff.log", (s, "state = kStateShutdownClose\n"));
#endif
        // We got called with a Shutdown() while we were
        // waiting on a pending MimeTypeFound() call. Therefore,
        // we do nothing here.
        retVal = HXR_OK;
    }
    else
    {
        retVal = HXR_UNEXPECTED;
    }

    return retVal;
}

void PXFileHandler::Reset()
{
    m_ulState         = kStateConstructed;
    m_ulFileBytesRead = 0;
    m_ulInstance      = 0;
    m_ulImageFileSize = 0;
    m_ulReadChunkSize = 0;
}

void PXFileHandler::Deallocate()
{
    HX_RELEASE(m_pContext);
    HX_RELEASE(m_pRPFileObject);
    HX_RELEASE(m_pResponse);
    HX_RELEASE(m_pCommonClassFactory);
    HX_RELEASE(m_pFileSystemManager);
    HX_RELEASE(m_pFileObject);
    HX_RELEASE(m_pFragBuffer);
    HX_RELEASE(m_pImageNameStr);
    HX_RELEASE(m_pImageMimeTypeStr);
    HX_RELEASE(m_pFileStat);
    HX_RELEASE(m_pFileMimeMapper);
}

HX_RESULT PXFileHandler::CreateImageFile(const char* pszImageName)
{
    HX_RESULT retVal = HXR_OK;

    if (pszImageName)
    {
        if (m_pCommonClassFactory && m_pRPFileObject)
        {
            // First determine if this is relative or absolute
            if (strstr(pszImageName, "://") || pszImageName[0] == '/' || pszImageName[0] == '\\')
            {
                // Protocol string found or mount slash found - it's an "absolute" path - use
                // IHXFileSystemManager::GetNewFileObject to get the
                // file object for this file
                IHXRequest* pRequest = NULL;
                retVal                = m_pCommonClassFactory->CreateInstance(CLSID_IHXRequest,
                                                                              (void **) &pRequest);
                if (SUCCEEDED(retVal))
                {
                    // Set the URL
                    pRequest->SetURL(pszImageName);
                    // Call IHXFileSystemManager::GetNewFileObject()
                    m_pFileSystemManager->GetNewFileObject(pRequest, NULL);
                }
                HX_RELEASE(pRequest);
            }
            else
            {
                // It's a relative file name, so call IHXFileSystemManager::GetRelativeFileObject()
                retVal = m_pFileSystemManager->GetRelativeFileObject(m_pRPFileObject, pszImageName);
            }
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

/************************************************************************
 *      Method:
 *          IHXThreadSafeMethods::IsThreadSafe
 */
STDMETHODIMP_(UINT32)
PXFileHandler::IsThreadSafe()
{
    return HX_THREADSAFE_METHOD_FSR_READDONE;
}