player.cpp

来自「这是一个mp3的源代码」· C++ 代码 · 共 1,991 行 · 第 1/4 页

   m_plm->GotoNextItem(true);

   if (m_playerState != PlayerState_Stopped)
   {
       if (m_playerState == PlayerState_Paused)
       {
          AcceptEvent(new Event(CMD_PlayPaused));
       }   
       else
       { 
          AcceptEvent(new Event(CMD_Play));
       }   
   }

   delete pEvent;
}

void 
Player::
Previous(Event *pEvent)
{
   if (m_playerState != PlayerState_Stopped)
   {
      AcceptEvent(new Event(CMD_Stop));
   }

   m_plm->GotoPreviousItem(true);

   if (m_playerState != PlayerState_Stopped)
   {
       if (m_playerState == PlayerState_Paused)
          AcceptEvent(new Event(CMD_PlayPaused));
       else
          AcceptEvent(new Event(CMD_Play));
   }

   delete pEvent;
}

void 
Player::
Pause(Event *pEvent)
{
   if (m_pmo)
   {
      m_pmo->Pause();
      if (SetState(PlayerState_Paused))
         SEND_NORMAL_EVENT(INFO_Paused);
   }
   delete pEvent;
}

void 
Player::
UnPause(Event *pEvent)
{
   if (m_pmo)
   {
      m_pmo->Resume();
      if (SetState(PlayerState_Playing))
         SEND_NORMAL_EVENT(INFO_Playing);
   }
   delete pEvent;
}

void 
Player::
TogglePause(Event *pEvent)
{
    if (m_pmo)
    {
       if (m_playerState == PlayerState_Playing)
           Pause(NULL);
       else
       if (m_playerState == PlayerState_Paused)
           UnPause(NULL);
    }

    delete pEvent;
}

int 
Player::
Quit(Event *pEvent)
{
   Event *pe;

   Stop(NULL);
   // 1) Set "I'm already quitting flag" (or exit if its already Set)
   m_imQuitting = 1;
   // 2) Get CIO/COO manipulation lock

   GetUIManipLock();
   // 3) Count CIO/COO, put into m_quitWaitingFor.
   m_quitWaitingFor = m_uiList->size();
   // 4) Send CMD_Cleanup event to all CIO/COOs

   pe = new Event(CMD_Cleanup);

   SendToUI(pe);
   delete    pe;

   delete  pEvent;

   if (m_quitWaitingFor == 0)
   {
      if (m_pTermSem)
      {
         m_pTermSem->Signal();
      }
      return 1;
   }
   else
   {
      ReleaseUIManipLock();
      return 0;
   }
}

int 
Player::
ReadyToDieUI(Event *pEvent)
{
   delete pEvent;

   if (!m_imQuitting)
       return 0;

   m_quitWaitingFor--;
   if (m_quitWaitingFor > 0)
       return 0;

   GetUIManipLock();
   if (m_pTermSem)
      m_pTermSem->Signal();

   return 1;
}

void 
Player::
HandleMediaInfo(Event *pEvent)
{
   MediaInfoEvent *pmvi;
   Event          *pe = NULL;
   
   GetUIManipLock();

   pmvi = (MediaInfoEvent *)pEvent;
   pmvi->m_indexOfSong = m_plm->GetCurrentIndex() + 1;         // zero based
   pmvi->m_totalSongs = m_plm->CountItems();

   SendToUI(pEvent);

   for (uint32 foobar = 0; foobar < pmvi->m_childEvents->size(); foobar++)
   {
      pe = (*pmvi->m_childEvents)[foobar];
      SendToUI(pe);
   }

   ReleaseUIManipLock();

   delete pEvent;
}

void 
Player::
HandleMediaTimeInfo(Event *pEvent)
{
   if (m_playerState == PlayerState_Playing)
   {
      GetUIManipLock();
      SendToUI(pEvent);
      ReleaseUIManipLock();
   }

   delete pEvent;
}

void 
Player::
SendEventToUI(Event *pEvent)
{
   GetUIManipLock();
   SendToUI(pEvent);
   ReleaseUIManipLock();
   delete pEvent;
}

void
Player::
SendEventToCatalog(Event *pEvent)
{
    if (m_musicCatalog)
        m_musicCatalog->AcceptEvent(pEvent);
}

#define _EQUALIZER_ENABLE_
#ifdef  _EQUALIZER_ENABLE_
void 
Player::
SetEQData(Event *pEvent)
{
   if (m_pmo)
   {
       if (((SetEqualizerDataEvent *) pEvent)->IsEQData())
           m_lmc->SetEQData(((SetEqualizerDataEvent *) pEvent)->GetEQData());
       else
           m_lmc->SetEQData(((SetEqualizerDataEvent *) pEvent)->GetEnableState());
   }
   delete pEvent;
}
#endif // _EQUALIZER_ENABLE_
#undef  _EQUALIZER_ENABLE_

#define _VISUAL_ENABLE_
#ifdef  _VISUAL_ENABLE_
void 
Player::
SendVisBuf(Event *pEvent)
{
   if (m_playerState == PlayerState_Playing)
   {
      GetUIManipLock();
      SendToUI(pEvent);
      ReleaseUIManipLock();
   }
   delete pEvent;
}
#endif // _VISUAL_ENABLE_
#undef  _VISUAL_ENABLE_

void
Player::
ToggleUI(Event *pEvent)
{
   switch (pEvent->Type()) 
   {
      case CMD_ToggleDownloadUI: {
           if (!m_downloadUI) {
              delete pEvent;
              return;
           }
           m_downloadUI->AcceptEvent(pEvent);
           break; }
      case CMD_TogglePlaylistUI: 
      case CMD_ToggleMusicBrowserUI: {
           if (!m_browserUI) {
              delete pEvent;
              return;
           }
           m_browserUI->AcceptEvent(pEvent);
           break; }
      default:
           break;
   }
   delete pEvent;
} 

int32 
Player::
ServiceEvent(Event * pC)
{
    if (!pC)
    {
      return 255;
    }

    //printf("Got event %d\n", pC->Type());
    switch (pC->Type())
    {
        case INFO_DoneOutputtingDueToError:
        case INFO_DoneOutputting:
            DoneOutputting(pC);
            break;

        case CMD_Stop:
            Stop(pC);
            break;

        case CMD_GetVolume:
            GetVolume(pC);
            break;

        case CMD_SetVolume:
            SetVolume(pC);
            break;

        case CMD_ChangePosition:
            ChangePosition(pC);
            break;

        case CMD_PlayPaused:
            Play(pC);
            break;

        case CMD_Play:
            Play(pC);
            break;

        case CMD_NextMediaPiece:
            Next(pC); 
            break;

        case CMD_PrevMediaPiece:
            Previous(pC);
            break;

        case CMD_Pause:
            Pause(pC);
            break;

        case CMD_UnPause:
            UnPause(pC);
            break;

        case CMD_TogglePause:
            TogglePause(pC);
            break;

        case CMD_QuitPlayer:
            return Quit(pC);

        case CMD_QueryPlayerState:
            HandleQueryState();
            break;

        case INFO_ReadyToDieUI:
            return ReadyToDieUI(pC);

        case INFO_MediaInfo:
            HandleMediaInfo(pC);
            break;

        case INFO_MediaTimeInfo:
            HandleMediaTimeInfo(pC);
            break;

        case INFO_PlaylistItemUpdated:
            SendEventToCatalog(pC);
            SendEventToUI(pC);
            break;

        case INFO_UserMessage:
        case INFO_StatusMessage:
        case INFO_BrowserMessage:
        case INFO_ErrorMessage:
        case INFO_PrefsChanged:
        case INFO_StreamInfo:
        case INFO_PlaylistShuffle:
        case INFO_PlaylistRepeat:
        case INFO_PlaylistUpdated:
        case INFO_PlaylistItemAdded:
        case INFO_PlaylistItemsAdded:
        case INFO_PlaylistItemRemoved:
        case INFO_PlaylistItemMoved:
        case INFO_PlaylistSorted:
        case INFO_PlaylistCurrentItemInfo:
        case INFO_BufferStatus:
        case INFO_SearchMusicDone:
        case INFO_DownloadItemAdded:
        case INFO_DownloadItemRemoved:
        case INFO_DownloadItemNewState:
        case INFO_DownloadItemProgress:
        case INFO_MusicCatalogTrackAdded:
        case INFO_MusicCatalogTrackRemoved:
        case INFO_MusicCatalogPlaylistAdded:
        case INFO_MusicCatalogPlaylistRemoved:
        case INFO_MusicCatalogTrackChanged:
        case INFO_MusicCatalogCleared:
        case CMD_AddFiles:
        case CMD_LoadTheme:
        case CMD_ShowPreferences:
            SendEventToUI(pC);
            break;

        case CMD_ToggleDownloadUI:
        case CMD_TogglePlaylistUI:
        case CMD_ToggleMusicBrowserUI:
            ToggleUI(pC);
            break;

#define _EQUALIZER_ENABLE_
#ifdef  _EQUALIZER_ENABLE_
        case CMD_SetEQData:
            SetEQData(pC);
            break;

#endif // _EQUALIZER_ENABLE_
#undef  _EQUALIZER_ENABLE_

#define _VISUAL_ENABLE_
#ifdef  _VISUAL_ENABLE_
        case CMD_SendVisBuf:
            SendVisBuf(pC);
            break;
#endif // _VISUAL_ENABLE_
#undef  _VISUAL_ENABLE_

        default:
            m_context->log->Error("serviceEvent: Unknown event: %d\n",
            pC->Type());
            delete  pC;
            break;
    }

    return 0;
}

Error     
Player::
PropertyChange(const char *pProp, PropValue * ppv)
{
   Error     rtn = kError_UnknownErr;

   return rtn;
}

void      
Player::
SendToUI(Event * pe)
{
   uint32     i;

   for (i = 0; i < m_uiList->size(); i++)
   {
      (*m_uiList)[i]->AcceptEvent(pe);
   }
}

Error     
Player::
GetProperty(const char *pProp, PropValue ** ppVal)
{
   return m_props.GetProperty(pProp, ppVal);
}

Error     
Player::
SetProperty(const char *pProp, PropValue * pVal)
{
   return m_props.SetProperty(pProp, pVal);
}

Error     
Player::
RegisterPropertyWatcher(const char *pProp, PropertyWatcher * pPropWatch)
{
   return m_props.RegisterPropertyWatcher(pProp, pPropWatch);
}

Error     
Player::
RemovePropertyWatcher(const char *pProp, PropertyWatcher * pPropWatch)
{
   return m_props.RemovePropertyWatcher(pProp, pPropWatch);
}

/*
   void Player::testQueue() {
   Event *pC;

   pC = m_eventQueue->Read();
   if (pC) {
   cout << "testQueue: First failed!!" << endl;
   } else {
   cout << "testQueue: First succeded!!" << endl;
   }
   cout << "testQueue: IsEmpty(): " << m_eventQueue->IsEmpty() << endl;

   pC = new Event(CMD_Play);
   AcceptEvent(pC);
   pC = new Event(CMD_Play);
   AcceptEvent(pC);
   pC = new Event(CMD_NextMediaPiece);
   AcceptEvent(pC);

   pC = m_eventQueue->Read();
   cout << "testQueue: " << pC->GetEvent() << endl;
   delete pC;
   pC = m_eventQueue->Read();
   cout << "testQueue: " << pC->GetEvent() << endl;
   delete pC;
   cout << "testQueue: IsEmpty(): " << m_eventQueue->IsEmpty() << endl;
   pC = m_eventQueue->Read();
   cout << "testQueue: " << pC->GetEvent() << endl;
   delete pC;
   pC = m_eventQueue->Read();
   if (pC) {
   cout << "testQueue: Failed!!!" << endl;
   } else {
   cout << "testQueue: Final Succeeded!!" << endl;
   }
   cout << "testQueue: IsEmpty(): " << m_eventQueue->IsEmpty() << endl;
   }
 */