plist.cpp

media player 控件源码 用EVC编译可以进行对WINCE下media player控制

    {
        DWORD             dwCount;
        IAMPlayListItem * pItem   = NULL;

        hr = pPlaylist->GetItemCount(&dwCount);

        if (SUCCEEDED(hr))
        {
            for (DWORD i = 0; i < dwCount; i++)
            {
                hr = pPlaylist->GetItem(i, &pItem);

                if (SUCCEEDED(hr))
                {
                    BSTR pszSource = NULL;

                    hr = pItem->GetSourceURL(0, &pszSource);

                    if (SUCCEEDED(hr))
                    {
                        InsertTrack(i, pszSource);
                    }

                    pItem->Release();
                }
            }
        }
    }

    if (pPlaylist)
    {
        pPlaylist->Release();
    }

    if (pGraph)
    {
        pGraph->Release();
    }

    if (SUCCEEDED(hr))
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool CPlaylist::Rename(TCHAR * pszName)
{
    TCHAR   szOldPath[MAX_PATH];
    TCHAR   szNewPath[MAX_PATH];
    TCHAR * pszExt  = NULL;
    bool    bResult = false;

    _tcsncpy(szOldPath, m_pszPath, MAX_PATH);
	szOldPath[ MAX_PATH -1 ] = TEXT('\0' );

    pszExt = _tcsrchr(m_pszPath, TEXT('.'));


    if (NULL == pszExt)
    {
        pszExt = m_pszPath + _tcslen(m_pszPath);
    }

    pszExt -= _tcslen(m_pszName);

    *pszExt = TEXT('\0');

    StringCchPrintf( szNewPath, sizeof( szNewPath ) / sizeof( szNewPath[0] ), L"%s%s.asx", m_pszPath, pszName);

    if (MoveFile(szOldPath, szNewPath))
    {
        TCHAR * pszOldName = m_pszName;
        TCHAR * pszOldPath = m_pszPath;

        m_pszPath = new TCHAR [_tcslen(szNewPath) + 1];
        m_pszName = new TCHAR [_tcslen(pszName) + 1];

        if (NULL != m_pszPath && NULL != m_pszName)
        {
            _tcscpy(m_pszPath, szNewPath);
            _tcscpy(m_pszName, pszName);

            bResult = true;

            delete [] pszOldName;
            delete [] pszOldPath;
        }
        else
        {
            m_pszName = pszOldName;
            m_pszPath = pszOldPath;
        }
    }
    else
    {
        _tcscpy(m_pszPath, szOldPath);
    }

    return bResult;
}

bool CPlaylist::IsCEPlaylist()
{
    return m_bCEPlaylist;
}

void CPlaylist::IsCEPlaylist(bool b)
{
    m_bCEPlaylist = b;
}

bool CPlaylist::IsHidden()
{
    return m_bHidden;
}

void CPlaylist::IsHidden(bool b)
{
    m_bHidden = b;
}

bool CPlaylist::IsTransient()
{
    return m_bTransient;
}

void CPlaylist::IsTransient(bool b)
{
    m_bTransient = b;
}

CPlaylist::playlist_t * CPlaylist::GetFirst()
{
    return m_pList;
}

// case insensitive substring (with bounds checking)
const char * strnistr(const char * pszSource, DWORD dwLength, const char * pszFind)
{
    DWORD        dwIndex   = 0;
    DWORD        dwStrLen  = 0;
    const char * pszSubStr = NULL;

    // check for valid arguments
    if (!pszSource || !pszFind)
    {
        return pszSubStr;
    }

    dwStrLen = strlen(pszFind);

    // can pszSource possibly contain pszFind?
    if (dwStrLen > dwLength)
    {
        return pszSubStr;
    }

    while (dwIndex <= dwLength - dwStrLen)
    {
        if (0 == _strnicmp(pszSource + dwIndex, pszFind, dwStrLen))
        {
            pszSubStr = pszSource + dwIndex;
            break;
        }

        dwIndex ++;
    }

    return pszSubStr;
}

bool CPlaylist::LoadParam()
{
    DWORD    dwIndex;
    DWORD    dwFileSize;
    DWORD    dwFileAttrib;
    char   * pszASXFile;
    char   * pszParam;
    HANDLE   hFile;
    HANDLE   hMap;
    bool     bLastEntry = false;
    bool     bGenerator = false;
    enum  {E_INVALID = 0, E_NOERROR, E_EOF, E_BADMATCH} eError = E_NOERROR;

    if (m_bHidden)
    {
        dwFileAttrib = FILE_ATTRIBUTE_HIDDEN;
    }
    else
    {
        dwFileAttrib = FILE_ATTRIBUTE_NORMAL;
    }

    hFile = CreateFileForMapping(m_pszPath, GENERIC_READ, FILE_SHARE_READ,
                                 NULL, OPEN_EXISTING, dwFileAttrib, NULL);

    if (INVALID_HANDLE_VALUE == hFile)
    {
        return false;
    }

    hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);

    if (NULL == hMap)
    {
        CloseHandle(hFile);
        return false;
    }

    dwFileSize = GetFileSize(hFile, NULL);

    pszASXFile = (char*)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);

    if (NULL == pszASXFile)
    {
        CloseHandle(hMap);
        CloseHandle(hFile);
        return false;
    }

    // find the occurance of "LAST ENTRY" (case insensitive)
    pszParam = (char*)strnistr(pszASXFile, dwFileSize, "LAST ENTRY");
    dwIndex = (DWORD)pszParam - (DWORD)pszASXFile;

    if (pszParam) 
    {
        dwIndex += strlen("LAST ENTRY");

        // skip the trailing quote
        if (dwIndex < dwFileSize)
        {
            if ('\"' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match "VALUE"
        if (E_NOERROR == eError
            && dwIndex < dwFileSize
            && 0 == _strnicmp(pszASXFile + dwIndex, "VALUE", 5))
        {
            dwIndex += strlen("VALUE");
        }
        else if (E_NOERROR == eError && dwIndex > dwFileSize)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match "="
        if (dwIndex < dwFileSize && E_NOERROR == eError)
        {
            if ('=' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
            else
            {
                eError = E_BADMATCH;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match quote
        if (dwIndex < dwFileSize && E_NOERROR == eError)
        {
            if ('\"' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // get the number
        if (E_NOERROR == eError
            && dwIndex < dwFileSize
            && 1 == sscanf(pszASXFile + dwIndex, "%d", &m_iCurrentTrack))
        {
            bLastEntry = true;
        }
        else if (E_NOERROR == eError && dwIndex >= dwFileSize)
        {
            eError = E_BADMATCH;
            SetCurrent(-1);
        }
    }

    // find the occurance of "GENERATOR" (case insensitive)
    pszParam = (char*)strnistr(pszASXFile, dwFileSize, "GENERATOR");
    dwIndex = (DWORD)pszParam - (DWORD)pszASXFile;

    if (pszParam) 
    {
        dwIndex += strlen("GENERATOR");

        // skip the trailing quote
        if (dwIndex < dwFileSize)
        {
            if ('\"' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match "VALUE"
        if (E_NOERROR == eError
            && dwIndex < dwFileSize
            && 0 == _strnicmp(pszASXFile + dwIndex, "VALUE", 5))
        {
            dwIndex += strlen("VALUE");
        }
        else if (E_NOERROR == eError && dwIndex > dwFileSize)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match "="
        if (dwIndex < dwFileSize && E_NOERROR == eError)
        {
            if ('=' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
            else
            {
                eError = E_BADMATCH;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // skip spaces
        while (E_NOERROR == eError
               && dwIndex < dwFileSize
               && isspace(pszASXFile[dwIndex]))
        {
            dwIndex++;
        }

        if (dwIndex >= dwFileSize && E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // match quote
        if (dwIndex < dwFileSize && E_NOERROR == eError)
        {
            if ('\"' == pszASXFile[dwIndex])
            {
                dwIndex++;
            }
        }
        else if (E_NOERROR == eError)
        {
            eError = E_EOF;
        }

        // examine the value 
        if (E_NOERROR == eError
            && dwIndex < dwFileSize
            && 0 == _strnicmp(pszASXFile + dwIndex, "CEPLAYER", 8))
        {
            bGenerator    = true;
            m_bCEPlaylist = true;
        }
        else if (E_NOERROR == eError && dwIndex >= dwFileSize)
        {
            eError = E_BADMATCH;
        }
    }

    UnmapViewOfFile(pszASXFile);
    CloseHandle(hMap);
    CloseHandle(hFile);

    return bLastEntry && bGenerator;
}

void CPlaylist::SwapItems(playlist_t * pItem)
{
    playlist_t * pTemp = pItem->pNext;
    playlist_t * pNext = pTemp->pNext;
    playlist_t * pPrev = pItem->pPrev;

    pItem->pNext = pNext;
    pItem->pPrev = pTemp;

    pTemp->pNext = pItem;
    pTemp->pPrev = pPrev;

    if (pPrev)
    {
        pPrev->pNext = pTemp;
    }
    else
    {
        m_pList = pTemp;
    }

    if (pNext)
    {
        pNext->pPrev = pItem;
    }
}

CPlaylist::playlist_t * CPlaylist::GetListItem(int iIndex)
{
	if (iIndex < 0) return NULL;

    playlist_t * pTemp = m_pList;
    int          iPos  = 0;

    while (NULL != pTemp)
    {
        if (iPos == iIndex) break;

        pTemp = pTemp->pNext;
        iPos++;
    }

    return pTemp;
}