player.cpp

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

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

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

void 
Player::
SetEQData(Event *pEvent)
{
   if (((SetEqualizerDataEvent *) pEvent)->IsEQData())
   {
       memcpy(m_eqValues, ((SetEqualizerDataEvent *) pEvent)->GetEQData(), 
              sizeof(float) * 32);
       m_eqPreamp = ((SetEqualizerDataEvent *) pEvent)->GetPreamp(); 
   }
   else
       m_eqEnabled = ((SetEqualizerDataEvent *) pEvent)->GetEnableState();

   if (m_lmc && m_pmo)
   {
       if (((SetEqualizerDataEvent *) pEvent)->IsEQData())
       {
           m_eqPreamp = ((SetEqualizerDataEvent *) pEvent)->GetPreamp(); 
           m_lmc->SetEQData(m_eqValues, m_eqPreamp);
       }
       else
           m_lmc->SetEQData(m_eqEnabled);
   }
   delete pEvent;
}

#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;
} 

void 
Player::
HandleAudioSigGenerated(Event *pEvent)
{
    AudioSignatureGeneratedEvent *asge = (AudioSignatureGeneratedEvent *)pEvent;
    if (m_sigspmo)
        delete asge->PMO();
    m_sigspmo = NULL;
    m_musicCatalog->AcceptEvent(pEvent);

    delete pEvent;
}

void 
Player::
HandleAudioSigFailed(Event *pEvent)
{
    AudioSignatureFailedEvent *asfe = (AudioSignatureFailedEvent *)pEvent;
    if (m_sigspmo)
        delete asfe->PMO();
    m_sigspmo = NULL;
    m_musicCatalog->AcceptEvent(pEvent);

    delete pEvent;
}

void
Player::
HandlePrefsChanged(Event *pEvent)
{
#ifndef WIN32
    bool pollCD = false;
    m_context->prefs->GetPrefBoolean(kCheckCDAutomaticallyPref, &pollCD);

    if (pollCD && !m_cdTimerActive)
        m_context->timerManager->StartTimer(&m_cdTimer, cd_timer, 5, this);
    else if (!pollCD && m_cdTimerActive)
        m_context->timerManager->StopTimer(m_cdTimer);
 
    m_cdTimerActive = pollCD;
#endif

    bool useProxy = false;
    m_context->prefs->GetPrefBoolean(kUseProxyPref, &useProxy);
    if (useProxy)
    {
       uint32 size = 1024;
       char *buffer = (char *)malloc(size);

       if (kError_BufferTooSmall == m_context->prefs->GetPrefString(
                                                 kProxyHostPref, buffer, &size))
       {
           buffer = (char *)realloc(buffer, size);
           m_context->prefs->GetPrefString(kProxyHostPref, buffer, &size);
       }

       char *port = strrchr(buffer, ':');
       if (port) {
           *port = '\0';
           port++;
       }

       string proxyAddr = string(buffer, strlen(buffer) + 1);
       int nPort = 80;
       if (port && *port)
           nPort = atoi(port);

       free(buffer);
       m_APSInterface->SetProxy(proxyAddr.c_str(), nPort);
    }
    else
       m_APSInterface->SetProxy("", 0);


    SendEventToUI(pEvent);
    SendEventToCatalog(pEvent);

    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_PrefsChanged:
            HandlePrefsChanged(pC);
            break;

        case INFO_PlaylistItemsUpdated:
            SendEventToUI(pC);
            SendEventToCatalog(pC);
            delete pC;
            break;

        case INFO_AudioSignatureGenerated:
            HandleAudioSigGenerated(pC);
            break;

        case INFO_AudioSignatureFailed:
            HandleAudioSigFailed(pC);
            break;

        case INFO_UserMessage:
        case INFO_StatusMessage:
        case INFO_BrowserMessage:
        case INFO_ErrorMessage:
        case INFO_FileNotFound:
        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_HeadlineText:
        case INFO_SearchMusicDone:
        case INFO_DownloadItemAdded:
        case INFO_DownloadItemRemoved:
        case INFO_DownloadItemNewState:
        case INFO_DownloadItemProgress:
        case INFO_MusicCatalogTrackAdded:
        case INFO_MusicCatalogTrackRemoved:
        case INFO_MusicCatalogStreamAdded:
        case INFO_MusicCatalogStreamRemoved:
        case INFO_MusicCatalogPlaylistAdded:
        case INFO_MusicCatalogPlaylistRemoved:
        case INFO_MusicCatalogTrackChanged:
        case INFO_MusicCatalogCleared:
        case INFO_MusicCatalogRegenerating:
        case INFO_MusicCatalogDoneRegenerating:
        case INFO_CDDiscStatus:
        case INFO_UnsignaturedTracksExist:
        case INFO_SignaturingStarted:
        case INFO_SignaturingStopped:
        case INFO_VorbisInfo:
        case CMD_AddFiles:
        case CMD_LoadTheme:
        case CMD_ShowPreferences:
        case CMD_EditCurrentPlaylistItemInfo:
        case CMD_GeneratePlaylist:
        case INFO_CDNotFound:
        case INFO_DatabaseUpgraded:
            SendEventToUI(pC);
            delete pC;
            break;

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

        case CMD_SetEQData:
            SetEQData(pC);
            break;

        case CMD_GenerateSignature:
            GenerateSignature(pC);
            delete pC;
            break;

        case CMD_KillSigThread:
            KillSigThread(pC);
            delete pC;
            break;
         
#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::cd_timer(void* arg)
{
    Player* player = (Player*) arg;

    player->CDTimer();
}

void Player::UpdateCDNow(void)
{
    CDTimer();
}

void Player::CDTimer()
{
    Registry *pmoRegistry = m_context->player->GetPMORegistry();
    RegistryItem *pmo_item = NULL;
    int32 i = 0;

    if (!pmoRegistry)
        return;

    while(NULL != (pmo_item = pmoRegistry->GetItem(i++))) 
    {
        if(!strcmp("cd.pmo", pmo_item->Name())) 
        {
            break;
        }
    }

    if(!pmo_item)
        return;

    PhysicalMediaOutput *pmo;
    pmo = (PhysicalMediaOutput *)pmo_item->InitFunction()(m_context);
    pmo->SetPropManager(m_context->props);

    if(IsError(pmo->Init(NULL))) 
    {
        CDInfoEvent *cie = new CDInfoEvent(0, 0, "");
        AcceptEvent(cie);
    }

    delete pmo;
}

void Player::synclog_timer(void* arg)
{
    Player* player = (Player*) arg;

    player->SyncLog();
}

void Player::SyncLog()
{
    m_context->aps->SyncLog();
}