cnfdemoprm.cpp

Conferencing code using Dialogic hardware

    {"RFC2833",   IP_DTMF_TYPE_RFC_2833     },
	{"INBAND",    IP_DTMF_TYPE_INBAND_RTP   },
	{"OUTOFBAND", IP_DTMF_TYPE_ALPHANUMERIC },
    {0,0}
};

const char * ip_digit_type_name(int code) {
  const char *dg_type;
  if (str_findname(code, &dg_type, digit_types)){
     return dg_type;
  } 
  return "unknown";   
}


static NAME_TABLE coder_names[] = {
    {"CODER_TYPE_NONSTANDARD",   CODER_TYPE_NONSTANDARD  },
    {"CODER_TYPE_G711ALAW64K",   CODER_TYPE_G711ALAW64K  },
    {"CODER_TYPE_G711ALAW56K",   CODER_TYPE_G711ALAW56K  },
    {"CODER_TYPE_G711ULAW64K",   CODER_TYPE_G711ULAW64K  },
    {"CODER_TYPE_G711ULAW56K",   CODER_TYPE_G711ULAW56K  },
    {"CODER_TYPE_G721ADPCM",     CODER_TYPE_G721ADPCM    },
    {"CODER_TYPE_G722_48K",      CODER_TYPE_G722_48K     },
    {"CODER_TYPE_G722_56K",      CODER_TYPE_G722_56K     },
    {"CODER_TYPE_G722_64K",      CODER_TYPE_G722_64K     },
	{"CODER_TYPE_G7231_5_3K",    CODER_TYPE_G7231_5_3K   },
	{"CODER_TYPE_G7231_6_3K",    CODER_TYPE_G7231_6_3K   },
    // etc....
    {0,0}
};

const char * ip_coder_name(int code) {
  const char *coder_name;
  if (str_findname(code, &coder_name, coder_names)){
     return coder_name;
  } 
  return "unknown";   
}

//-
static NAME_TABLE vad_names[] = {
    {"CODER_VAD_DISABLE",   CODER_VAD_DISABLE  },
	{"CODER_VAD_ENABLE",    CODER_VAD_ENABLE   },
    {0,0}
};

const char * ip_vad_name(int code) {
  const char *vad_name;
  if (str_findname(code, &vad_name, vad_names)){
     return vad_name;
  } 
  return "unknown";   
}


static NAME_TABLE framesize_names[] = {
    {"CODER_FRAMESIZE_5",  CODER_FRAMESIZE_5     },
	{"CODER_FRAMESIZE_10",  CODER_FRAMESIZE_10   },
	{"CODER_FRAMESIZE_20", CODER_FRAMESIZE_20 },
	{"CODER_FRAMESIZE_30", CODER_FRAMESIZE_30 },
    {0,0}
};

const char * ip_framesize_name(int code) {
  const char *frame_name;
  if ( str_findname(code, &frame_name, framesize_names) ){
       return frame_name;
  } 
  return "unknown";   
}

static NAME_TABLE payload_names[] = {
    {"IP_USE_STANDARD_PAYLOADTYPE",  IP_USE_STANDARD_PAYLOADTYPE     },
    {0,0}
};

const char * ip_payload_name(int code){
  const char *payload_name;
  if ( str_findname(code, &payload_name, payload_names) ){
       return payload_name;
  } 
  return "unknown";   
}

//*****************************************************************************
// Purpose	: 
//    Adjust parameters if (all available) is specified
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::AdjustNumberOfDevices(size_t dx_devices,
                                       size_t ipt_devices,
                                       size_t dti_devices){

  unsigned int ipt_requested = GetRequestedNumberOfIptDevices();
  unsigned int dti_requested = GetRequestedNumberOfDtiDevices();

  // ipt check
  if ( ipt_requested > ipt_devices) {
       LOG( LOG_ERR2, GetFileName(), 
            "Requested: %u ipt devices, available %u",
            ipt_requested, ipt_devices );
       return false;
  }

  // dti check
  if ( dti_requested > dti_devices) {
       LOG( LOG_ERR2, GetFileName(), 
            "Requested: %u dti devices, available %u",
            dti_requested, dti_devices );
       return false;
  }

  if ( ipt_requested + dti_requested > dx_devices) {
       LOG( LOG_ERR2, GetFileName(), 
            "Requested: %u dxx devices, available %u",
            ipt_requested + dti_requested, dx_devices );
       return false;
  }

  // consume 
  dx_devices  -= (ipt_requested + dti_requested);
  ipt_devices -= ipt_requested;
  dti_devices -= dti_requested;

  // adjust dti for (all available request)

  PDtiParams pDtiParams = GetDtiPrm();
  if ( MAXUINT == pDtiParams->m_number_of_channels ){
      size_t max_avl = tmin(dx_devices, dti_devices );
      if ( max_avl == 0 ){
           LOG( LOG_WARNING, GetFileName(), 
                "\"all avalilable ipt devices\" equals to 0");
      }
      pDtiParams->m_number_of_channels = max_avl;
     // consume dx device, we know there are enough
      dx_devices -= max_avl; 
  }

  return true;
}
//*****************************************************************************
// Purpose	: 
//    Read section [ipt] from configuration file
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::ReadIptValues(const char *token){
  typedef enum {
    NUM_IPT_CHANNELS,
    PRIVATE_IPT_LOG,
    IP_ACCEPT_CALL,
    IP_PROTOCOL,
    IP_DIGITS,
    IP_CODER,
    IP_FRAMESIZE,
    IP_VAD,
    IP_PAYLOAD,
  }IPT_KEYWORD_CODES;
  static const char *ipt_keywords[] = {
    "NumberOfChannels",
    "PrivateLog",
    "AcceptCall",
    "IpProtocol",
    "IpDigits",
    "IpCoder",
    "IpFrame",
    "IpVad",
    "PayLoadType"
  };  //End of common_keywords
  static const size_t num_ipt_keywords = sizeof(ipt_keywords) / sizeof(const char *);

  if (m_ipt_params.ipt_id != GetSectionId() ){
       // ipt changed, store current value
       StoreIpt();
  } 
  m_ipt_params.ipt_id = GetSectionId();

  char value[MAXTOKEN];

  // Skip any '='
  *value = '=';
  while( *value == '=') {
         if (!GetNextToken(value, sizeof(value))){
             return false;
         }
  } // while

  bool brc = true;
  size_t inx;
  for ( inx = 0; inx < num_ipt_keywords; inx++ ){
     if (COMPARE_EQUAL == str_compare(ipt_keywords[inx],token ) ) {
         switch(inx){
            case NUM_IPT_CHANNELS:    //   "NumberOfChannels",
                 if (! GetUNumber(value, &m_ipt_params.m_number_of_channels) ){
                     LogInvalidValue(token,value);
                     brc = false;
                 }
                 break;
            
            case PRIVATE_IPT_LOG:    //   "PrivateIptLog",
                 if ( ! str_getunsignednumber(value,(unsigned int *)&m_ipt_params.m_private_log ) ) {
                        m_ipt_params.m_private_log = log_get_msgtype_value(value);
                 }
 
                 if ( m_ipt_params.m_private_log >= MSG_TYPE_MAX ){
                      LogInvalidValue(token, value);
                      brc = false;
                 } 
                 break;
            case IP_ACCEPT_CALL:
                 if ( ! GetYesNo(value, &m_ipt_params.m_accept_call) ){
                      brc = false;
                      LogInvalidValue(token, value);
                 }
                 break;

            case IP_PROTOCOL:    //   "IP Protocol"
                 str_storestring(&m_ipt_params.ip_protocol, value);
                 break;

            case IP_DIGITS:
                 if (!str_findcode(value, &m_ipt_params.ip_digits, digit_types) ){
                     // not in table
                     if ( ! str_getnumber(value, &m_ipt_params.ip_digits ) ) {
                         // and not a number, failure
                          brc = false;
                          LogInvalidValue(token, value);
                     }
                 }
                 break;

            case IP_CODER:
                 if (!str_findcode(value, (int *)&m_ipt_params.ip_coder, coder_names) ){
                     // not in table
                     if ( ! str_getnumber(value, (int *)&m_ipt_params.ip_coder ) ) {
                         // and not a number, use default
                          LogInvalidValue(token, value);
                          brc = false;
                     }
                 }
                 break;

            case IP_FRAMESIZE:
                 if (!str_findcode(value, (int *)&m_ipt_params.ip_frame_size, framesize_names) ){
                     // not in table
                     if ( ! str_getnumber(value, (int *)&m_ipt_params.ip_frame_size ) ) {
                         // and not a number, failure
                          LogInvalidValue(token,value);
                          brc = false;
                     }
                 }
                 break;

            case IP_VAD:
                 if (!str_findcode(value, (int *)&m_ipt_params.ip_vad, vad_names) ){
                     // not in table
                     if ( ! str_getnumber(value, (int *)&m_ipt_params.ip_vad ) ) {
                          // and not a number, failure
                          LogInvalidValue(token, value);
                          brc = false;
                     }
                 }
                 break;

            case IP_PAYLOAD:
                 if (!str_findcode(value, (int *)&m_ipt_params.ip_payoad_type, payload_names) ){
                     // not in table
                     if ( ! str_getnumber(value, &m_ipt_params.ip_payoad_type ) ) {
                          // and not a number, failure
                          LogInvalidValue(token, value);
                          brc = false;
                     }
                 }
                 break;

            default:
                 LogUnmatchedParameter(token, __LINE__);
                 brc = false;
                 break;
         } // switch inx (keyword)
         break;
     } // if keyword match
 }  // for each keyword  

 if ( inx == num_ipt_keywords){
      LogUndefinedParameter(token);
 }
 return brc;
}  //	End of ReadIptValues()

//*****************************************************************************
// Purpose	: 
//    Read section [Dti] from configuration file
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::ReadDtiValues(const char *token){
 typedef enum {
    NUM_DTI_CHANNELS,
    PRIVATE_DTI_LOG,
    DTI_ACCEPT_CALL
 }DTI_KEYWORD_CODES;

 static const char *dti_keywords[] = {
    "NumberOfChannels",
    "PrivateLog",
    "AcceptCall"
 };  //	End of common_keywords
  static const size_t num_dti_keywords = sizeof(dti_keywords) / sizeof(const char *);

  char value[MAXTOKEN];

  // skip any '='
  *value = '=';
  while( *value == '=') {
         if (!GetNextToken(value, sizeof(value))){
             return false;
         }
  } // while

  bool brc = true;
  size_t inx;
  for ( inx = 0; inx < num_dti_keywords; inx++){
     if (COMPARE_EQUAL == str_compare(dti_keywords[inx],token ) ) {
         switch(inx){
            case NUM_DTI_CHANNELS:    //   "NumberOfChannels",
                 if ( !GetUNumber(value, &m_DtiParams.m_number_of_channels) ){
                      LogInvalidValue(token, value);
                      brc = false;
                 }
                 break;

            case PRIVATE_DTI_LOG:    //   "MaxLogSize",
                 if ( ! str_getunsignednumber(value, (unsigned int *)&m_DtiParams.m_private_log ) ) {
                        m_DtiParams.m_private_log = log_get_msgtype_value(value);
                 }
                 if ( m_DtiParams.m_private_log >= MSG_TYPE_MAX ){
                      LogInvalidValue(token, value);
                      brc = false;
                 } 
                 break;
            case DTI_ACCEPT_CALL:
                 if ( ! GetYesNo(value, &m_DtiParams.m_accept_call) ){
                      brc = false;
                      LogInvalidValue(token, value);
                 }
                 break;

            default:
                 LogUnmatchedParameter(token, __LINE__);
                 brc = false;
                 break;
         } // switch inx (keyword)
         break;
     } // if keyword match