/home/fwph/code/wurde/rde/core/capabilities/PlaybackControl.cpp

Go to the documentation of this file.

#include <PlaybackControl.H>
#include <CommsManager.H>
#include <Logger.H>

// $Id: Type.cpp 68 2007-02-01 17:56:57Z fwph $

using namespace WURDE;

PlaybackControl::PlaybackControl(const std::string & streamname){
       init(streamname,STRAT_NORMAL,"Any");

       //global name will be set later
       m_haveGlobalname=false;
}

PlaybackControl::PlaybackControl(const ConnectionStrategy & strategy,const std::string & gblName){
       init("Any",strategy,gblName);

       if(strategy==STRAT_NORMAL){
              //then the global name really specifies the streamname,
              // and the global name should be assigned automagically once we have
              // confirmation that the stream has been started
              m_haveGlobalname=false;   
       }

       m_haveStream=false;
       
}

PlaybackControl::PlaybackControl(const std::string &streamname,const std::string &gblName){
       init(streamname,STRAT_NORMAL,gblName);
}

void PlaybackControl::init(const std::string &streamname,const ConnectionStrategy &strategy,const std::string &gblName){
  m_globalname=gblName;
  m_streamname=streamname;

  myCOMObject=NULL;
  
  //  data.source=streamname.c_str();
  requests=info;

  m_queue=false;
  m_supplier=false;
  m_doTimestamp=true;
  m_doTag=true;

  m_doPublishData=false;
  m_doPublishInfo=false;

  m_initialize=false;
  m_strategy=strategy;

  m_haveStream=true;
  m_haveGlobalname=true;
  m_doPublishData=false;
  m_doPublishInfo=false;

  m_doAutoPing=true;

  info.source=streamname;
  requests.source=m_globalname;
  info.target="Any";
  requests.target=streamname;
  info.timestamp.now();
  requests.timestamp.now();

  m_streamRequest=STAT_NULL;
  
  m_sourceModule="Unknown";
}


PlaybackControl::~PlaybackControl(){
  myManager=NULL;
  if(myCOMObject){

         //      delete myCOMObject;
  }
}


void PlaybackControl::activateSupplier(){
       if(m_haveStream){
              m_supplier=true;
              m_globalname=m_streamname;
              m_haveGlobalname=true;
              m_initialize=false;
              if(myCOMObject){
                      //                     myCOMObject=new CMUIPCRobotProtocol::CMUIPCPlaybackControl(m_globalname);
                     myCOMObject->setGlobalName(m_globalname);
                     myCOMObject->setStreamName(m_streamname);
                     myCOMObject->setInfo(&requests);
                     myCOMObject->setRequests(&info);
                     myCOMObject->setStaging(&data);
                     myCOMObject->activateSupplier();
                     myCOMObject->setAutoPing(m_doAutoPing);
                     myCOMObject->setInfoVector(&m_requestVector);
                     myCOMObject->setRequestVector(&m_infoVector);
                     myCOMObject->setDataVector(&m_dataVector);

                     data.source=m_streamname;
                     info.source=m_streamname;

                     if(m_queue){
                            myCOMObject->setQueueMode(true);
                     }

              }else{
                      g_fatal("Attempted to activateSupplier before setting a COMObject Please just use registerSupplier.");
                      exit(-1);
              }
        if(m_supplier){
                info.playbackControl.setCMode(C_SUPPLIER);
        }else{
                info.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                info.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.duration.setCMode(C_SUPPLIER);
        }else{
                info.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.zeroTime.setCMode(C_SUPPLIER);
        }else{
                info.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.loop.setCMode(C_SUPPLIER);
        }else{
                info.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                info.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.multiplier.setCMode(C_SUPPLIER);
        }else{
                info.multiplier.setCMode(C_CONSUMER);
        }
       }else{
              //this shouldn't happen, but there's no real problem with it.
              //it'd just be dumb.
              m_initialize=true;
              m_supplier=true;
       }
       
       requests=info;

}

void PlaybackControl::activateConsumer(){
       std::string localname;
       
       if(m_haveStream){
              m_initialize=false;
              m_supplier=false;
              if(myCOMObject&&myManager){
                      /* global name so we don't have conflicts with the naming service */
                      if(!m_haveGlobalname&&m_strategy==STRAT_NORMAL){
                              m_globalname=myManager->getName()+PLAYBACKCONTROL+m_streamname+"Consumer";
                              m_haveGlobalname=true;
                      }

                     myCOMObject->setGlobalName(m_globalname);
                     myCOMObject->setStreamName(m_streamname);
                     requests.source=m_globalname;
                     data.source=m_streamname;
                     info.source=m_streamname;
                     myCOMObject->setInfo(&info);
                     myCOMObject->setRequests(&requests);
                     myCOMObject->setStaging(&data);
                     myCOMObject->setAutoPing(m_doAutoPing);
                     myCOMObject->activateConsumer();
                     myCOMObject->setInfoVector(&m_infoVector);
                     myCOMObject->setRequestVector(&m_requestVector);
                     myCOMObject->setDataVector(&m_dataVector);

                     if(m_queue){
                            myCOMObject->setQueueMode(true);
                     }
              }else{
                      g_fatal("Attempted to activateConsumer before setting a COMObject and CommsManager. Please use registerConsumer instead.");
                     exit(-1);
              }

        if(m_supplier){
                info.playbackControl.setCMode(C_SUPPLIER);
        }else{
                info.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                info.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.duration.setCMode(C_SUPPLIER);
        }else{
                info.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.zeroTime.setCMode(C_SUPPLIER);
        }else{
                info.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.loop.setCMode(C_SUPPLIER);
        }else{
                info.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                info.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.multiplier.setCMode(C_SUPPLIER);
        }else{
                info.multiplier.setCMode(C_CONSUMER);
        }
       }else{
              //no stream, so we can't connect yet. tell the system 
              //to initialize as soon as we've got one
              m_initialize=true;
       }

}

void PlaybackControl::runUpdate(){
       if(myCOMObject){

              myCOMObject->runUpdate(m_doPublishData,m_doPublishInfo);
              
              m_doPublishData=false;
              m_doPublishInfo=false;
              
       }
}

void PlaybackControl::setManager(CommsManager *myManager_){

  if(!myCOMObject){
    myManager=myManager_;
  }

}

void PlaybackControl::setQueueMode(const bool & val){

       if(!myCOMObject){
              m_queue=val;
       }else if(!m_queue&&val){
              m_queue=val;
              myCOMObject->setDataVector(&m_dataVector);
              myCOMObject->setQueueMode(true);

       }else if(!val&&m_queue){
              m_queue=val;
              myCOMObject->setQueueMode(false);
              while(!m_dataVector.empty()){
                     m_dataVector.pop();
              }
              while(!m_infoVector.empty()){
                     m_infoVector.pop();
              }
              while(!m_requestVector.empty()){
                     m_requestVector.pop();
              }
       }
}

bool PlaybackControl::newData(){
       if(m_queue){
              return !m_dataVector.empty();
       }else{
              if(myCOMObject){
                     return myCOMObject->newData();
              }
       }

       return false;
}

bool PlaybackControl::newInfo(){
       if(m_queue){
              if(m_supplier){
                     return !m_requestVector.empty();
              }

              return !m_infoVector.empty();
       }else{
              if(myCOMObject){
                     return myCOMObject->newInfo();
              }
       }


       return false;
}

void PlaybackControl::publishData(){
       if(m_supplier){
              if(m_doTimestamp){
                     data.timestamp.now();
              }
              if(m_doTag){
                     data.source=m_globalname;
              }
              if(m_queue){
                     PlaybackControlDataStruct temp;
                     temp.source=data.source;
temp.timestamp=data.timestamp;
 
                     m_dataVector.push(temp);
                              //                     m_dataVector.push(data);
              }
              m_doPublishData=true;
       }
}

void PlaybackControl::publishInfo(){
       if(m_supplier){

              info.mType=MESSAGE_INFO;
              if(m_doTimestamp){
                     info.timestamp.now();
              }

              if(m_doTag){
                     info.source=m_globalname;
                     info.target="Any";
              }

              if(m_queue){
                     PlaybackControlInfoStruct temp;
                     
                    
                     temp.source=info.source;
temp.playbackControl=info.playbackControl;
temp.fakeTimeOffset=info.fakeTimeOffset;
temp.duration=info.duration;
temp.zeroTime=info.zeroTime;
temp.loop=info.loop;
temp.mType=info.mType;
temp.target=info.target;
temp.timestamp=info.timestamp;
temp.localFakeTime=info.localFakeTime;
temp.multiplier=info.multiplier;

                     m_infoVector.push(temp);
                    
                     //              m_infoVector.push(info);
              }

              m_doPublishInfo=true;
       }else{

              requests.mType=MESSAGE_REQUEST;
              
              if(m_doTimestamp){
                     requests.timestamp.now();
              }

              if(m_doTag){
                     requests.source=m_globalname;
                     requests.target=m_streamname;
              }

              if(m_queue){
                     PlaybackControlInfoStruct temp;
        if(m_supplier){
                temp.playbackControl.setCMode(C_SUPPLIER);
        }else{
                temp.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                temp.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.duration.setCMode(C_SUPPLIER);
        }else{
                temp.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.zeroTime.setCMode(C_SUPPLIER);
        }else{
                temp.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.loop.setCMode(C_SUPPLIER);
        }else{
                temp.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                temp.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.multiplier.setCMode(C_SUPPLIER);
        }else{
                temp.multiplier.setCMode(C_CONSUMER);
        }
                     temp.source=requests.source;
temp.playbackControl=requests.playbackControl;
temp.fakeTimeOffset=requests.fakeTimeOffset;
temp.duration=requests.duration;
temp.zeroTime=requests.zeroTime;
temp.loop=requests.loop;
temp.mType=requests.mType;
temp.target=requests.target;
temp.timestamp=requests.timestamp;
temp.localFakeTime=requests.localFakeTime;
temp.multiplier=requests.multiplier;

                     m_requestVector.push(temp);

                     //              m_requestVector.push(requests);
              }

              m_doPublishInfo=true;
       }
}

PlaybackControlDataStruct PlaybackControl::getNextData(){
       if(m_queue){
              PlaybackControlDataStruct retval;
              retval.source="NULL";
              if(m_dataVector.empty()){
                     return data;
              }
             
              retval.source=m_dataVector.front().source;
retval.timestamp=m_dataVector.front().timestamp;

                       //             retval=m_dataVector.front();
              m_dataVector.pop();
              data=retval;
       
              return retval;
       }else{
              myCOMObject->resetData();
              return data;
       }
}

PlaybackControlInfoStruct PlaybackControl::getNextInfo(){
       if(m_queue){
              PlaybackControlInfoStruct retval;
        if(m_supplier){
                retval.playbackControl.setCMode(C_SUPPLIER);
        }else{
                retval.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                retval.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.duration.setCMode(C_SUPPLIER);
        }else{
                retval.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.zeroTime.setCMode(C_SUPPLIER);
        }else{
                retval.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.loop.setCMode(C_SUPPLIER);
        }else{
                retval.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                retval.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.multiplier.setCMode(C_SUPPLIER);
        }else{
                retval.multiplier.setCMode(C_CONSUMER);
        }
              retval.source="NULL";
              if(m_supplier){
                     if(m_requestVector.empty()){
                            return requests;
                     }
                     retval.source=m_requestVector.front().source;
retval.playbackControl=m_requestVector.front().playbackControl;
retval.fakeTimeOffset=m_requestVector.front().fakeTimeOffset;
retval.duration=m_requestVector.front().duration;
retval.zeroTime=m_requestVector.front().zeroTime;
retval.loop=m_requestVector.front().loop;
retval.mType=m_requestVector.front().mType;
retval.target=m_requestVector.front().target;
retval.timestamp=m_requestVector.front().timestamp;
retval.localFakeTime=m_requestVector.front().localFakeTime;
retval.multiplier=m_requestVector.front().multiplier;

                              //                     retval=m_requestVector.front();
        if(m_supplier){
                retval.playbackControl.setCMode(C_SUPPLIER);
        }else{
                retval.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                retval.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.duration.setCMode(C_SUPPLIER);
        }else{
                retval.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.zeroTime.setCMode(C_SUPPLIER);
        }else{
                retval.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.loop.setCMode(C_SUPPLIER);
        }else{
                retval.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                retval.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.multiplier.setCMode(C_SUPPLIER);
        }else{
                retval.multiplier.setCMode(C_CONSUMER);
        }
                     m_requestVector.pop();
                     requests=retval;
                     return retval;
              }else{
                     if(m_infoVector.empty()){
                            return info;
                     }
                     retval.source=m_infoVector.front().source;
retval.playbackControl=m_infoVector.front().playbackControl;
retval.fakeTimeOffset=m_infoVector.front().fakeTimeOffset;
retval.duration=m_infoVector.front().duration;
retval.zeroTime=m_infoVector.front().zeroTime;
retval.loop=m_infoVector.front().loop;
retval.mType=m_infoVector.front().mType;
retval.target=m_infoVector.front().target;
retval.timestamp=m_infoVector.front().timestamp;
retval.localFakeTime=m_infoVector.front().localFakeTime;
retval.multiplier=m_infoVector.front().multiplier;

        if(m_supplier){
                retval.playbackControl.setCMode(C_SUPPLIER);
        }else{
                retval.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                retval.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.duration.setCMode(C_SUPPLIER);
        }else{
                retval.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.zeroTime.setCMode(C_SUPPLIER);
        }else{
                retval.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.loop.setCMode(C_SUPPLIER);
        }else{
                retval.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                retval.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.multiplier.setCMode(C_SUPPLIER);
        }else{
                retval.multiplier.setCMode(C_CONSUMER);
        }
                     m_infoVector.pop();
                     info=retval;
                     // the requests struct really should get the values in 
                     // info
                     requests=info;
                     
                     return retval;
              }
       }else{
              myCOMObject->resetInfo();
              if(m_supplier){
        if(m_supplier){
                requests.playbackControl.setCMode(C_SUPPLIER);
        }else{
                requests.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                requests.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.duration.setCMode(C_SUPPLIER);
        }else{
                requests.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.zeroTime.setCMode(C_SUPPLIER);
        }else{
                requests.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.loop.setCMode(C_SUPPLIER);
        }else{
                requests.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                requests.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.multiplier.setCMode(C_SUPPLIER);
        }else{
                requests.multiplier.setCMode(C_CONSUMER);
        }
                     return requests;
              }else{
        if(m_supplier){
                info.playbackControl.setCMode(C_SUPPLIER);
        }else{
                info.playbackControl.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.fakeTimeOffset.setCMode(C_SUPPLIER);
        }else{
                info.fakeTimeOffset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.duration.setCMode(C_SUPPLIER);
        }else{
                info.duration.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.zeroTime.setCMode(C_SUPPLIER);
        }else{
                info.zeroTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.loop.setCMode(C_SUPPLIER);
        }else{
                info.loop.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.localFakeTime.setCMode(C_SUPPLIER);
        }else{
                info.localFakeTime.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.multiplier.setCMode(C_SUPPLIER);
        }else{
                info.multiplier.setCMode(C_CONSUMER);
        }
                     // the requests struct really should get the values in 
                     // info
                     requests=info;
                     return info;
              }
       }
}

void PlaybackControl::setStreamName(const std::string & name){

       if(m_supplier&&name=="Any"){
              return;
       }

       m_streamname=name;
       m_haveStream=true;

       if(m_supplier){
              m_globalname=name;
       }
       
       if(myCOMObject){
              myCOMObject->setStreamName(name);
       }

       if(m_initialize){
              if(m_supplier){
                     activateSupplier();
              }else{
                     activateConsumer();
              }
       }

       m_streamRequest=STAT_OKAY;
}

void PlaybackControl::setGlobalName(const std::string & name){
       
       if(name=="Any"){
              return;
       }

       m_globalname=name;
       m_haveGlobalname=true;
       if(m_supplier){
              m_streamname=name;
       }

       if(myCOMObject){
              myCOMObject->setGlobalName(name);
       }
}

void PlaybackControl::doPing(){
       if(myCOMObject){
              myCOMObject->doPing();
       }
}

void PlaybackControl::setAutoPing(const bool & val){
       m_doAutoPing=val; 
       if(myCOMObject){
              myCOMObject->setAutoPing(val);
       }
}

---