lid.cxx

sloedgy open sip stack source code

{
  return FALSE;
}


OpalLineInterfaceDevice::AECLevels OpalLineInterfaceDevice::GetAEC(unsigned)
{
  return AECError;
}


BOOL OpalLineInterfaceDevice::SetAEC(unsigned, AECLevels)
{
  return FALSE;
}

unsigned OpalLineInterfaceDevice::GetWinkDuration(unsigned)
{
  return 0;
}


BOOL OpalLineInterfaceDevice::SetWinkDuration(unsigned, unsigned)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::GetVAD(unsigned)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::SetVAD(unsigned, BOOL)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::GetCallerID(unsigned, PString & id, BOOL)
{
  id = PString();
  return FALSE;
}


BOOL OpalLineInterfaceDevice::SetCallerID(unsigned, const PString &)
{
  return FALSE;
}

BOOL OpalLineInterfaceDevice::SendCallerIDOnCallWaiting(unsigned, const PString &)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::SendVisualMessageWaitingIndicator(unsigned, BOOL)
{
  return FALSE;
}

BOOL OpalLineInterfaceDevice::PlayDTMF(unsigned, const char *, DWORD, DWORD)
{
  return FALSE;
}


char OpalLineInterfaceDevice::ReadDTMF(unsigned)
{
  return '\0';
}


BOOL OpalLineInterfaceDevice::GetRemoveDTMF(unsigned)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::SetRemoveDTMF(unsigned, BOOL)
{
  return FALSE;
}


unsigned OpalLineInterfaceDevice::IsToneDetected(unsigned)
{
  return NoTone;
}


unsigned OpalLineInterfaceDevice::WaitForToneDetect(unsigned line, unsigned timeout)
{
  PTRACE(2, "LID\tWaitForToneDetect");

  static const unsigned sampleRate = 25;

  timeout = (timeout+sampleRate-1)/sampleRate;

  unsigned retry = 0;
  do {
    unsigned tones = IsToneDetected(line);
    if (tones != NoTone) {
      PTRACE(2, "LID\tTone " << tones << " detected after " << (retry*sampleRate) << " ms");
      return tones;
    }

    PThread::Current()->Sleep(sampleRate);
    retry++;
  } while (retry < timeout);

  PTRACE(3, "LID\tTone detection timeout " << (retry*sampleRate) << " ms");
  return NoTone;
}


BOOL OpalLineInterfaceDevice::WaitForTone(unsigned line,
                                          CallProgressTones tone,
                                          unsigned timeout)
{
  PTRACE(3, "LID\tWaitFor the tone " << tone );
  BOOL res = WaitForToneDetect(line, timeout) & tone;
  PTRACE(3, "LID\tWaitFor the tone " << tone << 
	 " is successfull-" << (res ? "YES" : "No"));
  return res;
}


BOOL OpalLineInterfaceDevice::SetToneFilter(unsigned line,
                                            CallProgressTones tone,
                                            const PString & description)
{
  PString freqDesc, cadenceDesc;
  PINDEX colon = description.Find(':');
  if (colon == P_MAX_INDEX)
    freqDesc = description;
  else {
    freqDesc = description.Left(colon);
    cadenceDesc = description.Mid(colon+1);
  }

  unsigned low_freq, high_freq;
  PINDEX dash = freqDesc.Find('-');
  if (dash == P_MAX_INDEX)
    low_freq = high_freq = freqDesc.AsUnsigned();
  else {
    low_freq = freqDesc.Left(dash).AsUnsigned();
    high_freq = freqDesc.Mid(dash+1).AsUnsigned();
  }
  if (low_freq  < 100 || low_freq  > 3000 ||
      high_freq < 100 || high_freq > 3000 ||
      low_freq > high_freq) {
    PTRACE(1, "LID\tIllegal frequency specified: " << description);
    return FALSE;
  }

  PStringArray times = cadenceDesc.Tokenise("-");
  PINDEX numCadences = (times.GetSize()+1)/2;
  
  PUnsignedArray onTimes(numCadences), offTimes(numCadences);
  for (PINDEX i = 0; i < times.GetSize(); i++) {
    double time = atof(times[i]);
    if (time <= 0.01 || time > 10) {
      PTRACE(1, "LID\tIllegal cadence time specified: " << description);
      return FALSE;
    }

    if ((i&1) == 0)
      onTimes[i/2] = (unsigned)(time*1000);
    else
      offTimes[i/2] = (unsigned)(time*1000);
  }

  return SetToneFilterParameters(line, tone, low_freq, high_freq,
                                 numCadences, onTimes, offTimes);
}


BOOL OpalLineInterfaceDevice::SetToneFilterParameters(unsigned /*line*/,
                                                      CallProgressTones /*tone*/,
                                                      unsigned /*lowFrequency*/,
                                                      unsigned /*highFrequency*/,
                                                      PINDEX /*numCadences*/,
                                                      const unsigned * /*onTimes*/,
                                                      const unsigned * /*offTimes*/)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::PlayTone(unsigned, CallProgressTones)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::IsTonePlaying(unsigned)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::StopTone(unsigned)
{
  return FALSE;
}


BOOL OpalLineInterfaceDevice::PlayAudio(unsigned /*line*/, const PString & /*filename*/)
{
  PTRACE(3, "LID\tBase Class PlayAudio method called, exiting with FALSE");
  return FALSE;
}


BOOL OpalLineInterfaceDevice::StopAudio(unsigned /*line*/)
{
  PTRACE(3, "LID\tBase Class StopAudio method called, exiting with FALSE");
  return FALSE;
}
	

OpalLineInterfaceDevice::CallProgressTones
                OpalLineInterfaceDevice::DialOut(unsigned line,
                                                 const PString & number,
                                                 BOOL requireTone)
{
  PTRACE(3, "LID\tDialOut to " << number);

  if (IsLineTerminal(line))
    return NoTone;

  if (!SetLineOffHook(line))
    return NoTone;

  // Should get dial tone within 2 seconds of going off hook
  if (!WaitForTone(line, DialTone, 2000)) {
    if (requireTone)
      return DialTone;
  }

  // Dial the string
  PINDEX lastPos = 0;
  PINDEX nextPos;
  while ((nextPos = number.FindOneOf("!@,")) != P_MAX_INDEX) {
    PlayDTMF(line, number(lastPos, nextPos-1));
    lastPos = nextPos+1;
    switch (number[nextPos]) {
      case '!' :
        if (!HookFlash(line))
          return NoTone;
        break;

      case '@' :
        if (!WaitForTone(line, DialTone, 3000)) {
          if (requireTone)
            return DialTone;
        }
        break;

      case ',' :
        PThread::Current()->Sleep(2000);
        break;
    }
  }

  PlayDTMF(line, number.Mid(lastPos));

  // Wait for busy or ring back
  unsigned tones;
  while ((tones = WaitForToneDetect(line, 5000)) != NoTone) {
    if (tones & BusyTone)
      return BusyTone;
    else if (tones & RingTone)
      break;
  }

  if (requireTone)
    return NoTone;

  return RingTone;
}

static struct {
  const char * isoName;
  unsigned dialCode;
  OpalLineInterfaceDevice::T35CountryCodes t35Code;
  const char * fullName;
  const char * dialTone;
  const char * ringTone;
  const char * busyTone;
} CountryInfo[] = {
  { "AF", 93,   OpalLineInterfaceDevice::Afghanistan,           "Afghanistan" },
  { "AL", 355,  OpalLineInterfaceDevice::Albania,               "Albania" },
  { "DZ", 213,  OpalLineInterfaceDevice::Algeria,               "Algeria" },
  { "AS", 684,  OpalLineInterfaceDevice::AmericanSamoa,         "American Samoa" },
  { "AO", 244,  OpalLineInterfaceDevice::Angola,                "Angola" },
  { "AI", 1264, OpalLineInterfaceDevice::Anguilla,              "Anguilla" },
  { "AG", 1268, OpalLineInterfaceDevice::AntiguaAndBarbuda,     "Antigua and Barbuda" },
  { "AR", 54,   OpalLineInterfaceDevice::Argentina,             "Argentina" },
  { "AC", 247,  OpalLineInterfaceDevice::Ascension,             "Ascension Island" },
  { "AU", 61,   OpalLineInterfaceDevice::Australia,             "Australia",            "425:0.1", "425:0.4-0.2-0.4-2", "425:0.375-0.375" },
  { "AT", 43,   OpalLineInterfaceDevice::Austria,               "Austria" },
  { "BS", 1242, OpalLineInterfaceDevice::Bahamas,               "Bahamas" },
  { "BH", 973,  OpalLineInterfaceDevice::Bahrain,               "Bahrain" },
  { "BD", 880,  OpalLineInterfaceDevice::Bangladesh,            "Bangladesh" },
  { "BB", 1246, OpalLineInterfaceDevice::Barbados,              "Barbados" },
  { "BE", 32,   OpalLineInterfaceDevice::Belgium,               "Belgium" },
  { "BZ", 501,  OpalLineInterfaceDevice::Belize,                "Belize" },
  { "BJ", 229,  OpalLineInterfaceDevice::Benin,                 "Benin" },
  { "BM", 1441, OpalLineInterfaceDevice::Bermudas,              "Bermudas" },
  { "BT", 975,  OpalLineInterfaceDevice::Bhutan,                "Bhutan" },
  { "BO", 591,  OpalLineInterfaceDevice::Bolivia,               "Bolivia" },
  { "BW", 267,  OpalLineInterfaceDevice::Botswana,              "Botswana" },
  { "BR", 55,   OpalLineInterfaceDevice::Brazil,                "Brazil" },
  { "xx", 0,    OpalLineInterfaceDevice::BritishAntarcticTerritory, "British Antarctic Territory" },
  { "IO", 246,  OpalLineInterfaceDevice::BritishIndianOceanTerritory, "British IndianOcean Territory" },
  { "VG", 1284, OpalLineInterfaceDevice::BritishVirginIslands,  "British Virgin Islands" },
  { "BN", 673,  OpalLineInterfaceDevice::BruneiDarussalam,      "Brunei Darussalam" },
  { "BG", 359,  OpalLineInterfaceDevice::Bulgaria,              "Bulgaria" },
  { "BF", 226,  OpalLineInterfaceDevice::BurkinaFaso,           "Burkina Faso" },
  { "BI", 257,  OpalLineInterfaceDevice::Burundi,               "Burundi" },
  { "xx", 0,    OpalLineInterfaceDevice::Byelorussia,           "Byelorussia" },
  { "KH", 855,  OpalLineInterfaceDevice::Cambodia,              "Cambodia" },
  { "CM", 237,  OpalLineInterfaceDevice::Cameroon,              "Cameroon" },
  { "CA", 1,    OpalLineInterfaceDevice::Canada,                "Canada" },
  { "CV", 238,  OpalLineInterfaceDevice::CapeVerde,             "Cape Verde" },
  { "KY", 1345, OpalLineInterfaceDevice::CaymanIslands,         "Cayman Islands" },
  { "CF", 236,  OpalLineInterfaceDevice::CentralAfricanRepublic,"Central African Republic" },
  { "TD", 235,  OpalLineInterfaceDevice::Chad,                  "Chad" },
  { "CL", 56,   OpalLineInterfaceDevice::Chile,                 "Chile" },
  { "CN", 86,   OpalLineInterfaceDevice::China,                 "China" },
  { "CO", 57,   OpalLineInterfaceDevice::Colombia,              "Colombia" },
  { "KM", 269,  OpalLineInterfaceDevice::Comoros,               "Comoros" },
  { "CG", 242,  OpalLineInterfaceDevice::Congo,                 "Congo" },
  { "CK", 682,  OpalLineInterfaceDevice::CookIslands,           "Cook Islands" },
  { "CR", 506,  OpalLineInterfaceDevice::CostaRica,             "Costa Rica" },
  { "CI", 225,  OpalLineInterfaceDevice::CotedIvoire,           "Cote dIvoire" },
  { "CU", 53,   OpalLineInterfaceDevice::Cuba,                  "Cuba" },
  { "CY", 357,  OpalLineInterfaceDevice::Cyprus,                "Cyprus" },
  { "CZ", 420,  OpalLineInterfaceDevice::Czechoslovakia,        "Czech Republic" },
  { "DK", 45,   OpalLineInterfaceDevice::Denmark,               "Denmark" },
  { "DJ", 253,  OpalLineInterfaceDevice::Djibouti,              "Djibouti" },
  { "DM", 1767, OpalLineInterfaceDevice::Dominica,              "Dominica" },
  { "DO", 1809, OpalLineInterfaceDevice::DominicanRepublic,     "Dominican Republic" },
  { "EC", 593,  OpalLineInterfaceDevice::Ecuador,               "Ecuador" },
  { "EG", 20,   OpalLineInterfaceDevice::Egypt,                 "Egypt" },
  { "SV", 503,  OpalLineInterfaceDevice::ElSalvador,            "El Salvador" },
  { "GQ", 240,  OpalLineInterfaceDevice::EquatorialGuinea,      "Equatorial Guinea" },
  { "ET", 251,  OpalLineInterfaceDevice::Ethiopia,              "Ethiopia" },
  { "FK", 500,  OpalLineInterfaceDevice::FalklandIslands,       "Falkland Islands" },
  { "FJ", 679,  OpalLineInterfaceDevice::Fiji,                  "Fiji" },
  { "FI", 358,  OpalLineInterfaceDevice::Finland,               "Finland" },
  { "FR", 33,   OpalLineInterfaceDevice::France,                "France" },
  { "PF", 689,  OpalLineInterfaceDevice::FrenchPolynesia,       "French Polynesia" },
  { "TF", 0,    OpalLineInterfaceDevice::FrenchSouthernAndAntarcticLands, "French Southern and Antarctic Lands" },
  { "GA", 241,  OpalLineInterfaceDevice::Gabon,                 "Gabon" },
  { "GM", 220,  OpalLineInterfaceDevice::Gambia,                "Gambia" },
  { "DE", 49,   OpalLineInterfaceDevice::Germany,               "Germany" },
  { "GH", 233,  OpalLineInterfaceDevice::Ghana,                 "Ghana" },