playlist.cpp

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

    return result;
}

Error PlaylistManager::MoveItems(vector<uint32>* items, uint32 index)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(items);

    if(items)
    {
        vector<PlaylistItem*> pl_items;

        vector<uint32>::iterator i;

        for(i = items->begin(); i != items->end(); i++)
        {
            pl_items.push_back(ItemAt(*i));
        }

        result = MoveItems(&pl_items, index);
    }

    m_mutex.Release();
    return result;
}

typedef struct WriteToDiskStruct {
    PlaylistItem item;
    vector<MetaDataFormat*> metadataFormats;
    Thread* thread;
}WriteToDiskStruct;

static void write_to_disk(void* arg)
{
    WriteToDiskStruct* wtd = (WriteToDiskStruct*)arg;

    MetaData metadata = wtd->item.GetMetaData();

    MetaDataFormat* mdf = NULL;
    uint32 numFormats;

    numFormats = wtd->metadataFormats.size();

    for(uint32 i = 0; i < numFormats; i++)
    {
        mdf = wtd->metadataFormats[i];

        if(mdf)
        {
            mdf->WriteMetaData(wtd->item.URL().c_str(), metadata);
        }
    }

    delete wtd->thread;
    delete wtd;
}

// Functions for updating
// This function searches the items in the playlist
// and updates the metadata if the tracks are the
// same (matched based on URL)
Error PlaylistManager::UpdateTrackMetaData(PlaylistItem* updatedTrack, bool writeToDisk)
{
    Error result = kError_InvalidParam;
    //m_mutex.Acquire();

    vector<PlaylistItem*>::iterator i = m_activeList->begin();

    MetaData metadata = updatedTrack->GetMetaData();

    vector<PlaylistItem*> pl_items;

    for(; i != m_activeList->end(); i++)
    {
        if((*i)->URL() == updatedTrack->URL())
        {
            (*i)->SetMetaData(&metadata);
            
            pl_items.push_back(*i);
        }
    }

    if(pl_items.size())
    {
        m_context->target->AcceptEvent(new PlaylistItemsUpdatedEvent(&pl_items, this));
    }

    if(writeToDisk)
    {
        WriteToDiskStruct* wtd = new WriteToDiskStruct;

        wtd->item = *updatedTrack;
        wtd->metadataFormats = m_metadataFormats;

        wtd->thread = Thread::CreateThread();
        wtd->thread->Create(write_to_disk, wtd, true);
    }

    //m_mutex.Release();
    return result;
}


// Functions for sorting
Error PlaylistManager::Sort(PlaylistSortKey key, PlaylistSortType type)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    const PlaylistItem* currentItem = GetCurrentItem();

    if(key >= kPlaylistSortKey_FirstKey && key < kPlaylistSortKey_LastKey)
    {
        if(type == kPlaylistSortType_Ascending)
            stable_sort(m_activeList->begin(), m_activeList->end(), PlaylistItemSort(key));
        else
            stable_sort(m_activeList->begin(), m_activeList->end(), not2(PlaylistItemSort(key)));
    
        m_sortKey = key;
        m_sortType = type;

        result = kError_NoErr;
    }
    else if(key == kPlaylistSortKey_Random)
    {
        ShuffleIt(m_activeList);
        
        m_sortKey = key;
        m_sortType = type;

        result = kError_NoErr;
    }

    if(IsntError(result))
    {
        if(kPlaylistKey_MasterPlaylist == GetActivePlaylist() && currentItem)
            SetCurrentIndex(IndexOf(currentItem));
           
        m_context->target->AcceptEvent(new PlaylistSortedEvent(key, this));

        //m_undo.Clear();
    }

    m_mutex.Release();
    return result;
}

PlaylistSortKey PlaylistManager::GetPlaylistSortKey() const
{
    return m_sortKey;
}

PlaylistSortType PlaylistManager::GetPlaylistSortType() const
{
    return m_sortType;
}

// Which playlist are we dealing with for purposes of editing:
// 1) Master Playlist - list of songs to play
// 2) Secondary Playlist - a playlist that we want to edit
//      - External playlist
//      - Portable playlist

Error PlaylistManager::SetActivePlaylist(PlaylistKey key)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    if(key >= kPlaylistKey_FirstKey && key < kPlaylistKey_LastKey)
    {
        m_playlistKey = key;
        result = kError_NoErr;

        switch(key)
        {
            case kPlaylistKey_MasterPlaylist:
            {
                m_activeList = &m_masterList;
                break;
            }

            case kPlaylistKey_ExternalPlaylist:
            {
                m_activeList = &m_externalList;
                break;
            }
    

            case kPlaylistKey_PortablePlaylist:
            {
                //m_activeList = &m_portableList;
                m_activeList = &m_externalList;
                break;
            }

            default:
            {
                result = kError_InvalidParam;
            }
        }
    }

    m_mutex.Release();
    return result;
}

PlaylistKey PlaylistManager::GetActivePlaylist() const
{
    return m_playlistKey;  
}

Error PlaylistManager::SetExternalPlaylist(char* url)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(url);

    if(url)
    {
        // first delete old playlist
        uint32 index = 0;
        uint32 numItems = 0;
        PlaylistItem* item = NULL;

        numItems = m_externalList.size();

        for(index = 0; index < numItems; index++)
        {
            item = m_externalList[index];

            if(item)
            {
                // if the metadata thread is still accessing this item
                // we don't wanna delete the item  out from under it.
                // instead we set a flag and let the metadata thread
                // clean up when it returns.
                if(item->GetState() == kPlaylistItemState_RetrievingMetaData)
                {
                    item->SetState(kPlaylistItemState_Delete);  
                }
                else
                {
                    delete item;
                }
            }
        }

        m_externalList.clear();

        result = ReadPlaylist(url, &m_externalList);

        vector<PlaylistItem*>* items = new vector<PlaylistItem*>;

        items->insert(items->end(), 
                      m_externalList.begin(), 
                      m_externalList.end());

        RetrieveMetaData(items);

        m_externalPlaylist = string(url);
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::GetExternalPlaylist(char* url, uint32* length)
{
    Error result = kError_InvalidParam;
    m_mutex.Acquire();

    assert(url);
    assert(length);

    if(url && length)
    {
        if(*length >= m_externalPlaylist.size() + 1)
        {
            strcpy(url, m_externalPlaylist.c_str());
            result = kError_NoErr;
        }
        else
        {
            result = kError_BufferTooSmall;
        }

        *length = m_externalPlaylist.size() + 1;
    }

    m_mutex.Release();
    return result;
}

Error PlaylistManager::SetPortablePlaylist(DeviceInfo* device, 
                                           PLMCallBackFunction function,
                                           void* cookie)
{
    Error result = kError_InvalidParam;

    assert(device);

    if(device)
    {
        result = ReadPortablePlaylist(device, NULL, function, cookie);
        m_portableDevice = *device;
    }

    return result;
}

Error PlaylistManager::GetPortablePlaylist(DeviceInfo* device)
{
    Error result = kError_InvalidParam;

    assert(device);

    if(device)
    {
        result = kError_NoErr;
        *device = m_portableDevice;
    }

    return result;
}


// External playlist support
bool PlaylistManager::IsSupportedPlaylistFormat(const char *extension)
{
    bool retvalue = false;

    m_mutex.Acquire();

    if (!extension)
        return false;

    uint32 numFormats = m_playlistFormats.size();

    for(uint32 index = 0; index < numFormats; index++)
    {
        PlaylistFormatInfo* format = m_playlistFormats[index];

        if(!strcasecmp(extension, format->GetExtension()))
        {
            retvalue = true;
            break;
        }
    }

    m_mutex.Release();
  
    return retvalue;
}

Error PlaylistManager::GetSupportedPlaylistFormats(PlaylistFormatInfo* format, 
                                                   uint32 index)
{
    Error result = kError_InvalidParam;

    assert(format);

    if(format)
    {
        result = kError_NoMoreFormats;

        uint32 numFormats = m_playlistFormats.size();

        if(index < numFormats)
        {
            result = kError_NoErr;

            *format = *m_playlistFormats[index];
        }
    }

    return result;
}

Error PlaylistManager::ReadPlaylist(const char* url, 
                                    vector<PlaylistItem*>* items,
                                    PLMCallBackFunction function,
                                    void* cookie)
{
    Error result = kError_InvalidParam;

    assert(url);

    if(url)
    {
        // find a suitable plugin
        result = kError_FormatNotSupported;
        char* extension = strrchr(url, '.');

        if(extension)
        {
            extension++;

            uint32 numFormats = m_playlistFormats.size();

            for(uint32 index = 0; index < numFormats; index++)
            {
                PlaylistFormatInfo* format = m_playlistFormats[index];
                
                if(!strcasecmp(extension, format->GetExtension()))
                {
                    bool addToActiveList = false;

                    if(!items)
                    {
                        items = new vector<PlaylistItem*>;
                        addToActiveList = true;
                    }

                    result = format->GetRef()->ReadPlaylist(url, 
                                                            items, 
                                                            function, 
                                                            cookie);

                    if(addToActiveList)
                    {
                        AddItems(items);
                        delete items;
                    }

                    break;
                }
            }
        }
    }

    return result;
}

Error PlaylistManager::WritePlaylist(const char* url, 
                                     PlaylistFormatInfo* format, 
                                     vector<PlaylistItem*>* items,
                                     PLMCallBackFunction function,
                                     void* cookie)
{
    Error result = kError_InvalidParam;

    assert(url);
    assert(format);

    if(url && format)
    {
        if(!items)
        {
            items = m_activeList;
        }
        result = format->GetRef()->WritePlaylist(url, 
                                                 format, 
                                                 items, 
                                                 function, 
                                                 cookie);
    }

    return result;
}

Error PlaylistManager::WritePlaylist(const char* url, 
                                     vector<PlaylistItem*>* items,
                                     PLMCallBackFunction function,
                                     void* cookie)
{
    Error result = kError_InvalidParam;

    assert(url);

    if(url)
    {
        // find a suitable plugin
        result = kError_FormatNotSupported;
        char* extension = strrchr(url, '.');

        if(extension)
        {
            extension++;

            uint32 numFormats = m_playlistFormats.size();

            for(uint32 index = 0; index < numFormats; index++)
            {
                PlaylistFormatInfo* format = m_playlistFormats[index];
                
                if(!strcasecmp(extension, format->GetExtension()))
                {
                    if(!items)
                    {
                        items = m_activeList;
                    }

                    result = format->GetRef()->WritePlaylist(url, 
                                                             format, 
                                                             items, 
                                                             function, 
                                                             cookie);
                    break;
                }
            }
        }
    }

    return result;
}


// Portable player communication
Error PlaylistManager::GetSupportedPortables(DeviceInfo* device, uint32 index)
{
    Error result = kError_InvalidParam;