plist.cpp

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

    if ((UINT)m_iCurrentTrack - 1 == uIndex)
        m_iCurrentTrack--;
    else if ((UINT)m_iCurrentTrack == uIndex)
    	m_iCurrentTrack++;

    return true;
}

CMediaClip * CPlaylist::GetTrack(int iIndex)
{
    playlist_t * pTemp = GetListItem(iIndex);
    //ASSERT(-1 == iIndex || pTemp);
    return (pTemp ? pTemp->pClip : NULL);
}

CMediaClip * CPlaylist::PlayCurrentTrack()
{
    playlist_t * pTemp = GetListItem(m_iCurrentTrack);
	//ASSERT(pTemp);

    if (pTemp)
    {
        pTemp->bPlayed = true;
        pTemp->bIsPlaying = true;
        return pTemp->pClip;
    }

    return NULL;
}

void CPlaylist::CurrentTrackDonePlaying()
{
	playlist_t * pTemp = GetListItem(m_iCurrentTrack);

#ifdef DEBUG
	// If none of the clips in the playlist are
	// playing then this may just be a brand new
	// playlist.  But if a clip we didn't expect
	// is playing, then we need investigate whether
	// we're updating this flag in all the right
	// places!!!
	if (pTemp && !pTemp->bIsPlaying)
	{
		playlist_t * pDbg = m_pList;
		while (pDbg)
		{
			ASSERT(!pDbg->bIsPlaying);
			pDbg = pDbg->pNext;
		}
	}
#endif

	if (pTemp)
	{
		pTemp->bIsPlaying = false;
	}
}

UINT CPlaylist::GetCount()
{
	return m_uCount;
}

void CPlaylist::ResetPlayed()
{
    playlist_t * pTemp = m_pList;

    while (pTemp)
    {
        pTemp->bPlayed = false;

        pTemp = pTemp->pNext;
    }
}

bool CPlaylist::IsPlaying(int iIndex)
{
	playlist_t * pTemp = GetListItem(iIndex);
	ASSERT(pTemp);
	return (pTemp ? pTemp->bIsPlaying : false);
}

int CPlaylist::GetCurrent()
{
    return m_iCurrentTrack;
}

void CPlaylist::SetCurrent(int iIndex)
{
    if (-1 <= iIndex && iIndex <= (int)GetCount())
    {
        m_iCurrentTrack = iIndex;
    }
    else
    {
    	ASSERT(FALSE);
    }
}

bool CPlaylist::NextTrack(bool bRandom, bool bRepeat)
{
     UINT uCount    = GetCount();
     int  iIndex    = m_iCurrentTrack;
     int  iOldIndex = m_iCurrentTrack;
     int  iNumTried = 0;

     playlist_t * pTemp = m_pList;
     CMediaClip * pClip = NULL;

     bool bResult = false;

     if (0 == uCount)
     {
         return false;
     }

     //
     // If all the tracks have been played, reset their "played" flag
     //

     if (bRepeat)
     {
         bool bReset = true;

         while (NULL != pTemp)
         {
             if (false == pTemp->bPlayed) bReset = false;

             pTemp = pTemp->pNext;
         }

         if (bReset)
         {
             ResetPlayed();
         }
     }

     //
     // Get the "next" track
     //

     if (bRandom)
     {

         do
         {
             do
             {
                 iIndex = rand() % uCount;
             } while (iIndex == iOldIndex && uCount > 1);

             iNumTried++;

             if(( iNumTried < (int)uCount) || ( bRepeat ))
             {
                 pTemp = GetListItem(iIndex);

                 if (NULL != pTemp)
                     pClip = pTemp->pClip;
                 else
                     pClip = NULL;
             }
             else
             {
                 pClip = NULL;
                 pTemp = NULL;
             }
         } while (pClip && (true == pTemp->bPlayed
                            || !pClip->IsAvailable()));
     }
     else
     {
         do
         {
             iIndex++;

             if (iIndex >= (int)uCount)
             {
                 iIndex = 0;

                 if (false == bRepeat)
                 {
                     pClip = NULL;
                     break;
                 }
             }

             if (iIndex != iOldIndex)
             {
                 pClip = GetTrack(iIndex);
             }
             else
             {
                 pClip = NULL;
             }
         } while (pClip && !pClip->IsAvailable());
    }

    SetCurrent(iIndex);

    Save();

    if (pClip)
    {
        if (bRandom && pTemp && false == pTemp->bPlayed)
            bResult = true;
        else if (!bRandom)
            bResult = true;
    }

    return bResult;
}

bool CPlaylist::PrevTrack(bool bRandom, bool bRepeat)
{
     UINT uCount    = GetCount();
     int  iIndex    = m_iCurrentTrack;
     int  iOldIndex = m_iCurrentTrack;
     int  iNumTried = 0;

     playlist_t * pTemp = m_pList;
     CMediaClip * pClip = NULL;

     bool bPlayed = false;
     bool bResult = false;

     if (0 == uCount)
     {
         return false;
     }

     while (NULL != pTemp)
     {
         if (pTemp->bPlayed) bPlayed = true;

         pTemp = pTemp->pNext;
     }

     //
     // Get the "previous" track
     //

     if (bRandom)
     {
         do
         {
             do
             {
                 iIndex = rand() % uCount;
             } while (iIndex == iOldIndex && uCount > 1);

             iNumTried++;

             if (iNumTried < (int)uCount)
             {
                 pTemp = GetListItem(iIndex);

                 if (NULL != pTemp)
                     pClip = pTemp->pClip;
                 else
                     pClip = NULL;
             }
             else
             {
                 pClip = NULL;
             }
         } while (pClip && ((false == pTemp->bPlayed && bPlayed)
                            || !pClip->IsAvailable()));
     }
     else
     {
         do
         {
             iIndex--;

             if (iIndex < 0)
             {
                 iIndex = (int)uCount - 1;
             }

             if (iIndex != iOldIndex)
             {
                 pClip = GetTrack(iIndex);
             }
             else
             {
                 pClip = NULL;
             }
         } while (pClip && !pClip->IsAvailable());
    }

    SetCurrent(iIndex);

    Save();

    if (pClip)
    {
        bResult = true;
    }

    return bResult;
}

LPCTSTR CPlaylist::GetName()
{
    return m_pszName;
}

LPCTSTR CPlaylist::GetPath()
{
    return m_pszPath;
}

bool CPlaylist::Save()
{
    DWORD        dwToWrite, dwWritten;
    DWORD        dwASXDataLen = 0;
    DWORD        dwFileAttrib;
    char       * pszASXData   = NULL;
    playlist_t * pTrack;
    char         szFilename[MAX_PATH];
    HANDLE       hFile;
    BOOL         bWrite;
    bool         bResult      = true;

    // Don't save a playlist that wasn't created by the player
    if (false == m_bCEPlaylist || true == m_bTransient)
    {
        return true;
    }

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

    hFile = CreateFile(m_pszPath, GENERIC_WRITE, 0, NULL,
                       CREATE_ALWAYS, dwFileAttrib, NULL);

    if (INVALID_HANDLE_VALUE != hFile)
    {
        bWrite = FALSE;

        // write out the header
        dwASXDataLen = sizeof (c_szASXHeaderFormat) + 10;

        if (pszASXData = new char[dwASXDataLen])
        {
            pszASXData[0] = '\0';

            dwToWrite = sprintf(pszASXData, c_szASXHeaderFormat, m_iCurrentTrack);

            dwWritten = 0;
            bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
        }

        if (FALSE == bWrite || dwToWrite != dwWritten)
        {
            bResult = false;
        }
    }
    else
    {
        bResult = false;
    }

    pTrack = m_pList;

    while (NULL != pTrack && bResult)
    {
        LPCTSTR pszPath = pTrack->pClip->GetPath();

        szFilename[0] = '\0';

        if (NETWORK != pTrack->pClip->GetLocation())
        {
#ifdef _UNICODE
            _snprintf(szFilename, MAX_PATH-1, "file://%ls", pszPath);
#else
            _snprintf(szFilename, MAX_PATH-1, "file://%s", pszPath);
#endif /* _UNICODE */

            szFilename[MAX_PATH-1] = '\0';
        }
        else
        {
#ifdef _UNICODE
            WideCharToMultiByte(CP_ACP, 0, pszPath, -1, szFilename, MAX_PATH, NULL, NULL);
#else
            strncpy(szFilename, pszPath, MAX_PATH);
            pszPath[MAX_PATH-1] = '\0';
#endif /* _UNICODE */
        }

        dwToWrite = sizeof (c_szASXEntryFormat) + strlen(szFilename);

        if (dwASXDataLen < dwToWrite)
        {
            delete [] pszASXData;

            pszASXData  = new char [dwToWrite];
            dwASXDataLen = dwToWrite;
        }

        dwToWrite = sprintf(pszASXData, c_szASXEntryFormat, szFilename);

        dwWritten = 0;
        bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);

        if (FALSE == bWrite || dwToWrite != dwWritten)
        {
            bResult = false;
        }

        pTrack = pTrack->pNext;
    }


    if (INVALID_HANDLE_VALUE != hFile && NULL != pszASXData)
    {
        // write out the footer
        if (dwASXDataLen < sizeof (c_szASXFooterFormat))
        {
            delete [] pszASXData;

            pszASXData = new char [sizeof (c_szASXFooterFormat)];
        }

        strcpy(pszASXData, c_szASXFooterFormat);
        dwToWrite = strlen(pszASXData);

        dwWritten = 0;
        bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);

        if (FALSE == bWrite || dwToWrite != dwWritten)
        {
            bResult = false;
        }

        CloseHandle(hFile);
    }
    else if (INVALID_HANDLE_VALUE != hFile)
    {
        CloseHandle(hFile);
    }

    delete [] pszASXData;

    return bResult;
}

bool CPlaylist::Load()
{
    IGraphBuilder * pGraph       = NULL;
    IAMPlayList   * pPlaylist    = NULL;
    HRESULT         hr;
    bool            bResult;

    if (NULL != m_pList || true == m_bTransient)
    {
        return true;
    }

    //
    // Make sure that this is one of our playlist read the last played element
    //
    bResult = LoadParam();

    hr = CoCreateInstance(CLSID_FilterGraph,
                          NULL,
                          CLSCTX_INPROC_SERVER,
                          IID_IGraphBuilder,
                          (void**) &pGraph);

    if (SUCCEEDED(hr))
    {
        hr = pGraph->RenderFile(m_pszPath, NULL);
    }

    if (SUCCEEDED(hr))
    {
        IEnumFilters * pEnum   = NULL;
        IBaseFilter  * pFilter = NULL;

        hr = pGraph->EnumFilters(&pEnum);

        if (pEnum)
        {
            while (!pPlaylist && pEnum->Next(1, &pFilter, NULL) == S_OK)
            {
                hr = pFilter->QueryInterface(IID_IAMPlayList, (void**)&pPlaylist);
                pFilter->Release();
            }

            if (!pPlaylist)
            {
                hr = E_NOINTERFACE;
            }

            pEnum->Release();
        }
    }

    if (SUCCEEDED(hr))