srlthread.cpp

Conferencing code using Dialogic hardware

// Returns:	
//    bool (true = success, evt_name set properly in this case )
//*****************************************************************************
bool evt_getname(int event, const char **evt_name){
   if ( !str_findname(event, evt_name, nongc_events) ){
         *evt_name = GCEV_MSG(event); 
   }
   return true;
} // End of evt_getname()


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//*****************************************************************************
// Purpose	: 
//    Constructor
// Parameters:	
//    [in] Configuration parameters ( from configuration file )
// Returns:	
//    none
//*****************************************************************************
CSrlThread::CSrlThread(PCommonParams pCommonParams) 
          : CSrlDeviceContainer(DEV_NONE, pCommonParams, 0){
 m_srl_tmo = 0;
 m_onidle_counter = 0;
 // Exiting
 flag_exit_request = false;

 SetName("SrlThread");
} // End of Constructor()

//*****************************************************************************
// Purpose	: 
//    Destructor
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
CSrlThread::~CSrlThread(){
  
  WaitSrlState(10000, SRLSTATE_OPENED, false ,0 );
  GLBLOG(LOG_DBG, CNF_MODULE_NAME, "Object deleted");
} // End of Destructor()

//*****************************************************************************
// Purpose	: 
//    Init srl thread - specify SRL model and timeout
//    Note: different threads may have different timeouts, but
//          will share same model - latest sr_setparm takes precedence
// Parameters:	
//    [in] timeout in ms 
//    [in] srl model
// Returns:	
//    true = success
//    false = failure
//*****************************************************************************
bool CSrlThread::InitMode(int srl_tmo,  // timeout in milliseconds
                          int mode){    // mode ( see user manual )
int ret_code;
// 
  m_srl_tmo=srl_tmo;
  switch (mode)  {
        default:
             GLBLOG( LOG_ERR1, CNF_MODULE_NAME,
                     "Requested mode (%d) is not supported in this demo. Use SR_STASYNC(Win32) / SR_POLLED(Linux)", mode);
             ret_code = AT_FAILURE;
             break;

        case SRL_POLLED_MODE:
             // single thread polled mode
             // (asynchronous polled)
            # ifdef WIN32
            //Windows
                int srlmodeltype = SR_STASYNC;      // single thread asyncronous
                ret_code = sr_setparm(SRL_DEVICE, SR_MODELTYPE, &srlmodeltype),
                GLBLOG(LOG_API, CNF_MODULE_NAME,
                       "%d = sr_setparm(SRL_DEVICE, SR_MODELTYPE, SR_STASYNC)", ret_code);
            # else  
            // Linux
                int srlmodeltype = SR_POLLMODE;     // Polled mode
                ret_code = sr_setparm(SRL_DEVICE, SR_MODEID, &srlmodeltype),
                GLBLOG(LOG_API, CNF_MODULE_NAME,
                       "%d = sr_setparm(SRL_DEVICE, SR_MODEID, SR_POLLMODE)", ret_code);
            # endif
                break;
  } // switch 

 return ret_code != AT_FAILURE;
} // End of InitMode()

//*****************************************************************************
// Purpose	: 
//    Receive and handle events
// Parameters:	
//    none
// Returns:	
//    none. 
//*****************************************************************************
void CSrlThread::TheThreadBody(){
int rc = 1;
int evhandle = 0;
// in WIN32 MT environment, change 0 to evhanke

  while (rc > 0) {
      // consume all available events
       rc = sr_waitevt(m_srl_tmo) ;
       if(  rc >= 0 ) {
	        EventHandler(evhandle);
            m_onidle_counter = 0;    // reset counter
       }  
  }
  OnIdle();  

 return ;
} // End of TheThreadBody()

//*****************************************************************************
// Purpose	: 
//    Handle events
// Parameters:	
//    [in] evhandle - only used in WIN32 Multithreaded models 
// Return:	
//    none
//*****************************************************************************
void CSrlThread::EventHandler(int evhandle){

  // --- Find name and log
#  ifdef WIN32
     void * evtusercontext = sr_getUserContext(evhandle);
     int evttype = sr_getevttype(evhandle);
     int srl_handle = sr_getevtdev(evhandle);
     void *evtdata = sr_getevtdatap(evhandle);
     int evtlen = sr_getevtlen(evhandle);
#  else 
  // --- LINUX
     void * evtusercontext = sr_getUserContext();
     int evttype = sr_getevttype();
     int srl_handle = sr_getevtdev();
     void *evtdata = sr_getevtdatap();
     int evtlen = sr_getevtlen();
#  endif

METAEVENT metaevent;
const char *event_name;
PSrlDevice pDevice = 0;
bool is_globalcall = false;
   gc_GetMetaEvent(&metaevent);

   if (metaevent.flags & GCME_GC_EVENT) {
       // GlobalCall event
       event_name = GCEV_MSG(evttype); 
       is_globalcall = true; 
   }else {
       str_findname(evttype, &event_name, nongc_events) ;
   }
   
   //
   // Search node:
   //
   if ( 0 != evtusercontext ) {
       // User context is device object un case of CNF events
        pDevice = static_cast<PSrlDevice>(evtusercontext);
   }else {
        if (is_globalcall) {
            // user attribute is device object in case of GlobalCall
            pDevice = static_cast<PSrlDevice>(metaevent.usrattr);
        }
   }

   if (0 == pDevice ) {
       if (!AreYouHandle(srl_handle, &pDevice) ){
           LOG( LOG_WARNING, CNF_MODULE_NAME,
                "Missing device, srl_handle = 0x%x(%d), event = 0x%x %s",
                srl_handle, srl_handle, evttype, event_name);
                return;
       }
   } // 0 == pDevice


   const char *dev_name =  CNF_MODULE_NAME;
   if (pDevice){
       dev_name = pDevice->GetName();
   }

   CGenLog *pLog;
   if (pDevice){
       pLog = pDevice->GetLog();
   }else {
       pLog = GLBLOGOBJ;
   }

   const char *txt;

   if ( evt_isnotification(evttype) ) {
        txt = "[info]";
   }else if(    (evttype >= EVENT_USER)
             && (evttype <= USREV_LAST) )  {
        txt = "[app ]";
   }else {
        txt = "[term]";
   }

   const char *event_data = "";
   switch(evttype){
       case TDX_CST:
           { DX_CST *cst = (DX_CST*)evtdata;
             switch(cst->cst_event){
                case DE_SILON:   event_data = "DE_SILON"; break;
                case DE_SILOF:   event_data = "DE_SILOF"; break;
                case DE_DIGITS:  event_data = "DE_DIGITS"; break;
                case DE_DIGOFF:  event_data = "DE_DIGOFF"; break;
                case DE_TONEON:  event_data = "DE_TONEON"; break;
                case DE_TONEOFF: event_data = "DE_TONEOFF"; break;
                case DE_VAD:     event_data = "DE_VAD"; break;
             }
 
           }
            break;
       default: 
            break;
   }

   if (is_globalcall) {
       pLog->Log(RCEVENT(evttype), dev_name,
                 "%s%s %s 0x%x (%d), usrattr = 0x%x hndl = 0x%x", 
                 event_name, txt, event_data, evttype, evttype,  metaevent.usrattr, srl_handle);
   }else {
       pLog->Log(RCEVENT(evttype), dev_name,
                 "%s%s %s 0x%x (%d), context = 0x%x hndl = 0x%x", 
                 event_name, txt, event_data, evttype, evttype,  evtusercontext, srl_handle);
   }

/*
   // test print
   if (pLog->CanOutput(LOG_DBG)) {
       printf("*** Event %s %s %d 0x%x %s\n",
              pDevice->GetName(), event_data, evttype, evttype,  event_name);
      fflush(stdout);
   }
*/

   LOG(LOG_DBG, CNF_MODULE_NAME,
            "Event routed to device: %s", 
             pDevice->GetName());
    
   pDevice->HandleEvent(evttype, evtdata, evtlen, &metaevent);

 return;
} // End of EventHandler()

//*****************************************************************************
// Purpose	: 
//    Do something while the system is idle
//    1. Pass exit request down to all devices
//    2. Calculate timeouts
//    3. Printf dots and
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
void CSrlThread::OnIdle(){

 CheckTmo();

 if ( flag_exit_request ) {
     flag_exit_request = false;
     ExitRequest();
 }
 return;
} // End of OnIdle()

//*****************************************************************************
// Purpose	: 
//    Wait specific time for all devices to reach specified state
// Parameters:	
//    [in] tmo (seconds) - how long to wait
//    [in] state         - state to compare with
//    [in] compare flag: - true means compare for equal, 
//                    false means compare for not equal
//    [out] holder for SrlDevice addr
// Returns:	
//    bool (true = success, compare passed for all devices)
//         (false = operation timed out, compare failed for at least one device
//         *ppDev contains first device that DOES NOT match criteria)
//*****************************************************************************
bool CSrlThread::WaitSrlState(int tmo,
                              int srl_state,
                              bool compare_flag,
                              PSrlDevice *ppDev){
    struct timeb bgn;
    struct timeb now;
    struct timeb diff;

    ftime(&bgn);
    ftime(&now);
    timeb_diff(&diff, &bgn, &now);

    while( time_isgreater(tmo, &diff) ){
        if (AreSrlStates(srl_state, compare_flag, ppDev) ){
            return true;
        }
        // Give everybody a chance to Advance state
        TheThreadBody();

        if ( AreSrlStates(srl_state, compare_flag, ppDev) ){
            return true;
        }

        if (AreSrlStates(SRLSTATE_OPENED, false, ppDev) ){
            return false;
        }

        ftime(&now);
        timeb_diff(&diff, &bgn, &now);
    }; // while
        
    return AreSrlStates(srl_state, compare_flag, ppDev);
} // End of WaitSrlState()