cnfdemoprm.h

Conferencing code using Dialogic hardware

      CommonParams(){
		  m_call_control_mode = MEDIA_OPERATIONAL_MODE_1PCC;
		  m_reserve_resource_type = RESERVE_RESOURCE_NONE;	   // HMP mode
	      m_maxlogsize    = 10000;     // lines
          m_log_level     = LOG_APP;   // Application, Warning and Error messages
          m_log_file      = 0;
          str_storestring(&m_log_file, DFLT_LOG_FILE_NAME);

          m_welcome_file  = 0;
          str_storestring(&m_welcome_file,DFLT_WELLCOME_FILE_NAME);

          m_bad_passcode_file  = 0;
          str_storestring(&m_bad_passcode_file,DFLT_BAD_PASSCODE_FILE_NAME);

          m_callater_file  = 0;
          str_storestring(&m_callater_file,DFLT_CALL_LATER_FILE_NAME);

          m_goodbye_file  = 0;
          str_storestring(&m_goodbye_file,DFLT_GOODBYE_FILE_NAME);

      };

      // Destructor
      virtual ~CommonParams(){
	      str_deletestoredstring(&m_goodbye_file); 
	      str_deletestoredstring(&m_callater_file); 
	      str_deletestoredstring(&m_bad_passcode_file); 
	      str_deletestoredstring(&m_welcome_file); 
	      str_deletestoredstring(&m_log_file); 
      };
      
      // Dump internal variavles
      void Dump(CGenLog *pLog){
           const char *name;
           static const char *obj_name = "CommonParams";
           name = get_call_control_mode_name(m_call_control_mode);
           pLog->Log(LOG_API, obj_name, 
                      "         m_call_control_mode     = %d %s",  m_call_control_mode, name );

           pLog->Log(LOG_API, obj_name, 
                      "         m_reserve_resource_type = %d %s", m_reserve_resource_type, get_reserve_resource_name(m_reserve_resource_type) );

           pLog->Log(LOG_API, obj_name, 
                      "         m_maxlogsize   = %d",  m_maxlogsize );


           name = log_get_msgtype_name(m_log_level);
           pLog->Log(LOG_API, obj_name, 
                      "         m_log_level         = %d %s", m_log_level, name);

           pLog->Log(LOG_API, obj_name, 
                      "         m_log_file          = %s",    m_log_file);

           pLog->Log(LOG_API, obj_name, 
                      "         m_welcome_file      = %s", m_welcome_file);

           pLog->Log(LOG_API, obj_name, 
                      "         m_bad_passcode_file = %s", m_bad_passcode_file);


           pLog->Log(LOG_API, obj_name, 
                      "         m_callater_file     = %s", m_callater_file);

           pLog->Log(LOG_API, obj_name, 
                      "         m_goodbye_file      = %s", m_goodbye_file);

        return;                 
      };
      
      inline bool  Is3PCCMode(){
		 return MEDIA_OPERATIONAL_MODE_3PCC == m_call_control_mode;
	  }

	  inline RESERVE_RESOURCE_TYPE GetReserveResourceType() {
		  return m_reserve_resource_type;
	  }


	  enumIPCCLIBMediaMode m_call_control_mode;	// MEDIA_OPERATIONAL_MODE_1PCC or 3PCC
	  RESERVE_RESOURCE_TYPE m_reserve_resource_type;
	  
	  unsigned int m_maxlogsize;    // lines
      MSG_TYPE m_log_level;         // verbosity level
      char *   m_log_file;          // log file name
      char *   m_welcome_file;      // wecome message
      char *   m_bad_passcode_file; // bad pass code message
      char *   m_callater_file;     // call later message
      char *   m_goodbye_file;      // goodbye 

}; // class CommonParams



//
//  DTI parameters
//
typedef class DtiParams * PDtiParams;
class DtiParams {
  public:
      //--------
      DtiParams(){
	      m_number_of_channels = 0;     // lines
          m_accept_call   = false;      // do accept calls?
          m_private_log   = LOG_NONE;   // No private log
      };

      // Destructor
      virtual ~DtiParams(){
      };
      
      // Dump internal variavles
      void Dump(CGenLog *pLog){
           const char *name;
           static const char *obj_name = "DtiParams";
           pLog->Log(LOG_API, obj_name, 
                      "         m_number_of_channels = %d",  m_number_of_channels );

           pLog->Log(LOG_API, obj_name, 
                      "         m_accept_call        = %s",  YESNO(m_accept_call));

           name = log_get_msgtype_name(m_private_log);
           pLog->Log(LOG_API, obj_name, 
                      "         m_log_level          = %d %s", m_private_log, name);
        return;                 
      };
      
	  unsigned int m_number_of_channels;
      bool m_accept_call;
      MSG_TYPE m_private_log;         // verbosity level
}; // class DtiParams

//
//  BRD (cnfB1) parameters
//
typedef class BrdParams * PBrdParams;
class BrdParams {
  public:
      //--------
      BrdParams(){
          m_log_level         = LOG_APP;    // Application, Warning and Error messages
	      m_brd_active_talker = false;     
          m_brd_at_interval   = 10;
          m_brd_dtmf_clamping = false;
      };

      // Destructor
      virtual ~BrdParams(){
      };
      
      // Dump internal variavles
      void Dump(CGenLog *pLog){
           const char *name;
           static const char *obj_name = "CBrdParams";
           name = log_get_msgtype_name(m_log_level);
           pLog->Log(LOG_API, obj_name, 
                      "         m_log_level          = %d %s", m_log_level, name);

           pLog->Log(LOG_API, obj_name, 
                      "         m_brd_active_talker  = %d %s",
                      m_brd_active_talker, YESNO(m_brd_active_talker));
           
           pLog->Log(LOG_API, obj_name, 
                      "         m_brd_at_interval    = %d ",
                      m_brd_at_interval);

           pLog->Log(LOG_API, obj_name, 
                      "         m_brd_dtmf_clamping  = %d %s",
                      m_brd_dtmf_clamping, YESNO(m_brd_dtmf_clamping));

        return;                 
      };
       
      MSG_TYPE m_log_level;
      bool m_brd_active_talker;
      int m_brd_at_interval;
      bool m_brd_dtmf_clamping;
}; // class BrdParams



//
// Specific Configuration file reader 
// Based on CnfParams class and customized for cnf_demo configuration file
// 
typedef class CnfDemoPrm * PCnfDemoPrm;

class CnfDemoPrm : public ConfigFile  {
public:
	CnfDemoPrm(CGenLog *pLog);
	virtual ~CnfDemoPrm();


    // Load configuration file and scan & read parameters 
    bool ReadConfigFile(const char *filename);

//    Adjust parameters if (all available) is specified
    bool  AdjustNumberOfDevices(size_t dx_devices,
                                size_t ipt_devices,
                                size_t dti_devices);
public:
    size_t GetRequestedNumberOfDxDevices(){
        size_t total = GetRequestedNumberOfDtiDevices() +
                       GetRequestedNumberOfIptDevices() +
                       m_ConferenceContainer.GetNumberOfDxDevices();
        
           return total;
    }

	inline enumIPCCLIBMediaMode GetPCCMode(){
		   return m_CommonParams.m_call_control_mode;
	}
    inline bool  Is3PCCMode(){
		return m_CommonParams.Is3PCCMode();
	}

    inline RESERVE_RESOURCE_TYPE GetReserveResourceType() {
		  return m_CommonParams.GetReserveResourceType();
	}


    // Global parameters
        // -------------------------
        // section [Common]
private:
       CommonParams m_CommonParams;
public:
       PCommonParams GetCommonPrm (){
           return &m_CommonParams;
       }

       // --------------------------
       // section [Board Parameters] 
private:
       BrdParams m_BrdParams;
public:
       PBrdParams GetBrdPrm(){
           return &m_BrdParams;
       };

        // --------------------------
        // section [Dti] 
private:
       DtiParams m_DtiParams;
public:
       PDtiParams GetDtiPrm (){
           return &m_DtiParams;
       };

       unsigned int GetRequestedNumberOfDtiDevices(){
           if ( MAXUINT == m_DtiParams.m_number_of_channels ){
                return 0;
           }
           return m_DtiParams.m_number_of_channels;
       };

private:
    // -------------------------
    // Sections [conference xxx]
       bool StoreConference();

       CnfPrmContainer m_ConferenceContainer; 

       CnfParams m_cnf_params;  // Scratch, Currently processed values

public:
       PCnfPrmContainer GetConferencePrmContainer(){
            return &m_ConferenceContainer;    
       };

       size_t GetRequestedNumberOfConferences(){
            return m_ConferenceContainer.GetNumberOfConferences();
       }
private:
    // -------------------------
    // Sections [Ipt]
     bool StoreIpt();
     list<PIptParams> m_IptContainer;
     CIptParams m_ipt_params;  // Scratch, Currently processed values

     // How many ipt blocks are defined
     int GetNumberOfIptParams(){
         return m_IptContainer.size();
     }

public:
     // retrieve ipt block by sequential index
     bool GetIptPrm (unsigned int inx, PIptParams *ppIptParams){
         if (inx < m_IptContainer.size() ){
             list<PIptParams>::iterator pos = m_IptContainer.begin();
             unsigned int tmp = 0;
             while(tmp++ < inx){
                   ++pos;
             }
             *ppIptParams = *pos;
             return true;
         }
         return false;
     }

     unsigned int GetRequestedNumberOfIptDevices(const char *protocol = 0) {
         unsigned int total = 0;
         list<PIptParams>::iterator pos = m_IptContainer.begin();
         while(pos != m_IptContainer.end()){
             PIptParams pPrm = *pos;
             if (    ( protocol == 0)
                  || ( COMPARE_EQUAL == str_compare(protocol, pPrm->ip_protocol) ) 
                ){
                if (pPrm->m_number_of_channels!= MAXUINT){
                    total += pPrm->m_number_of_channels;
                }
             }
             ++pos;
         } 
         return total;
     }


///////////////////////////////////////////////
    // dump (LOG) all parameters
public:
    void Dump();

private:

    // Log errors when reading file
        // Log invalid value message
        void LogInvalidValue(const char *token, const char *value);
        // This token exist, but there is no case to handle (app error)
        void LogUnmatchedParameter(const char *token, int line);
        // This token exist, but there is no case to handle (app error)
        void LogUndefinedParameter(const char *token);

    // Read section [Common]
    bool ReadCommonValues(const char * token);
    // Read section [Board Parameters]
    bool ReadBoardValues(const char * token);
    // Read section [dti]
    bool ReadDtiValues(const char * token);
    // Read section [ipt]
    bool ReadIptValues(const char * token);

    // Read Conference
    bool ReadConference(const char * token);


}; // class CnfDemoPrm

#endif // !defined(AFX_CNFDEMOPRM_H__E5E3A839_DBD7_4192_A383_AE92E822028B__INCLUDED_)