player.cpp

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

      lmc = (LogicalMediaConverter *)temp->InitFunction()(m_context);
      vector<string> *extList = lmc->GetExtensions();
      vector<string>::iterator i;

      for (i = extList->begin(); i != extList->end(); i++)
      {
          lmc_item = new RegistryItem(*temp);
          (*m_lmcExtensions)[(*i)] = lmc_item;
      }

      delete extList;
      delete lmc;
   }

   m_lmcMutex->Release();

   return result;
}

int32     
Player::
RegisterPMIs(Registry * registry)
{
   int32     result = 0;

   m_pmiMutex->Acquire();

   if (m_pmiRegistry)
   {
      Registrar::CleanupRegistry(m_pmiRegistry);
      delete    m_pmiRegistry;
   }

   if (m_pmiProtocols) {
       map<string, RegistryItem *>::iterator iter = m_pmiProtocols->begin();
       for (; iter != m_pmiProtocols->end(); iter++)
           delete (*iter).second;
       delete m_pmiProtocols;
   }

   m_pmiProtocols = new map<string, RegistryItem *>;
   m_pmiRegistry = registry;

   RegistryItem *pmi_item;
   PhysicalMediaInput *pmi;
   int iItems = registry->CountItems();

   for (int iLoop = 0; iLoop < iItems; iLoop++)
   {
      RegistryItem *temp = registry->GetItem(iLoop);

      pmi = (PhysicalMediaInput *)temp->InitFunction() (m_context);
      vector<string> *protoList = pmi->GetProtocols();
      vector<string>::iterator i;

      for (i = protoList->begin(); i != protoList->end(); i++)
      {
         pmi_item = new RegistryItem(*temp);
         (*m_pmiProtocols)[(*i)] = pmi_item;
      }

      delete protoList;
      delete pmi;
   }
   
   m_pmiMutex->Release();

   return result;
}

int32     
Player::
RegisterPMOs(Registry * registry)
{
   int32     result = 0;

   m_pmoMutex->Acquire();

   if (m_pmoRegistry)
   {
    Registrar::CleanupRegistry(m_pmoRegistry);
      delete    m_pmoRegistry;
   }

   m_pmoRegistry = registry;

   m_pmoMutex->Release();

   return result;
}

int32     
Player::
RegisterUIs(Registry * registry)
{
   int32     result = 0;

   m_uiMutex->Acquire();

   if (m_uiRegistry)
   {
    Registrar::CleanupRegistry(m_uiRegistry);
      delete    m_uiRegistry;
   }

   m_uiRegistry = registry;

   m_uiMutex->Release();

   return result;
}

Registry* 
Player::
GetLMCRegistry() const
{
    return m_lmcRegistry;
}

Registry* 
Player::
GetPMIRegistry() const
{
    return m_pmiRegistry;
}

Registry* 
Player::
GetPMORegistry() const
{
    return m_pmoRegistry;
}

Registry*  
Player::
GetUIRegistry() const
{
    return m_uiRegistry;
}

void 
Player::
GetUIManipLock()
{
   m_uiManipLock->Acquire();
}

void 
Player::
ReleaseUIManipLock()
{
   m_uiManipLock->Release();
}

Error 
Player::
AcceptEvent(Event * e)
{
   if (!m_eventQueue)
       return kError_YouScrewedUp;

   m_eventQueue->Write(e);
   m_eventSem->Signal();
   return kError_NoErr;
}

bool 
Player::
SetState(PlayerState ps)
{
#if 0
   printf("Player state: ");
   switch(ps)
   {
       case PlayerState_Stopped:
          printf("Stopped.\n");
          break;
       case PlayerState_Paused:
          printf("Paused.\n");
          break;
       case PlayerState_Playing:
          printf("Playing.\n");
          break;
       default:
          printf("Unknown.\n");
          break;
   }
#endif
   if (ps == m_playerState)
      return false;
   m_playerState = ps;
   return true;
}

char *
Player::
GetProtocol(const char *title)
{
   char *temp_proto;
   char *proto_return = NULL;

   temp_proto = strstr(title, "://");
   if(temp_proto)
   {
     int proto_len = temp_proto - title;
     proto_return = new char[ proto_len + 1];
     strncpy(proto_return, title, proto_len);
     proto_return[proto_len] = 0;
   }

   return proto_return;
}

char *
Player::
GetExtension(const char *title)
{
   char *temp_ext;
   char *ext_return = NULL;
   char *proto = NULL;

   temp_ext = strrchr(title, '.');
   if (temp_ext)
   {
      temp_ext = temp_ext + 1;
      ext_return = new char [strlen(temp_ext) + 1];
      strcpy(ext_return, temp_ext);
      char *p = ext_return;
      while (*p) {
         *p = toupper(*p);
         p++;
      }
   }

   if (!IsSupportedExtension(ext_return) && 
       !(m_plm->IsSupportedPlaylistFormat(ext_return)))
   {
       delete [] ext_return;
       ext_return = NULL;
       proto = GetProtocol(title);
 
       if (IsSupportedProtocol(proto) && (strncasecmp(proto, "file", 4) != 0))
       {
           ext_return = new char[4];
           strcpy(ext_return, "MP3");
       }
       if (proto)
           delete [] proto;
   }

   return ext_return;
}

bool
Player::
IsSupportedExtension(const char *ext)
{
   if (ext == NULL)
       return false;
   if (m_lmcExtensions->find(ext) != m_lmcExtensions->end())
       return true;
   return false;
}

bool
Player::
IsSupportedProtocol(const char *proto)
{
   if (proto == NULL)
       return false;
   if (m_pmiProtocols->find(proto) != m_pmiProtocols->end())
       return true;
   return false;
}

RegistryItem *
Player::
ChooseLMC(const char *szUrl)
{
   RegistryItem *lmc_item = NULL;
   char     *iExt;

   iExt = GetExtension(szUrl);
   if (!iExt)
      return NULL;

   if (m_lmcExtensions->find(iExt) != m_lmcExtensions->end()) 
       lmc_item = (*m_lmcExtensions)[iExt];

   delete iExt;

   return lmc_item;
}

RegistryItem *
Player::
ChoosePMI(const char *szUrl, char *szTitle)
{
   PhysicalMediaInput *pmi;
   RegistryItem *pmi_item, *ret = NULL;
   int       iLoop;
   char     *szNewUrl = NULL;

   if (strstr(szUrl, "://") == NULL)
   {
      szNewUrl = new char[strlen(szUrl) + strlen("file:// ") + 1];

      sprintf(szNewUrl, "file://%s", szUrl);

      szUrl = szNewUrl;
   }

   for (iLoop = 0; iLoop < m_pmiRegistry->CountItems(); iLoop++)
   {
      pmi_item = m_pmiRegistry->GetItem(iLoop);

      pmi = (PhysicalMediaInput *) pmi_item->InitFunction()(m_context);
      if (pmi->CanHandle(szUrl, szTitle))
      {
         ret = pmi_item;
         delete pmi;

         break;
      }
      delete pmi;
   }

   if (szNewUrl)
      delete szNewUrl;

   return ret;
}

void 
Player::
KillSigThread(Event *pEvent)
{
    m_sigStopMutex->Acquire();
    if (m_signatureThread) {
        m_bKillSignature = true;
        if (m_sigspmo) {
            delete m_sigspmo;
            m_sigspmo = NULL;
        }
        m_signatureThread->Join();

        delete m_signatureThread;
        m_signatureThread = NULL;
    }
    m_signatureThread = NULL;
    m_sigStopMutex->Release();
}
    
typedef struct GenerateSigsStruct {
    Player *player;
    Thread *thread;
    set<string> *tracks;
} GenerateSigsStruct;

void 
Player::
GenerateSignature(Event *pEvent)
{
    GenerateSignatureEvent *gse = (GenerateSignatureEvent *)pEvent;
    set<string> *tracks = gse->Tracks();

    m_sigStopMutex->Acquire();
    if (m_signatureThread) {
        m_bKillSignature = true;
        if (m_sigspmo) {
            delete m_sigspmo;
            m_sigspmo = NULL;
        }
        m_signatureThread->Join();

        delete m_signatureThread;
        m_signatureThread = NULL;
    }
    m_sigStopMutex->Release();
        
    m_signatureThread = Thread::CreateThread();
    if (m_signatureThread) {
        GenerateSigsStruct *gss = new GenerateSigsStruct;
        gss->player = this;
        gss->thread = m_signatureThread;
        gss->tracks = tracks;

        m_signatureThread->Create(generate_sigs_function, gss, false);
    }
}

void
Player::
generate_sigs_function(void *arg)
{
    GenerateSigsStruct *gss = (GenerateSigsStruct *)arg;
    gss->player->GenerateSigsWork(gss->tracks);

    delete gss;
}

void 
Player::
GenerateSigsWork(set<string> *items)
{
    //cout << "Generating signatures for " << items->size() << " tracks.\n";
    AcceptEvent(new Event(INFO_SignaturingStarted));

    set<string>::iterator i;
    while (items->size() > 0 && !m_bKillSignature) 
    {
        m_sigspmo = NULL;

        Error error = kError_NoErr;
        PhysicalMediaOutput *pmo = NULL;
        PhysicalMediaInput *pmi = NULL;
        LogicalMediaConverter *lmc = NULL;
        RegistryItem *pmi_item = NULL;
        RegistryItem *lmc_item = NULL;
        RegistryItem *item = NULL;

        i = items->begin();
        string url = *i;

        PlaylistItem *plitem = m_plm->GetCurrentItem();

        if (plitem && items->find(plitem->URL()) != items->end())
        {
            url = plitem->URL();
        }

        struct stat st;
	uint32 reallen = strlen(url.c_str()) + 1;
	char *realname = new char[reallen];
	URLToFilePath(url.c_str(), realname, &reallen);
        if (-1 == stat(realname, &st)) {
            delete [] realname;
            m_context->catalog->RemoveSong(url.c_str());
            items->erase(url);
	    continue;
	}

	delete [] realname;

        pmi_item = ChoosePMI(url.c_str());
        if (!pmi_item)
        {
           char szErr[1024];
 
           sprintf(szErr, "Cannot determine what pmi to use for %s\n", 
                   url.c_str());
           m_context->log->Error(szErr);
           AcceptEvent(new ErrorMessageEvent(szErr));

		   items->erase(url);
           continue;
        }

        lmc_item = ChooseLMC(url.c_str());
        if (!lmc_item)
        // FIXME: Should probably have a user definable default LMC
            lmc_item = ChooseLMC("blah.mp3");
   
        pmi = (PhysicalMediaInput *) pmi_item->InitFunction()(m_context);
        pmi->SetPropManager((Properties *) this);

        int32 i = 0;

        while (NULL != (item = m_pmoRegistry->GetItem(i++)))
            if (!strcmp("signature.pmo", item->Name()))
                break;

        if (!item) {
            delete pmi;
            break;
        }

        pmo = (PhysicalMediaOutput *) item->InitFunction()(m_context);
        pmo->SetPropManager((Properties *) this);

        if (m_bKillSignature) {
            delete pmo;
            delete pmi;
            m_sigspmo = NULL;
            break;
        }

        error = kError_NoErr;
        lmc = (LogicalMediaConverter *) lmc_item->InitFunction()(m_context);
        lmc->SetPropManager((Properties *) this);

        lmc->SetPMI(pmi);
        lmc->SetPMO(pmo);

        pmo->SetPMI(pmi);
        pmo->SetLMC(lmc);

        DecodeInfo decInfo;
        decInfo.sendInfo = false;

        lmc->SetDecodeInfo(decInfo);
        lmc->SetEQData(false);

        error = pmo->SetTo(url.c_str());
        if (error == kError_FileNotFound) {
            delete pmo;
            delete lmc;
            delete pmi;
            m_sigspmo = NULL;
			items->erase(url);
            continue;
        }

        if (IsError(error))
        {
            char szErr[1024];

            sprintf(szErr, "Cannot setup the audio decode process: %d\n", 
                    error);
            m_context->log->Error(szErr);
            delete pmo;
            delete lmc;
            delete pmi;
            m_sigspmo = NULL;
            continue;
        }

        string browserInfo = "Generating signature for " + url;
        AcceptEvent(new BrowserMessageEvent(browserInfo));

        m_sigspmo = pmo;

        pmo->Resume();