rpfile.cpp

linux下的一款播放器

HX_RESULT PXRealPixFile::SetImageName(UINT32 ulHandle, const char* pszName)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        HX_RELEASE(pInfo->m_pNameStr);
        retVal = SetString(pszName, &pInfo->m_pNameStr);
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetImageErrorStatus(UINT32 ulHandle, REF(HX_RESULT) rlStatus)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rlStatus = pInfo->m_lErrorStatus;
    }

    return retVal;
}

HX_RESULT PXRealPixFile::SetImageErrorStatus(UINT32 ulHandle, HX_RESULT lStatus)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        pInfo->m_lErrorStatus = lStatus;
    }

    return retVal;
}

HX_RESULT PXRealPixFile::GetImageSize(UINT32 ulHandle, REF(UINT32) rulSize)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rulSize = pInfo->m_ulSize;
    }
    return retVal;
}

UINT32 PXRealPixFile::GetImageSize(UINT32 ulHandle)
{
    UINT32 ulSize = 0;
    GetImageSize(ulHandle, ulSize);
    return ulSize;
}

HX_RESULT PXRealPixFile::SetImageSize(UINT32 ulHandle, UINT32 ulSize)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        if (ulSize)
        {
            pInfo->m_ulSize       = ulSize;
            pInfo->m_lErrorStatus = HXR_OK;
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }
    return retVal;
}

BOOL PXRealPixFile::IsImageSizeInitialized(UINT32 ulHandle)
{
    BOOL         bRet  = FALSE;
    PXImageInfo* pInfo = NULL;
    GetImageInfo(ulHandle, pInfo);
    if (pInfo && pInfo->m_lErrorStatus == HXR_OK)
    {
        bRet = TRUE;
    }
    return bRet;
}

HX_RESULT PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        if (pInfo->m_pFileMimeStr)
        {
            HX_RELEASE(rpMimeStr);
            rpMimeStr = pInfo->m_pFileMimeStr;
            rpMimeStr->AddRef();
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle, REF(const char*) rpszMime)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rpszMime = (const char*) (pInfo->m_pFileMimeStr ? pInfo->m_pFileMimeStr->GetBuffer() : NULL);
    }
    return retVal;
}

const char* PXRealPixFile::GetImageFileMimeType(UINT32 ulHandle)
{
    const char* pszMime = NULL;
    GetImageFileMimeType(ulHandle, pszMime);
    return pszMime;
}

HX_RESULT PXRealPixFile::SetImageFileMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        HX_RELEASE(pInfo->m_pFileMimeStr);
        retVal = SetString(pMimeStr, &pInfo->m_pFileMimeStr);
    }
    return retVal;
}

HX_RESULT PXRealPixFile::SetImageFileMimeType(UINT32 ulHandle, const char* pszMime)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        HX_RELEASE(pInfo->m_pFileMimeStr);
        retVal = SetString(pszMime, &pInfo->m_pFileMimeStr);
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle, REF(IHXBuffer*) rpMimeStr)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        if (pInfo->m_pStreamMimeStr)
        {
            HX_RELEASE(rpMimeStr);
            rpMimeStr = pInfo->m_pStreamMimeStr;
            rpMimeStr->AddRef();
        }
        else
        {
            retVal = HXR_FAIL;
        }
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle, REF(const char*) rpszMime)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rpszMime = (const char*) (pInfo->m_pStreamMimeStr ? pInfo->m_pStreamMimeStr->GetBuffer() : NULL);
    }
    return retVal;
}

const char* PXRealPixFile::GetImageStreamMimeType(UINT32 ulHandle)
{
    const char* pszMime = NULL;
    GetImageStreamMimeType(ulHandle, pszMime);
    return pszMime;
}

HX_RESULT PXRealPixFile::SetImageStreamMimeType(UINT32 ulHandle, IHXBuffer* pMimeStr)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        HX_RELEASE(pInfo->m_pStreamMimeStr);
        retVal = SetString(pMimeStr, &pInfo->m_pStreamMimeStr);
    }
    return retVal;
}

HX_RESULT PXRealPixFile::SetImageStreamMimeType(UINT32 ulHandle, const char* pszMime)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        HX_RELEASE(pInfo->m_pStreamMimeStr);
        retVal = SetString(pszMime, &pInfo->m_pStreamMimeStr);
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(IHXBuffer*) rpNameStr,
                                         REF(IHXBuffer*) rpFileMimeStr, REF(IHXBuffer*) rpStreamMimeStr)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rulSize        = pInfo->m_ulSize;
        if (pInfo->m_pNameStr)
        {
            HX_RELEASE(rpNameStr);
            rpNameStr = pInfo->m_pNameStr;
            rpNameStr->AddRef();
        }
        if (pInfo->m_pFileMimeStr)
        {
            HX_RELEASE(rpFileMimeStr);
            rpFileMimeStr = pInfo->m_pFileMimeStr;
            rpFileMimeStr->AddRef();
        }
        if (pInfo->m_pStreamMimeStr)
        {
            HX_RELEASE(rpStreamMimeStr);
            rpStreamMimeStr = pInfo->m_pStreamMimeStr;
            rpStreamMimeStr->AddRef();
        }
    }
    return retVal;
}

HX_RESULT PXRealPixFile::GetAllImageInfo(UINT32 ulHandle, REF(UINT32) rulSize, REF(const char*) rpszName,
                                         REF(const char*) rpszFileMime, REF(const char*) rpszStreamMime)
{
    PXImageInfo* pInfo  = NULL;
    HX_RESULT    retVal = GetImageInfo(ulHandle, pInfo);
    if (SUCCEEDED(retVal))
    {
        rulSize        = pInfo->m_ulSize;
        rpszName       = (const char*) (pInfo->m_pNameStr ? pInfo->m_pNameStr->GetBuffer() : NULL);
        rpszFileMime   = (const char*) (pInfo->m_pFileMimeStr ? pInfo->m_pFileMimeStr->GetBuffer() : NULL);
        rpszStreamMime = (const char*) (pInfo->m_pStreamMimeStr ? pInfo->m_pStreamMimeStr->GetBuffer() : NULL);
    }
    return retVal;
}

BOOL PXRealPixFile::AllImageSizesInitialized()
{
    BOOL bRet = TRUE;

    if (m_pImageMap)
    {
        // Run through the map, deleting all image objects
        POSITION pos = m_pImageMap->GetStartPosition();
        while (pos)
        {
            // Get the object pointer at the current position
            // and advance to the next position
            LONG32 lKey     = 0;
            void*  pElement = NULL;
            m_pImageMap->GetNextAssoc(pos, lKey, pElement);

            // Check the PXImageInfo object
            if (pElement)
            {
                PXImageInfo* pInfo = (PXImageInfo*) pElement;
                if (pInfo->m_lErrorStatus == HXR_NOT_INITIALIZED)
                {
                    bRet = FALSE;
                    break;
                }
            }
        }
    }

    return bRet;
}

BOOL PXRealPixFile::AllImageSizesOK()
{
    BOOL bRet = TRUE;

    if (m_pImageMap)
    {
        // Run through the map, deleting all image objects
        POSITION pos = m_pImageMap->GetStartPosition();
        while (pos)
        {
            // Get the object pointer at the current position
            // and advance to the next position
            LONG32 lKey     = 0;
            void*  pElement = NULL;
            m_pImageMap->GetNextAssoc(pos, lKey, pElement);

            // Check the PXImageInfo object
            if (pElement)
            {
                PXImageInfo* pInfo = (PXImageInfo*) pElement;
                if (pInfo->m_lErrorStatus != HXR_OK)
                {
                    bRet = FALSE;
                    break;
                }
            }
        }
    }

    return bRet;
}

HX_RESULT PXRealPixFile::GetFailedImageName(REF(IHXBuffer*) rpFailedNameStr)
{
    HX_RESULT retVal = HXR_FAIL;

    if (m_pImageMap)
    {
        // Run through the map, deleting all image objects
        POSITION pos = m_pImageMap->GetStartPosition();
        while (pos)
        {
            // Get the object pointer at the current position
            // and advance to the next position
            LONG32 lKey     = 0;
            void*  pElement = NULL;
            m_pImageMap->GetNextAssoc(pos, lKey, pElement);

            // Check the PXImageInfo object
            if (pElement)
            {
                PXImageInfo* pInfo = (PXImageInfo*) pElement;
                if (pInfo->m_lErrorStatus != HXR_OK)
                {
                    if (pInfo->m_pNameStr)
                    {
                        HX_RELEASE(rpFailedNameStr);
                        rpFailedNameStr = pInfo->m_pNameStr;
                        rpFailedNameStr->AddRef();
                        retVal = HXR_OK;
                        break;
                    }
                }
            }
        }
    }

    return retVal;
}

HX_RESULT PXRealPixFile::AddEffect(PXEffect* pEffect)
{
    HX_RESULT retVal = HXR_OK;

    if (pEffect)
    {
        if (!m_pEffectsList)
        {
            m_pEffectsList = new CHXSimpleList();
            if (!m_pEffectsList)
            {
                retVal = HXR_OUTOFMEMORY;
            }
        }

        if (SUCCEEDED(retVal))
        {
            // Check for a few shortcuts before searching the whole list
            // If there aren't any elements in the queue, we know just to
            // add ourselves to the end of the list.
            if (m_pEffectsList->GetCount() > 0)
            {
                // Now we check the last element in the queue. If our start time is
                // greater than or equal to its start time, then we know just to
                // add ourselves at the tail of the queue.
                PXEffect *pTailEffect = (PXEffect *) m_pEffectsList->GetTail();
                if (pTailEffect)
                {
                    if (pEffect->GetStart() < pTailEffect->GetStart())
                    {
                        // Now we have to search the list.
                        // Insert effect into list which is sorted by increasing start time
                        // We look for the first effect which has a start time greater
                        // than the one we're inserting