manager.cpp

可用该程序将avi的电影文件转化为TS流

}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Manager::HandleRequest(const C_Request& cRequest)
{
  m_cCmdLock.Lock();
  LogDbg(m_hLog, "Manager locked");

  C_Answer cAnswer("Manager");
  
  C_String strCmd = cRequest.GetCmd();

  if(strCmd == "load")
  {
    // Load the input: Not yet implemented 
    ASSERT(false);
  }
  else if(strCmd == "unload")
  {
    // Unload the input: Not yet implemented 
    ASSERT(false);
  }
  else if(strCmd == "browse")
  {
    cAnswer = Browse(cRequest);
  }
  else if(strCmd == "show")
  {
    cAnswer = Show(cRequest);
  }
  else if(strCmd == "start")
  {
    cAnswer = Start(cRequest);
  }
  else if(strCmd == "resume")
  {
    cAnswer = Resume(cRequest);
  }
  else if(strCmd == "suspend")
  {
    cAnswer = Suspend(cRequest);
  }
  else if(strCmd == "stop")
  {
    cAnswer = Stop(cRequest);
  }
  else if(strCmd == "config")
  {
    cAnswer = Config(cRequest);
  }
  else if(strCmd == "program")
  {
    cAnswer = Program(cRequest);
  }
  else if(strCmd == "input")
  {
    cAnswer = Input(cRequest);
  }
  else if(strCmd == "channel")
  {
    cAnswer = Channel(cRequest);
  }
  else
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("Unknown command: "+strCmd);
  }

  m_cCmdLock.UnLock();
  LogDbg(m_hLog, "Manager unlocked");

  return cAnswer;
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::HandleEvent(const C_Event& cEvent)
{
  m_cCmdLock.Lock();
  LogDbg(m_hLog, "Manager locked");

  m_cEventFifoLock.Lock();
  m_cEventFifo.Add(new C_Event(cEvent));
  m_cEventFifoLock.UnLock();

  m_cEventQueued.Post();

  m_pEventHub->ForwardEvent(cEvent);

  m_cCmdLock.UnLock();
  LogDbg(m_hLog, "Manager unlocked");
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::PrivHandleEvent(const C_Event& cEvent)
{
  switch(cEvent.GetCode())
  {
  case EOF_EVENT :
  case CONNEXION_LOST_EVENT :
    C_String strInput = cEvent.GetBroadcast()->GetInput()->GetName();
    C_String strPgrm = cEvent.GetBroadcast()->GetProgram()->GetName();

    ASSERT(strInput != "");
    ASSERT(strPgrm != "");

    C_Request cRequest("stop");
    cRequest.SetArg("input", strInput);
    cRequest.SetArg("program", strPgrm);

    C_Answer cAnswer = HandleRequest(cRequest);

    break;
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::InitWork()
{
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::DoWork()
{
  while(!m_bStop)
  {
    m_cEventQueued.Wait();

    m_cEventFifoLock.Lock();

    if((m_cEventFifo.Size() >= 1) && (!m_bStop))
    {
      C_Event* pEvent = m_cEventFifo.Remove(0);
      ASSERT(pEvent);

      m_cEventFifoLock.UnLock();

      PrivHandleEvent(*pEvent);

      delete pEvent;
    }
    else
    {
      ASSERT(m_bStop);

      m_cEventFifoLock.UnLock();
    }
  }
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::StopWork()
{
   m_bStop = true;
   m_cEventQueued.Post();
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void C_Manager::CleanWork()
{
}


//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Manager::Browse(const C_Request& cRequest)
{
  C_Answer cAnswer("Manager");
  cAnswer.SetStatus(NO_ERR);
  cAnswer.AddMessage("Program Table");

  m_cProgramList.Lock();

  C_PgrmDirectoryBrowser cBrowser = m_cProgramList.CreateBrowser();
  
  while(cBrowser.HasNext())
  {
    C_PgrmInfo* pPgrmInfo = cBrowser.GetNext();
    ASSERT(pPgrmInfo);

    // Build a subanswer with the pgrm description and the list of providers
    const C_Program* pPgrm = pPgrmInfo->GetProgram();
    C_String strPgrmName = pPgrm->GetName();
    ASSERT(strPgrmName != "");
    C_Answer cPgrmDescr(strPgrmName);
    cPgrmDescr.SetStatus(NO_ERR);
    cPgrmDescr.AddMessage(pPgrm->GetDescription());

    const C_Vector<C_Input>& cProviders = pPgrmInfo->GetProviders();
    C_String strProviders = "Provided by";
    for(unsigned int i = 0; i < cProviders.Size(); i++)
    {
      strProviders += " " + cProviders[i].GetName();
    }
    cPgrmDescr.AddMessage(strProviders);

    // Add it to the answer
    cAnswer.Add(cPgrmDescr);
  }

  m_cProgramList.UnLock();

  return cAnswer;
}

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Manager::Show(const C_Request& cRequest)
{
  C_Answer cAnswer("Manager");
  C_String strCommand = cRequest.GetArg("command");
  ASSERT(strCommand != "");

  if (strCommand.ToLower() == "broadcast")
  {
    cAnswer.AddMessage("Showing running broadcasts.");
    // Lock Broadcast repository
    m_cBroadcasts.Lock();

    C_RepositoryBrowser<C_String, C_Broadcast> cIterator1 =
                  m_cBroadcasts.CreateBrowser();

    while(cIterator1.HasNextItem())
    {
      C_Broadcast* pBroadcast = cIterator1.GetNextItem();
      C_Answer cBroadcast(pBroadcast->GetChannel()->GetName());
      cBroadcast.SetStatus(NO_ERR);
      cBroadcast.AddMessage("Channel '"+pBroadcast->GetChannel()->GetName()+"'");
      cBroadcast.AddMessage("Program '"+pBroadcast->GetProgram()->GetName()+"'");
      cBroadcast.AddMessage("Input '"+pBroadcast->GetInput()->GetName()+"'");
      cBroadcast.AddMessage("Input '"+pBroadcast->GetChannel()->GetName()+"'");
      C_String strOptions = "Options used are '";
      if (pBroadcast->GetOption("rtp")=="1")
         strOptions += "--rtp ";
      if (pBroadcast->GetOption("end")=="1")
         strOptions += "--end ";
      if (pBroadcast->GetOption("loop")=="1")
         strOptions += "--loop ";
      cBroadcast.AddMessage(strOptions+"'");
      cAnswer.Add(cBroadcast);
    }

    // UnLock Broadcast repository
    m_cBroadcasts.UnLock();
    cAnswer.SetStatus(NO_ERR);
  }
  else if (strCommand.ToLower() == "channel")
  {
    cAnswer.AddMessage("Showing available channels.");

    // Lock the channel repository
    m_cChannelList.Lock();

    // Get the names of all the channels
    C_Application* pApp = C_Application::GetApp();
    ASSERT(pApp);
    C_Vector<C_Setting> vChannels = pApp->GetSettings("Channels");

    // Create the corresponding channels
    for(unsigned int i = 0; i < vChannels.Size(); i++)
    {
      // Get channel name and type
      C_Setting cCurrentChannel = vChannels[i];
      C_String strChannelName = cCurrentChannel.GetName();
      C_String strChannelType = cCurrentChannel.GetValue();

      C_String strKey = strChannelName + C_String(".type");
      C_String strType = pApp->GetSetting(strKey, "");

      // Create answer
      C_Answer cChannelDescr(strChannelName);
      cChannelDescr.SetStatus(NO_ERR);
      cChannelDescr.AddMessage("Channel '"+strChannelName+"' of type '"+strChannelType+"'");
      cChannelDescr.AddMessage("Streamtype '"+strType+"'");
      cAnswer.Add(cChannelDescr);
    }
    cAnswer.SetStatus(NO_ERR);

    // Unlock the channel repository
    m_cChannelList.UnLock();
  }
  else if (strCommand.ToLower() == "program")
  {
    cAnswer.AddMessage("Showing available programs.");
    cAnswer.SetStatus(NO_ERR);

    m_cProgramList.Lock();
    C_PgrmDirectoryBrowser cBrowser = m_cProgramList.CreateBrowser();
    while(cBrowser.HasNext())
    {
      C_PgrmInfo* pPgrmInfo = cBrowser.GetNext();
      ASSERT(pPgrmInfo);

      // Build a subanswer with the pgrm description and the list of providers
      const C_Program* pPgrm = pPgrmInfo->GetProgram();
      C_String strPgrmName = pPgrm->GetName();
      ASSERT(strPgrmName != "");
      C_Answer cPgrmDescr(strPgrmName);
      cPgrmDescr.SetStatus(NO_ERR);
      cPgrmDescr.AddMessage(pPgrm->GetDescription());

      const C_Vector<C_Input>& cProviders = pPgrmInfo->GetProviders();
      C_String strProviders = "Provided by";
      for(unsigned int i = 0; i < cProviders.Size(); i++)
      {
        strProviders += " " + cProviders[i].GetName();
      }
      cPgrmDescr.AddMessage(strProviders);

      // Add it to the answer
      cAnswer.Add(cPgrmDescr);
    }
    m_cProgramList.UnLock();
  }
  else if (strCommand.ToLower() == "input")
  {
    cAnswer.AddMessage("Showing available inputs.");
    cAnswer.SetStatus(NO_ERR);

    // Lock the input repository
    m_cInputList.Lock();
    C_RepositoryBrowser<C_String, C_Input> cIterator =
                                                  m_cInputList.CreateBrowser();
    while(cIterator.HasNextItem())
    {
      C_Input* pInput = cIterator.GetNextItem();
      C_Answer cInputDescr(pInput->GetName());
      cInputDescr.SetStatus(NO_ERR);
      cInputDescr.AddMessage("Input '"+pInput->GetName()+"'");
      cAnswer.Add(cInputDescr);
    }
    // Unlock the input repository
    m_cInputList.UnLock();
  }
  else
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("What to show? Use: broadcast, channel, program or input.");
  }
  return cAnswer;
}

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
C_Answer C_Manager::Start(const C_Request& cRequest)
{
  C_Answer cAnswer("Manager");
  cAnswer.SetStatus(NO_ERR);

  // Find the channel
  C_String strChannel = cRequest.GetArg("channel");
  ASSERT(strChannel != "");
  C_Channel* pChannel = m_cChannelList.Get(strChannel);
  if(!pChannel)
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("Unknown channel");
  }
  else if(!pChannel->IsFree())
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("Channel is busy");
    pChannel = NULL;
  }

  // Find the pgrm
  C_String strPgrm = cRequest.GetArg("program");
  ASSERT(strPgrm != "");
  const C_Program* pPgrm = m_cProgramList.GetPgrm(strPgrm);
  if(!pPgrm)
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("Unknown pgrm");
  }  
   
  // Find the input
  C_String strInput = cRequest.GetArg("input");
  C_Input* pInput = m_cInputList.Get(strInput);
  if(!pInput)
  {
    cAnswer.SetStatus(GEN_ERR);
    cAnswer.AddMessage("input doesn't exist");
  }

  // kludge; D閗ludg