playlist.cpp

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

    assert(device);

    if(device)
    {
        result = kError_NoMoreDevices;

        uint32 numDevices = m_portablePlayers.size();

        if(index < numDevices)
        {
            result = kError_NoErr;

            *device = *m_portablePlayers[index];
        }
    }

    return result;
}

bool PlaylistManager::IsPortableAvailable(DeviceInfo* device)
{
    bool result = false;

    assert(device);

    if(device)
    {
        result = device->GetRef()->IsDeviceAvailable(device);
    }

    return result;
}

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

    assert(device);

    if(device)
    {
        result = device->GetRef()->GetDeviceInfo(device);
    }

    return result;
}

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

    assert(device);

    if(device)
    {
        result = device->GetRef()->InitializeDevice(device, function, cookie);
    }

    return result;

}


Error PlaylistManager::ReadPortablePlaylist(DeviceInfo* device,
                                            vector<PlaylistItem*>* items,
                                            PLMCallBackFunction function,
                                            void* cookie)
{
    Error result = kError_InvalidParam;

    assert(device);

    if(device)
    {
        // first delete old playlist

        if(!items)
        {
            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;
                    }
                }
            }
        }

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

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

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

    return result;
}

#if 0
Error PlaylistManager::ReadPortablePlaylist(DeviceInfo* device,
                                            PLMCallBackFunction function,
                                            void* cookie)
{
    Error result = kError_InvalidParam;

    assert(device);

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

        numItems = m_portableList.size();

        for(index = 0; index < numItems; index++)
        {
            item = m_portableList[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_portableList.clear();

        result = device->GetRef()->ReadPlaylist(device, 
                                                &m_portableList,
                                                function, 
                                                cookie);

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

    return result;
}

#endif

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

    assert(device);

    if(device)
    {
        result = device->GetRef()->WritePlaylist(device, 
                                                &m_externalList,
                                                function, 
                                                cookie);
    }

    return result;
}

Error PlaylistManager::DownloadItemFromPortable(DeviceInfo* device,
                                                PlaylistItem* item,
                                                const char* url,
                                                PLMCallBackFunction function,
                                                void* cookie)
{
    Error result = kError_InvalidParam;

    assert(device);
    assert(item);
    assert(url);

    if(device && item && url)
    {
        result = device->GetRef()->DownloadSong(device, 
                                                item,
                                                url,
                                                function, 
                                                cookie);
    }

    return result;
}

uint32 PlaylistManager::Time()
{
    uint32 time = 0;

    //m_mutex.Acquire();

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

    for(; i != m_activeList->end();i++)
    {
       time += (*i)->GetMetaData().Time();
    }

    //m_mutex.Release();

    return time;
}

// Utility Functions
bool PlaylistManager::IsEmpty()
{
    bool result;
    m_mutex.Acquire();

    result = m_activeList->empty();

    m_mutex.Release();
    return result;
}

uint32 PlaylistManager::CountItems()
{
    uint32 result;
    m_mutex.Acquire();

    result = m_activeList->size();

    m_mutex.Release();
    return result;
}

PlaylistItem* PlaylistManager::ItemAt(uint32 index)
{
    PlaylistItem* result = NULL;
    m_mutex.Acquire();
    
    index = CheckIndex(index);

    if(index != kInvalidIndex)
    {
        result = (*m_activeList)[index];
    }
    
    m_mutex.Release();
    return result;
}

uint32 PlaylistManager::IndexOf(const PlaylistItem* item)
{
    return InternalIndexOf(m_activeList, item);
}

uint32 PlaylistManager::InternalIndexOf(vector<PlaylistItem*>* list,
                                        const PlaylistItem* item)
{
    uint32 result = kInvalidIndex;
    uint32 index = 0;
    uint32 size = 0;

    assert(list);
    assert(item);

    if(list && item)
    {
        vector<PlaylistItem*>::iterator i = list->begin();
        size = list->size();

        for(index = 0; i != list->end();i++,  index++)
        {
            if(item == (*i))
            {
                result = index;
                break;
            }
        }
    }
    
    return result;
}

bool PlaylistManager::HasItem(const PlaylistItem* item)
{
    return (IndexOf(item) != kInvalidIndex);
}


bool PlaylistManager::CanUndo()
{
    m_mutex.Acquire();
    
    bool result = m_undo.CanUndo();
    
    m_mutex.Release();

    return result;
}

bool PlaylistManager::CanRedo()
{
    m_mutex.Acquire();

    bool result = m_undo.CanRedo();
    
    m_mutex.Release();

    return result;    
}

void PlaylistManager::Undo()
{
    m_mutex.Acquire();
    
    m_undo.Undo();
    
    m_mutex.Release();
}

void PlaylistManager::Redo()
{
    m_mutex.Acquire();
    
    m_undo.Redo();
    
    m_mutex.Release();
}

// Internal functions

inline uint32 PlaylistManager::CheckIndex(uint32 index)
{
	// If we're dealing with a bogus index then set it to -1.
	if(index >= CountItems())
    {
		index = kInvalidIndex;
    }

	return index;
}

void PlaylistManager::AddItemToShuffleList(PlaylistItem* item)
{
    m_shuffleList.push_back(item);
}

void PlaylistManager::AddItemsToShuffleList(vector<PlaylistItem*>* list)
{
	ShuffleIt(list);

    m_shuffleList.insert(m_shuffleList.end(),
                         list->begin(), 
                         list->end());
}

void
PlaylistManager::
MetaDataThreadFunction(vector<PlaylistItem*>* list)
{
    assert(list);

    if(list)
    {
        uint32 index = 0;
        uint32 numItems = 0;
        PlaylistItem* item = NULL;

        numItems = list->size();

        vector<PlaylistItem*> pl_items;

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

            if(item)
            {
                MetaData metadata;
                MetaData* dbData = NULL;

                // is there any metadata stored for this item in the music db?
                dbData = m_context->catalog->ReadMetaDataFromDatabase(item->URL().c_str());

                if(dbData)
                {
                    metadata = *dbData;
                    delete dbData;
                }
                else // if not look to see if the file contains metadata
                {
                    metadata = item->GetMetaData();
                    MetaDataFormat* mdf = NULL;
                    uint32 numFormats;

                    numFormats = m_metadataFormats.size();

                    for(uint32 i = 0; i < numFormats; i++)
                    {
                        mdf = m_metadataFormats[i];

                        if(mdf)
                        {
                            mdf->ReadMetaData(item->URL().c_str(), &metadata);
                        }
                    }
                }                

                m_mutex.Acquire();

                if(item->GetState() == kPlaylistItemState_Delete)
                {
                    delete item;
                }
                else
                {
                    item->SetMetaData(&metadata);
                    item->SetState(kPlaylistItemState_Normal);

                    if(item == GetCurrentItem())
                        pl_items.insert(pl_items.begin(), item);
                    else
                        pl_items.push_back(item);
                }

                m_mutex.Release();
            }
        }     

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

        delete list;
    }
}

typedef struct MetaDataThreadStruct{
    PlaylistManager* plm;
    vector<PlaylistItem*>* items;
    Thread* thread;
} MetaDataThreadStruct;

void 
PlaylistManager::
metadata_thread_function(void* arg)
{
    MetaDataThreadStruct* mts = (MetaDataThreadStruct*)arg;

    mts->plm->MetaDataThreadFunction(mts->items);

    delete mts->thread;
    delete mts;
}

void PlaylistManager::RetrieveMetaData(PlaylistItem* item)
{
    assert(item);

    if(item)
    {
        vector<PlaylistItem*>* items = new vector<PlaylistItem*>;

        if(items)
        {
            items->push_back(item);
    
            RetrieveMetaData(items);
        }
    }
}

void PlaylistManager::RetrieveMetaData(vector<PlaylistItem*>* list)
{
    uint32 inde