playlist.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

{
    m_current = index;
    if (index != kInvalidIndex) 
        m_context->target->AcceptEvent(new PlaylistCurrentItemInfoEvent(GetCurrentItem(), this));
}

uint32 PlaylistManager::GetCurrentIndex()
{
    uint32 result = kInvalidIndex;

    if(m_masterList.size())
    {
        if(m_shuffle)
            result = IndexOf(m_shuffleList[m_current]);
        else
            result = m_current;
    }

    return result;
}


Error PlaylistManager::GotoNextItem(bool userAction)
{
    m_mutex.Acquire();

    Error result = kError_NoErr;
    uint32 count = m_masterList.size();
    uint32 index = m_current;
    
    if(count)
    {
        if(!(kPlaylistMode_RepeatOne == m_repeatMode) || userAction)
        {
            index++;

            if( (index >= count) && 
                (m_repeatMode == kPlaylistMode_RepeatAll || userAction))
            {
                index = 0;

                if(m_shuffle)
                {
                    ShuffleIt();
                }
            }
            else if(index >= count)
            {
                index = m_current;
            }
        }

        InternalSetCurrentIndex(index);
    }
    else
    {
        m_current = kInvalidIndex;
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::GotoPreviousItem(bool userAction)
{
    m_mutex.Acquire();

    Error result = kError_NoErr;
    uint32 count = m_masterList.size();
    uint32 index = m_current;
    
    if(count)
    {
        if(!(kPlaylistMode_RepeatOne == m_repeatMode) || userAction)
        {
            if( (index == 0) && 
                (m_repeatMode == kPlaylistMode_RepeatAll || userAction))
            {
                index = count - 1;

                if(m_shuffle)
                {
                    ShuffleIt();
                }
            }
            else if(index != 0)
            {
                index--;
            }
        }

        InternalSetCurrentIndex(index);
    }
    else
    {
        m_current = kInvalidIndex;
    }

    m_mutex.Release();

    return result;
}

bool PlaylistManager::HasAnotherItem()
{
    m_mutex.Acquire();
    bool result = false;

    if(m_repeatMode == kPlaylistMode_RepeatOne || 
        m_repeatMode == kPlaylistMode_RepeatAll)
    {
        result = true;
    }
    else
    {
        result = (m_current < m_masterList.size() - 1);
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::SetShuffleMode(bool shuffle)
{
    m_mutex.Acquire();

    const PlaylistItem* currentItem = GetCurrentItem();

    m_shuffle = shuffle;

    if(shuffle)
    {
         ShuffleIt();
        if(currentItem)
            m_current = InternalIndexOf(&m_shuffleList, currentItem);
    }
    else
    {
        if(currentItem)
            m_current = IndexOf(currentItem);
    }

    m_context->target->AcceptEvent(new PlaylistShuffleEvent(m_shuffle, this));

    m_mutex.Release();

    return kError_NoErr;
}

Error PlaylistManager::SetRepeatMode(RepeatMode mode)
{
    m_repeatMode = mode;
    m_context->target->AcceptEvent(new PlaylistRepeatEvent(m_repeatMode, this));
    return kError_NoErr;
}

Error PlaylistManager::ToggleRepeatMode()
{
    Error result = kError_NoErr;

    if(m_repeatMode == kPlaylistMode_RepeatNone)
        result = SetRepeatMode(kPlaylistMode_RepeatOne);
    else if(m_repeatMode == kPlaylistMode_RepeatOne)
        result = SetRepeatMode(kPlaylistMode_RepeatAll);
    else if(m_repeatMode == kPlaylistMode_RepeatAll)
        result = SetRepeatMode(kPlaylistMode_RepeatNone);

    return result;
}

Error PlaylistManager::ToggleShuffleMode()
{
    return SetShuffleMode(!m_shuffle);
}


// Functions for adding items to playlist       
Error PlaylistManager::AddItem(const char* url)
{
    Error result = kError_InvalidParam;

    assert(url);

    if(url)
    {
        result = ReadPlaylist(url);

        if(IsError(result))
        {
            result = kError_OutOfMemory;

            PlaylistItem* item = new PlaylistItem(url);

            if(item)
            {
                result = AddItem(item, true);
            }
        }
    }

    return result;
}

Error PlaylistManager::AddItem(const char* url, uint32 index)
{
    Error result = kError_InvalidParam;

    assert(url);

    if(url)
    {
        result = ReadPlaylist(url);

        if(IsError(result))
        {
            result = kError_OutOfMemory;

            PlaylistItem* item = new PlaylistItem(url);

            if(item)
            {
                result = AddItem(item, index, true);
            }
        }
    }

    return result;
}

Error PlaylistManager::AddItem(const string& url)
{
    Error result = kError_InvalidParam;

    result = AddItem(url.c_str());

    return result;
}

Error PlaylistManager::AddItem(const string& url, uint32 index)
{
    Error result = kError_InvalidParam;

    result = AddItem(url.c_str(), index);

    return result;
}

Error PlaylistManager::AddItems(const vector<string>& urls)
{
    Error result = kError_InvalidParam;
    vector<string>::const_iterator i;
    vector<PlaylistItem*> list;

    for(i = urls.begin(); i != urls.end(); i++)
    {
        result = ReadPlaylist((*i).c_str());

        if(IsError(result))
        {
            result = kError_OutOfMemory;

            PlaylistItem* item = new PlaylistItem((*i).c_str());

            if(item)
            {
                list.push_back(item);
            }
        }
    }

    result = AddItems(&list);

    return result;
}

Error PlaylistManager::AddItems(const vector<string>& urls, uint32 index)
{
    Error result = kError_InvalidParam;
    vector<string>::const_iterator i;
    vector<PlaylistItem*> list;

    for(i = urls.begin(); i != urls.end(); i++)
    {
        result = ReadPlaylist((*i).c_str());

        if(IsError(result))
        {
            result = kError_OutOfMemory;

            PlaylistItem* item = new PlaylistItem((*i).c_str());

            if(item)
            {
                list.push_back(item);
            }
        }
    }

    result = AddItems(&list, index);

    return result;
}

Error PlaylistManager::AddItem(PlaylistItem* item, bool queryForMetaData)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(item);

    if(item)
    {
        m_activeList->push_back(item);

        if(kPlaylistKey_MasterPlaylist == GetActivePlaylist())
        {
            AddItemToShuffleList(item);

            if(m_current == kInvalidIndex && m_activeList->size())
                InternalSetCurrentIndex(0);
        }

        if(queryForMetaData)
            RetrieveMetaData(item);

        /*UndoAdd* undoItem = new UndoAdd(this, item->URL(), m_activeList->size() - 1);

        m_undo.AddItem(undoItem);*/
     
        m_context->target->AcceptEvent(new PlaylistItemAddedEvent(item, this));

        result = kError_NoErr;
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::AddItem(PlaylistItem* item, uint32 index, bool queryForMetaData)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(item);

    if(index > m_activeList->size())
        index = m_activeList->size();

    //index = CheckIndex(index);

    if(item && index != kInvalidIndex)
    {
		const PlaylistItem* currentItem = GetCurrentItem();

        m_activeList->insert(m_activeList->begin() + index,item);

        if(kPlaylistKey_MasterPlaylist == GetActivePlaylist())
        {
            AddItemToShuffleList(item);

            if(m_current == kInvalidIndex && m_activeList->size())
                InternalSetCurrentIndex(0);
            else if(index <= m_current)
            {
				SetCurrentIndex(IndexOf(currentItem));
                //SetCurrentIndex(m_current + 1);
            }
        }

        if(queryForMetaData)
            RetrieveMetaData(item);

        /*UndoAdd* undoItem = new UndoAdd(this, item->URL(), index);

        m_undo.AddItem(undoItem);*/

        m_context->target->AcceptEvent(new PlaylistItemAddedEvent(item, this));

        result = kError_NoErr;
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::AddItems(vector<PlaylistItem*>* list, bool queryForMetaData)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(list);

    if(list)
    {
        //uint32 index = m_activeList->size();

        m_activeList->insert(m_activeList->end(),
                             list->begin(), 
                             list->end());

        if(kPlaylistKey_MasterPlaylist == GetActivePlaylist())
        {
            AddItemsToShuffleList(list);

            if(m_current == kInvalidIndex && m_activeList->size())
                InternalSetCurrentIndex(0);
        }

        // we need our own vector so user can delete theirs
        vector<PlaylistItem*>* items = new vector<PlaylistItem*>;

        if(items)
        {
            items->insert(items->end(), list->begin(), list->end());

            if(queryForMetaData)
                RetrieveMetaData(items);
        }
        
        /*vector<PlaylistItem *>::iterator i = list->begin();
        vector<string> urls;

        for(; i != list->end(); i++)
            urls.push_back((*i)->URL());

        UndoAddMulti* undoItem = new UndoAddMulti(this, urls, index);
        m_undo.AddItem(undoItem);*/

        //vector<PlaylistItem *>::iterator i = list->begin();
        //for(; i != list->end(); i++)
            //m_context->target->AcceptEvent(new PlaylistItemAddedEvent(*i, this));

        m_context->target->AcceptEvent(new PlaylistItemsAddedEvent(list, this));

        result = kError_NoErr;
    }

    m_mutex.Release();

    return result;
}



Error PlaylistManager::AddItems(vector<PlaylistItem*>* list, uint32 index, bool queryForMetaData)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(list);

    if(index > m_activeList->size())
        index = m_activeList->size();

    //index = CheckIndex(index);

    if(list && index != kInvalidIndex)
    {
		const PlaylistItem* currentItem = GetCurrentItem();

        m_activeList->insert(m_activeList->begin() + index,
                             list->begin(), 
                             list->end());

        if(kPlaylistKey_MasterPlaylist == GetActivePlaylist())
        {
            AddItemsToShuffleList(list);

            if(m_current == kInvalidIndex && m_activeList->size())
                InternalSetCurrentIndex(0);
            else if(index <= m_current)
            {
				SetCurrentIndex(IndexOf(currentItem));
                //SetCurrentIndex(m_current + list->size());
            }
        }

        // we need our own vector so user can delete theirs
        vector<PlaylistItem*>* items = new vector<PlaylistItem*>;

        if(items)
        {
            items->insert(items->end(), list->begin(), list->end());

            if(queryForMetaData)
                RetrieveMetaData(items);
        }

        /*vector<PlaylistItem *>::iterator i = list->begin();
        vector<string> urls;

        for(; i != list->end(); i++)
            urls.push_back((*i)->URL());

        UndoAddMulti* undoItem = new UndoAddMulti(this, urls, index);
        m_undo.AddItem(undoItem);*/

        //vector<PlaylistItem *>::iterator i = list->begin();
        //for(; i != list->end(); i++)
        //    m_context->target->AcceptEvent(new PlaylistItemAddedEvent(*i, this));

        m_context->target->AcceptEvent(new PlaylistItemsAddedEvent(list, this));

        result = kError_NoErr;
    }

    m_mutex.Release();

    return result;
}


// Functions for removing items from playlist
Error PlaylistManager::RemoveItem(PlaylistItem* item)