helix-sp.cpp

来自「Amarok是一款在LINUX或其他类UNIX操作系统中运行的音频播放器软件。 」· C++ 代码 · 共 2,109 行 · 第 1/4 页

                                     const char *&description,
                                     const char *&copyright,
                                     const char *&moreinfourl) const
{
   if (index < m_numPlugins)
   {
      description = m_pluginInfo[index]->description;
      copyright   = m_pluginInfo[index]->copyright;
      moreinfourl = m_pluginInfo[index]->moreinfourl;

      return 0;
   }
   return -1;
}


void HelixSimplePlayer::play(const char *file, int playerIndex, bool fadein, bool fadeout, unsigned long fadetime)
{
   if (!setURL(file, playerIndex))
      play(playerIndex, fadein, fadeout, fadetime);
}

void HelixSimplePlayer::play(int playerIndex, bool fadein, bool fadeout, unsigned long fadetime)
{
   int i;
   int firstPlayer = playerIndex == ALL_PLAYERS ? 0 : playerIndex;
   int lastPlayer  = playerIndex == ALL_PLAYERS ? nNumPlayers : playerIndex + 1;

   nPlay = 0;
   nNumPlayRepeats=1;
   while(nPlay < nNumPlayRepeats)
   {
      nPlay++;
      if (bEnableVerboseMode)
      {
         print2stdout("Starting play #%d...\n", nPlay);
      }
      //print2stderr("firstplayer = %d  lastplayer=%d\n",firstPlayer,lastPlayer);

      UINT32 starttime=0, endtime=0, now=0;
      for (i = firstPlayer; i < lastPlayer; i++)
      {
         // start is already protected...
         start(i, fadein, fadetime);

         starttime = GetTime();
         endtime = starttime + nTimeDelta;
         while (1)
         {
            pthread_mutex_lock(&m_engine_m);
            DoEvents(nTimeDelta);
            pthread_mutex_unlock(&m_engine_m);
            now = GetTime();
            if (now >= endtime)
               break;
            if (fadeout && !ppctrl[i]->bFadeOut && now > endtime - fadetime)
            {
               ppctrl[i]->bFadeOut = true;
               ((HSPPreMixAudioHook *)ppctrl[i]->pPreMixHook)->setFadelength(fadetime);
               ((HSPPreMixAudioHook *)ppctrl[i]->pPreMixHook)->setFadeout(true);
            }
         }
      }

      starttime = GetTime();
      if (nStopTime == -1)
      {
         bStopTime = false;
      }
      else
      {
         endtime = starttime + nStopTime;
      }
      bStopping = false;
      // Handle events coming from all of the players
      while (!done(playerIndex))
      {
         now = GetTime();
         if (!bStopping && bStopTime && now >= endtime)
         {
	    // Stop all of the players, as they should all be done now
	    if (bEnableVerboseMode)
	    {
               print2stdout("\nEnd (Stop) time reached. Stopping...\n");
	    }
	    stop(playerIndex);
            bStopping = true;
         }
         pthread_mutex_lock(&m_engine_m);
         DoEvent();
         pthread_mutex_unlock(&m_engine_m);
      }

      // Stop all of the players, as they should all be done now
      if (bEnableVerboseMode)
      {
         print2stdout("\nPlayback complete. Stopping all players...\n");
      }
      stop(playerIndex);

      // repeat until nNumRepeats
   }
}

void HelixSimplePlayer::start(int playerIndex, bool fadein, unsigned long fadetime)
{
   if (playerIndex == ALL_PLAYERS)
   {
      int i;
      for (i=0; i<nNumPlayers; i++)
         start(i, fadein, fadetime);
   }
   else
   {
      if (!ppctrl[playerIndex]->pszURL)
         return;

      print2stderr("START MASTER VOL: %d\n",getDirectMasterVolume());

      if (bEnableVerboseMode)
      {
         print2stdout("Starting player %d...\n", playerIndex);
      }

      ppctrl[playerIndex]->bFadeIn = fadein;
      ppctrl[playerIndex]->bFadeOut = false; // assume we'll only fade out if we have another track
      ppctrl[playerIndex]->ulFadeLength = fadetime;
      if (!ppctrl[playerIndex]->bPlaying)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pPlayer->Begin();
         pthread_mutex_unlock(&m_engine_m);

         ppctrl[playerIndex]->bPlaying = true;
         ppctrl[playerIndex]->bStarting = true;
         //print2stderr("Begin player %d\n", playerIndex);
      }
   }
}


void HelixSimplePlayer::start(const char *file, int playerIndex, bool fadein, unsigned long fadetime)
{
   setURL(file, playerIndex);
   start(playerIndex, fadein, fadetime);
}



bool HelixSimplePlayer::done(int playerIndex)
{
   BOOL bAllDone = true;

   if (playerIndex == ALL_PLAYERS)
      // Start checking at the end of the array since those players
      // were started last and are therefore more likely to not be
      // finished yet.
      for (int i = nNumPlayers - 1; i >= 0 && bAllDone; i--)
      {
         pthread_mutex_lock(&m_engine_m);
         if (ppctrl[i]->bStarting || !ppctrl[i]->pPlayer->IsDone())
            ppctrl[i]->bPlaying = (bAllDone = false);
         pthread_mutex_unlock(&m_engine_m);
      }
   else
   {
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         if ((bAllDone = (!ppctrl[playerIndex]->bStarting && ppctrl[playerIndex]->pPlayer->IsDone())))
            ppctrl[playerIndex]->bPlaying = false;
         pthread_mutex_unlock(&m_engine_m);
      }
   }

   return bAllDone;
}

void HelixSimplePlayer::stop(int playerIndex)
{
   if (playerIndex == ALL_PLAYERS)
      for (int i = 0; i < nNumPlayers; i++)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[i]->pPlayer->Stop();
         pthread_mutex_unlock(&m_engine_m);

         ppctrl[i]->bPlaying = false;
         ppctrl[i]->bStarting = false;
         ppctrl[i]->isLocal = false;
      }
   else
   {
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pPlayer->Stop();
         pthread_mutex_unlock(&m_engine_m);
         ppctrl[playerIndex]->bPlaying = false;
         ppctrl[playerIndex]->bStarting = false;
         ppctrl[playerIndex]->isLocal = false;
         memset(&ppctrl[playerIndex]->md, 0, sizeof(ppctrl[playerIndex]->md));
      }
   }
}

HelixSimplePlayer::metaData *HelixSimplePlayer::getMetaData(int playerIndex)
{
   return &ppctrl[playerIndex]->md;
}


void HelixSimplePlayer::dispatch()
{
   struct _HXxEvent *pNothing = 0x0;
   struct timeval tv;
   int volAfter = 0;

   tv.tv_sec = 0;
   tv.tv_usec = SLEEP_TIME*1000;

   if (m_urlchanged)
   {
#ifdef USE_HELIX_ALSA
      m_MvolBefore = getDirectMasterVolume();
      print2stderr("Master Volume is: %d\n", m_MvolBefore);
#endif
      m_volBefore = getDirectPCMVolume();
      m_urlchanged = false;
      print2stderr("Volume is: %d\n", m_volBefore);
   }
   pEngine->EventOccurred(pNothing);
#ifdef USE_HELIX_ALSA
   if (m_MvolBefore > 0 && m_MvolAtStart != m_MvolBefore && (volAfter = getDirectMasterVolume()) != m_MvolBefore)
   {
      print2stderr("RESETTING MASTER VOLUME TO: %d\n", m_MvolBefore);
      setDirectMasterVolume(m_volBefore);
      print2stderr("Now Master Volume is %d\n", getDirectMasterVolume());
      m_MvolBefore = -1;
   }
#endif
   if (m_volBefore > 0 && m_volAtStart != m_volBefore && (volAfter = getDirectPCMVolume()) != m_volBefore)
   {
      print2stderr("RESETTING VOLUME TO: %d\n", m_volBefore);
      setDirectPCMVolume(m_volBefore);
      print2stderr("Now Volume is %d\n", getDirectPCMVolume());
      m_volBefore = -1;
   }
}


bool HelixSimplePlayer::isPlaying(int playerIndex) const
{
   if (playerIndex < nNumPlayers)
      return ppctrl[playerIndex]->bPlaying;
   else
      return false;
}

bool HelixSimplePlayer::isLocal(int playerIndex) const
{
   if (playerIndex < nNumPlayers)
      return (ppctrl[playerIndex]->isLocal && duration(playerIndex));
   else
      return false;
}

void HelixSimplePlayer::pause(int playerIndex)
{
   int i;

   if (playerIndex == ALL_PLAYERS)
      for (i=0; i<nNumPlayers; i++)
         pause(i);
   else
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pPlayer->Pause();
         pthread_mutex_unlock(&m_engine_m);
         ppctrl[playerIndex]->bPlaying = false;
      }
}

void HelixSimplePlayer::resume(int playerIndex)
{
   int i;

   if (playerIndex == ALL_PLAYERS)
      for (i=0; i<nNumPlayers; i++)
         resume(i);
   else
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pPlayer->Begin();
         pthread_mutex_unlock(&m_engine_m);
         ppctrl[playerIndex]->bPlaying = true;
      }
}


void HelixSimplePlayer::seek(unsigned long pos, int playerIndex)
{
   int i;

   if (playerIndex == ALL_PLAYERS)
      for (i=0; i<nNumPlayers; i++)
         seek(pos, i);
   else
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pPlayer->Seek(pos);
         pthread_mutex_unlock(&m_engine_m);
      }
}

unsigned long HelixSimplePlayer::where(int playerIndex) const
{
   if (playerIndex < nNumPlayers && ppctrl[playerIndex]->pHSPContext)
      //return ppctrl[playerIndex]->pHSPContext->position();
      return ppctrl[playerIndex]->pPlayer->GetCurrentPlayTime();
   else
      return 0;
}

unsigned long HelixSimplePlayer::duration(int playerIndex) const
{
   if (playerIndex < nNumPlayers && ppctrl[playerIndex]->pHSPContext)
      return ppctrl[playerIndex]->pHSPContext->duration();
   else
      return 0;
}

unsigned long HelixSimplePlayer::getVolume(int playerIndex)
{
   unsigned long vol;

   if (playerIndex < nNumPlayers)
   {
      pthread_mutex_lock(&m_engine_m);
      vol = ppctrl[playerIndex]->volume;
      //if (ppctrl[playerIndex]->pVolume)
         //pVolume->GetVolume();
      pthread_mutex_unlock(&m_engine_m);

      return (vol);
   }
   else
      return 0;
}

void HelixSimplePlayer::setVolume(unsigned long vol, int playerIndex)
{
   int i;

   if (playerIndex == ALL_PLAYERS)
   {
      for (i=0; i<nNumPlayers; i++)
         setVolume(vol, i);
   }
   else
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
#ifndef HELIX_SW_VOLUME_INTERFACE
         ppctrl[playerIndex]->volume = vol;
         ((HSPFinalAudioHook *)pFinalAudioHook)->setGain(vol);
#else
         ppctrl[playerIndex]->pVolume->SetVolume(vol);
#endif
         pthread_mutex_unlock(&m_engine_m);
      }
}

void HelixSimplePlayer::setMute(bool mute, int playerIndex)
{
   int i;

   if (playerIndex == ALL_PLAYERS)
   {
      for (i=0; i<nNumPlayers; i++)
         setMute(mute, i);
   }
   else
      if (playerIndex < nNumPlayers)
      {
         pthread_mutex_lock(&m_engine_m);
         ppctrl[playerIndex]->pVolume->SetMute(mute);
         pthread_mutex_unlock(&m_engine_m);
      }
}


bool HelixSimplePlayer::getMute(int playerIndex)
{
   bool ismute;

   if (playerIndex < nNumPlayers)
   {
      pthread_mutex_lock(&m_engine_m);
      ismute = ppctrl[playerIndex]->ismute;
//pVolume->GetMute();
      pthread_mutex_unlock(&m_engine_m);

      return ismute;
   }
   else
      return false;
}

bool HelixSimplePlayer::ReadGUIDFile()
{
   BOOL  bSuccess = false;
   FILE* pFile    = NULL;
   int   nNumRead = 0;
   int   readSize = 10000;
   char*  pszBuffer = new char[readSize];

   if (m_pszGUIDFile)
   {
      if((pFile = fopen(m_pszGUIDFile, "r")) != NULL)
      {
         // Read in the entire file
         nNumRead = fread(pszBuffer, sizeof(char), readSize, pFile);
         pszBuffer[nNumRead] = '\0';

         // Store it for later parsing
         m_pszGUIDList = new char[nNumRead + 1];
         strcpy(m_pszGUIDList, pszBuffer); /* Flawfinder: ignore */

         fclose(pFile);
         pFile = NULL;

         if (nNumRead > 0)
         {
            bSuccess = true;
         }
      }
   }

   delete [] pszBuffer;

   return bSuccess;
}


void HelixSimplePlayer::addScopeBuf(struct DelayQueue *item, int playerIndex)
{
   if (playerIndex >=0 && playerIndex < nNumPlayers)
   {
      pthread_mutex_lock(&ppctrl[playerIndex]->m_scope_m);

      if (ppctrl[playerIndex]->scopebuftail)
      {
         item->fwd = 0;
         ppctrl[playerIndex]->scopebuftail->fwd = item;
         ppctrl[playerIndex]->scopebuftail = item;
         ppctrl[playerIndex]->scopecount++;
      }
      else
      {
         item->fwd = 0;
         ppctrl[playerIndex]->scopebufhead = item;
         ppctrl[playerIndex]->scopebuftail = item;
         ppctrl[playerIndex]->scopecount = 1;
      }
      pthread_mutex_unlock(&ppctrl[playerIndex]->m_scope_m);
   }
}

struct DelayQueue *HelixSimplePlayer::getScopeBuf(int playerIndex)
{
   if (playerIndex >=0 && playerIndex < nNumPlayers)
   {
      pthread_mutex_lock(&ppctrl[playerIndex]->m_scope_m);

      struct DelayQueue *item = ppctrl[playerIndex]->scopebufhead;

      if (item)
      {
         ppctrl[playerIndex]->scopebufhead = item->fwd;
         ppctrl[playerIndex]->scopecount--;
         if (!ppctrl[playerIndex]->scopebufhead)
            ppctrl[playerIndex]->scopebuftail = 0;
      }

      pthread_mutex_unlock(&ppctrl[playerIndex]->m_scope_m);

      return item;
   }
   else
      return 0;
}

int HelixSimplePlayer::peekScopeTime(unsigned long &t, int playerIndex)
{
   if (playerIndex >=0 && playerIndex < nNumPlayers)
   {
      if (ppctrl[playerIndex]->scopebufhead)
         t = ppctrl[playerIndex]->scopebufhead->time;
      else
         return -1;
      return 0;
   }
   return -1;
}

void HelixSimplePlayer::clearScopeQ(int playerIndex)
{
   if (playerIndex < 0)
   {
      for (int i=0; i<nNumPlayers; i++)
         clearScopeQ(i);
   }
   else
   {
      struct DelayQueue *item;
      while ((item = getScopeBuf(playerIndex)))
         delete item;
   }
}