hxplayercontrol.cpp

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

               player->stop(0);
               player->clearScopeQ(0);
               senddone(wfd);
               playing = false;
               if (pmapped)
               {
                  *m_children[m_index].current_time = 0;
                  *m_children[m_index].duration = 0;
               }
            }
            
            if (pmapped)
            {
               *m_children[m_index].current_time = player->where(0);
               *m_children[m_index].duration = player->duration(0);

               HelixSimplePlayer::metaData *md = player->getMetaData(0);
               if (md)
                  memcpy((void *) m_children[m_index].md, (void *) md, sizeof(HelixSimplePlayer::metaData));
               
               struct DelayQueue *item;
               //int j;
               while ((item = player->getScopeBuf(0)))
               {
                  //j = (*m_children[m_index].m_current + 1) % NUM_SCOPEBUFS;
                  
                  //cerr << "player:" << m_index << " j=" << j << " time=" << item->time << " etime=" << item->etime << " len=" << item->len << endl;
                  //m_children[m_index].q[j].len = item->len;
                  //m_children[m_index].q[j].time = item->time;
                  //m_children[m_index].q[j].etime = item->etime;
                  //m_children[m_index].q[j].nchan = item->nchan;
                  //m_children[m_index].q[j].bps = item->bps;
                  //m_children[m_index].q[j].tps = item->tps;
                  //m_children[m_index].q[j].spb = item->spb;
                  //memcpy((void *)m_children[m_index].q[j].buf, (void *) item->buf, item->len );
                  //*m_children[m_index].m_current = j;
                  //cerr << "player:" << m_index << " time=" << item->time << " etime=" << item->etime << endl;
                  sendscopebuf(wfd, item);
                  delete item;
               }
            }
         }
         
         timeout.tv_sec = 0;
         timeout.tv_usec = 10000;
      }
      cerr << "CHILD " << m_index << " will exit!\n";
   }
   else
   {
      int i;
      bool done = false, dead = false;

      sendsetoutputsink();
      sendsetdevice();
      sendinit();

      // wait for ready from children
      while (!done && !dead)
      {
         dispatch();
         done = true;
         for (i=0; i<numPlayers; i++)
         {
            done &= m_children[i].isready;
            dead |= m_children[i].isdead;
         }
      }

      if (dead)
      {
         m_err = -1;
         return;
      }
   }
   m_inited = true;
}


void PlayerControl::setOutputSink( HelixSimplePlayer::AUDIOAPI out )
{
   print2stderr("%%%% In PlayerControl::setOutputSink:%d\n", out);
   m_api = out;
}

void PlayerControl::setDevice( const char *dev )
{
   delete [] m_device;

   int len = strlen(dev);
   m_device = new char [len + 1];
   strcpy(m_device, dev); 
   print2stderr("%%%% In PlayerControl::setDevice:%s\n", dev);
}

int PlayerControl::initDirectSS()
{
   return 0;
}

void PlayerControl::tearDown()
{
   int tmp;
   if (iamparent)
   {
      for (int i = 0; i < nNumPlayers; i++)
      {
         if (m_inited)
         {
            sendteardown(m_children[i].m_pipeB[1]);
            close(m_children[i].m_pipeB[1]);
            close(m_children[i].m_pipeA[0]);
            cerr << "About to waitpid for pid " << m_children[i].m_pid << endl;
            kill(m_children[i].m_pid, SIGTERM);
            waitpid(m_children[i].m_pid, &tmp, 0);
         }
      }
   }
}

void PlayerControl::start(int playerIndex, bool fadein, unsigned long fadetime)
{
   m_children[playerIndex].isplaying = true;
   if (pmapped)
      *m_children[playerIndex].m_consumed = *m_children[playerIndex].m_current = 0;
   sendstart(m_children[playerIndex].m_pipeB[1], fadein, fadetime);
}

int PlayerControl::setURL(const char *url, int playerIndex, bool islocal)
{
   m_children[playerIndex].islocal = islocal;
   if (sendsetURL(m_children[playerIndex].m_pipeB[1], url, islocal))
      return 0;

   return -1;
}

bool PlayerControl::done(int playerIndex)
{
   return (!m_children[playerIndex].isplaying);
}

void PlayerControl::stop(int playerIndex)
{
   if (playerIndex == HelixSimplePlayer::ALL_PLAYERS)
   {
      for (int i=0; i<nNumPlayers; i++)
         stop(i);
   }
   else
   {
      m_children[playerIndex].isplaying = false;
      sendstop(m_children[playerIndex].m_pipeB[1]);
   }
}

void PlayerControl::pause(int playerIndex)
{
   sendpause(m_children[playerIndex].m_pipeB[1]);
}

void PlayerControl::resume(int playerIndex)
{
   sendresume(m_children[playerIndex].m_pipeB[1]);
}

void PlayerControl::seek(unsigned long pos, int playerIndex)
{
   sendmessage(m_children[playerIndex].m_pipeB[1], SEEK, (unsigned char *) &pos, sizeof(unsigned long));
}

unsigned long PlayerControl::where(int playerIndex) const
{
   if (pmapped)
      return *m_children[playerIndex].current_time;
   else
      return 0;
}

unsigned long PlayerControl::duration(int playerIndex) const
{
   if (pmapped)
      return *m_children[playerIndex].duration;
   else
      return 0;
}

unsigned long PlayerControl::getVolume()
{
   return m_volume;
}

void PlayerControl::setVolume(unsigned long vol)
{
   m_volume = vol;
   for (int i = 0; i < nNumPlayers; i++)
      sendsetvolume(m_children[i].m_pipeB[1], vol);
}

void PlayerControl::dispatch()
{
   int i;
   struct timeval timeout;
   int n = -1, ntot;
   int rfd;
   int wfd;

   timeout.tv_sec = 0;
   timeout.tv_usec = 0;
   fd_set rdset, wrset;

   FD_ZERO(&rdset);
   FD_ZERO(&wrset);

   for (i=0; i<nNumPlayers; i++)
   {
      rfd = m_children[i].m_pipeA[0];
      wfd = m_children[i].m_pipeB[1];
      FD_SET(rfd, &rdset);
      FD_SET(wfd, &wrset); // really should check to see if we can write, but not gonna
      if (rfd > n)
         n = rfd;
   }
   
   if (n < 0)
      return;
   
   ntot = select(n + 1, &rdset, 0, 0, &timeout);
   for (i=0; ntot && i < nNumPlayers; i++)
   {
      rfd = m_children[i].m_pipeA[0];
      wfd = m_children[i].m_pipeB[1];
      if ( FD_ISSET(rfd, &rdset) )
      {
         msgid m;
         unsigned char buf[65536];
         int sz = 0;
         
         if (getmessage(rfd, m, buf, sz))
         {
            switch (m)
            {
               case READY:
                  print2stderr("CHILD %d is READY\n", i);
                  m_children[i].isready = true;;
                  break;
                  
               case DONE:
                  print2stderr("CHILD %d is DONE\n", i);
                  if (!sz)
                  {
                     m_children[i].isplaying = false;
                     clearScopeQ(i);
                     play_finished(i);
                  }
                  else
                     print2stderr("PARENT: sz does not agree in DONE\n");
                  break;
                  
               case MIMETYPES:
               {
                  int len, slen;
                  MimeList *entry;
                  char *tmp;
                  char tmpbuf[65536];
                  
                  mimehead = 0;
                  memcpy( (void *) &mimelistlen, (void *) buf, sizeof(mimelistlen) );
                  len = sizeof(mimelistlen);
                  
                  print2stderr("%%%%%%% Received %d mimetypes\n", mimelistlen);
                  for (int j = 0; j < mimelistlen; j++)
                  {
                     tmp = (char *) &buf[len];
                     slen = strlen(tmp);
                     strcpy(tmpbuf, tmp);
                     tmp += slen + 1;
                     len += slen + 1;
                     entry = new MimeList(tmpbuf, tmp);
                     slen = strlen(tmp);
                     len += slen + 1;
                     
                     entry->fwd = mimehead;
                     mimehead = entry;
                  }

                  if (sz != len) // sanity check
                     cerr << "PARENT: sz not = len in MIMETYPES " << sz << " " << len << endl;                  
               }
               break;
               
               case PLUGINS:
               {
                  int len, slen;
                  int nplugins;
                  char *tmp;
                  
                  memcpy( (void *) &nplugins, (void *) buf, sizeof(nplugins) );
                  len = sizeof(nplugins);
                  m_pluginInfo = new pluginInfo* [nplugins];
                  m_numPlugins = nplugins;
                  
                  print2stderr("%%%%%%% Received %d plugins\n", nplugins);
                  for (int j = 0; j < nplugins; j++)
                  {
                     m_pluginInfo[j] = new pluginInfo;
                     
                     tmp = (char *) &buf[len];
                     slen = strlen(tmp);
                     m_pluginInfo[j]->description = new char[ slen + 1 ];
                     strcpy(m_pluginInfo[j]->description, tmp);
                     len += slen + 1;
                     
                     tmp = (char *) &buf[len];
                     slen = strlen(tmp);
                     m_pluginInfo[j]->copyright = new char[ slen + 1 ];
                     strcpy(m_pluginInfo[j]->copyright, tmp);
                     len += slen + 1;
                     
                     tmp = (char *) &buf[len];
                     slen = strlen(tmp);
                     m_pluginInfo[j]->moreinfourl = new char[ slen + 1 ];
                     strcpy(m_pluginInfo[j]->moreinfourl, tmp);
                     len += slen + 1;
                  }

                  if (sz != len) // sanity check
                     cerr << "PARENT: sz not = len in PLUGINS " << sz << " " << len << endl;
               }
               break;
               
               case CONTACTING:
               {
                  int len = strlen((const char *)buf);
                  if (sz == len + 1)
                     onContacting((const char *)buf);
                  else
                     cerr << "PARENT: sz not right in CONTACTING sz=" << sz << endl;
               }
               break;
               
               case BUFFERING:
               {
                  unsigned long percent;
                  if (sz == sizeof(unsigned long))
                  {
                     memcpy((void *)&percent, (void *) buf, sizeof(unsigned long));
                     onBuffering(percent);
                  }
                  else
                     cerr << "PARENT: sz not right in BUFFERING sz=" << sz << endl;                     
               }
               break;
               
               case NOTIFYUSER:
               {
                  int len1, len2;
                  unsigned long code;
                  const char *moreinfo, *moreinfourl;
                  memcpy((void *) &code, (void *) buf, sizeof(unsigned long));
                  moreinfo = (const char *) &buf[sizeof(unsigned long)];
                  len1 = strlen(moreinfo);
                  moreinfourl = (const char *) &moreinfo[ len1 + 1];
                  len2 = strlen(moreinfourl);
                  // sanity check
                  if ((unsigned) sz != sizeof(unsigned long) + len1 + len2 + 2)
                     cerr << "PARENT: sz not right in NOTIFYUSER sz=" << sz << endl;
                  
                  notifyUser(code, moreinfo, moreinfourl);
               }
               break;
               
               case INTERRUPTUSER:
               {
                  int len1, len2;
                  unsigned long code;
                  const char *moreinfo, *moreinfourl;
                  memcpy((void *) &code, (void *) buf, sizeof(unsigned long));
                  moreinfo = (const char *) &buf[sizeof(unsigned long)];
                  len1 = strlen(moreinfo);
                  moreinfourl = (const char *) &moreinfo[ len1 + 1];
                  len2 = strlen(moreinfourl);
                  // sanity check
                  if ((unsigned) sz != sizeof(unsigned long) + len1 + len2 + 2)
                     cerr << "PARENT: sz not right in INTERRUPTUSER sz=" << sz << endl;
                  
                  interruptUser(code, moreinfo, moreinfourl);
               }
               break;
               
               case SCOPEBUF:
               {
                  DelayQueue *item;
                  int bufsz, len = 0;
                  memcpy( (void *) &bufsz, (void *) buf, sizeof(int) ); len += sizeof(int);
                  if ((int) (bufsz + 2 * sizeof(unsigned long) + 4 * sizeof(int) + sizeof(double)) == sz)
                  {
                     item = new DelayQueue(bufsz);
                     memcpy( (void *) &item->time, (void *) &buf[len], sizeof(unsigned long) ); 
                     len += sizeof(unsigned long);
                     memcpy( (void *) &item->etime, (void *) &buf[len], sizeof(unsigned long) ); 
                     len += sizeof(unsigned long);
                     memcpy( (void *) &item->nchan, (void *) &buf[len], sizeof(int) ); len += sizeof(int);
                     memcpy( (void *) &item->bps, (void *) &buf[len], sizeof(int) ); len += sizeof(int);
                     memcpy( (void *) &item->tps, (void *) &buf[len], sizeof(double) ); len += sizeof(double);
                     memcpy( (void *) &item->spb, (void *) &buf[len], sizeof(int) ); len += sizeof(int);
                     memcpy( (void *) item->buf, (void *) &buf[len], item->len ); len += item->len;      

                     addScopeBuf(item, i);
                  }
                  else
                     cerr << "PARENT: sz not right in SCOPEBUF sz=" << sz << endl;
               }
               break;
               default:
                  print2stderr("PARENT recvd unhandled message %d\n", m);
                  break;
            }
         }
         else
         {
            m_children[i].isdead = true;
            return; // should never happen
         }
      }
   }
   
   for (i=0; pmapped && i<nNumPlayers; i++)
   {
      while (*m_children[i].m_consumed != *m_children[i].m_current)
      {
         addScopeBuf(&m_children[i].q[*m_children[i].m_consumed], i);