mh_handset.c

DSP 播放语音文件例子

    /* Long duration DTMF event detected */
    case 'L':
      SYSLOG(LOG_DEBUG,"Long duration DTMF tone detected on line %d\n",oLineNumber);
      return HANDSET_LONG_DURATION_DTMF_EVENT;

    case 'T':
      if (pHandset->oDtmfStatus == 0) {
        /* The DTMF event has just been detected */
        SYSLOG(LOG_DEBUG,"T38 start detected on line %d\n",oLineNumber);
        return HANDSET_T38_START;
      } else {
        /* The DTMF event has stopped */
        SYSLOG(LOG_DEBUG,"T38 stop detected on line %d\n",oLineNumber);
        return HANDSET_T38_STOP;
      }
      break;

    default:
      *chKeyPressed = 0;
      SYSLOG(LOG_DEBUG,"Unknown dtmf event %d detected on line %d\n",chKey,oLineNumber);
    }
  }
  
  /* No handset activity detected on this round */
  return HANDSET_NO_EVENT;
}


/**************************************************************************
 * HandsetSetVolume
 *   Preset the volume of speaker, ring or handset output
 *     oLineNumber - line number to set
 *     eOutput - output volume to set
 *     oVolume - volume setting (0-9) where 0=mute, 9=loudest
 **************************************************************************/
LONG HandsetSetVolume(OCTET oLineNumber,
                      E_OUTPUT_TYPE eOutput, 
                      OCTET oVolume)
{
  return 0;
}


/**************************************************************************
 * HandsetInitialize
 *   Must be called before HandsetStart()
 *   Initialize the handset drivers
 *     Display, SLIC, keypad
 *   Returns INIT_ERROR for hardware or audio init problems
 *           INIT_NO_ERROR for no error
 **************************************************************************/
LONG HandsetInitialize(void)
{
  char chParamValue[CONFIG_MAXPARAMLENGTH+1];
  OCTET oCountry;
  
#ifdef HANDSET_USEDISPLAY
  /* Open the display driver */
  g_iDisplayFd=open("/display",O_RDONLY);
  if (g_iDisplayFd<0) {
    SYSLOG(LOG_ERROR,"FAILED to open display driver rc=%d, errno=%d\n",
           g_iDisplayFd,errno);
    return INIT_ERROR;
  }
  
  /* Display "initializing" message */
  HandsetClearDisplay();
  HandsetDisplayString("   Initializing:    ",1);
  
  /* open the keypad driver */
  HandsetDisplayString("Keypad driver ...",3);
  g_iKeypadFd=open("/keypad",O_RDONLY);
  if (g_iKeypadFd<0) {
    SYSLOG(LOG_ERROR,"FAILED to open keypad driver rc=%d, errno=%d\n",
           g_iKeypadFd,errno);
    HandsetDisplayString("Keypad driver FAIL",3);
    return INIT_ERROR;
  }
#endif // HANDSET_USEDISPLAY
  
#if ((!defined(HANDSET_NO_CALLER_ID)) || defined(HANDSET_VODSLMH))
  {
    OCTET oCidCountry = CID_UNKNOWN;
    oCountry = USA;
    
    /* Any special country requirements? */
    if (ConfigGetParam("COUNTRY",chParamValue,CONFIG_MAXPARAMLENGTH) == CONFIG_OK) {
      SYSLOG(LOG_INFO,"Country : %s\n", chParamValue);
      if (strcmp(chParamValue, "UK") == 0) {
	oCountry = UK;
	oCidCountry = CID_UK;
      } else if (strcmp(chParamValue, "USA") == 0) {
	oCidCountry = CID_USA;
      } else if (strcmp(chParamValue, "BELGIUM")== 0) {
	oCountry = BELGIUM;
      } else if (strcmp(chParamValue, "GERMANY") == 0) {
	oCountry = GERMANY;
	oCidCountry = CID_GERMANY;
      } else if (strcmp(chParamValue, "JAPAN") == 0) {
	oCountry = JAPAN;
	oCidCountry = CID_JAPAN;
      } else if (strcmp(chParamValue, "SWEDEN") == 0) {
	oCountry = USA;
	oCidCountry = CID_SWEDEN;
      } else if (strcmp(chParamValue, "FRANCE") == 0) {
	oCountry = FRANCE;
	oCidCountry = CID_FRANCE;
      } else if (strcmp(chParamValue, "ITALY") == 0) {
	oCidCountry = CID_ITALY;
      }
    }
#endif // ((!defined(HANDSET_NO_CALLER_ID)) || defined(HANDSET_VODSLMH))

#ifdef HANDSET_VODSLMH
    /* Open the SHPotsSPI driver */
    g_iSlicFd=open("/SHPotsSPI",O_RDONLY);
    if (g_iSlicFd<0) {
      SYSLOG(LOG_ERROR,"FAILED to open SHPotsSPI driver rc=%d, errno=%d\n",
             g_iSlicFd,errno);
      return INIT_ERROR;
    }
    ioctl(g_iSlicFd, SLIC_IOCTL_LOCALIZATION, oCountry);
  
    /* No autodetect yet, hardcoded to 2 lines for now */
    g_oNumHandsetLines = 2;
  
#else
    {
      /* Open the slic driver */
      HandsetDisplayString("SLIC driver ...",3);
      g_iSlicFd=open("/slic",O_RDWR);
      if (g_iSlicFd<0) {
        SYSLOG(LOG_ERROR,"FAILED to open slic driver rc=%d, errno=%d\n",
               g_iSlicFd,errno);
        HandsetDisplayString("SLIC driver FAIL",3);
        return INIT_ERROR;
      }
    }
  
    /* AutoDetect number of slics available */
    ioctl(g_iSlicFd, SLIC_IOCTL_NUMLINES, (OCTET *)(&g_oNumHandsetLines));
  
    if (g_oNumHandsetLines == 0) {
      ASSERT(0);
      printf("ERROR: no slics detected\n");
      return INIT_ERROR;
    }
  
    printf("SLIC driver: %d SLICs detected\n",g_oNumHandsetLines);
  
    /* 
     * Set fast slic thread cycle time for pulse dial detection
     * WARNING! This will result in a loss of MIPS!!
     */
    if ((ConfigGetParam("DIALPULSE",chParamValue,CONFIG_MAXPARAMLENGTH) == CONFIG_OK) &&
        (strcmp(chParamValue,"YES") == 0)) {
      g_bPulseDial = TRUE;
      ioctl(g_iSlicFd, SLIC_IOCTL_THREADCYCLETIME, 20);
    }
#endif // HANDSET_VODSLMH

#if ((!defined(HANDSET_NO_CALLER_ID)) || defined(HANDSET_VODSLMH))
    switch (oCidCountry) {
    case CID_UK:
      memcpy(pSEQ_RING_WITH_CID, pSEQ_UK_CID_ONHOOK, SEQUENCE_SIZE*sizeof(STATE_SEQUENCE));
      AudioSetCallerIdBFSK(&xCID_ONHOOK_UK, &xCID_OFFHOOK_UK, &xCID_BFSK_UK);
      break;
    case CID_FRANCE:
      memcpy(pSEQ_RING_WITH_CID, pSEQ_FRANCE_CID_ONHOOK, SEQUENCE_SIZE*sizeof(STATE_SEQUENCE));
      memcpy(pSEQ_VMWI, pSEQ_FRANCE_VMWI, SEQUENCE_SIZE*sizeof(STATE_SEQUENCE));
      AudioSetCallerIdBFSK(&xCID_ONHOOK_FRANCE, &xCID_OFFHOOK_FRANCE, &xCID_BFSK_FRANCE);
      break;
    case CID_SWEDEN: /* DTMF default */
      memcpy(pSEQ_RING_WITH_CID, pSEQ_DTMF, SEQUENCE_SIZE*sizeof(STATE_SEQUENCE));
      AudioSetCallerIdDTMF(NULL);
      break;
    case CID_ITALY:
      /* The only difference for Bellcore is BFSK frequency which is same with UK */
      AudioSetCallerIdBFSK(NULL, NULL, &xCID_BFSK_UK);
      break;
    case CID_JAPAN:
      {
#ifndef HANDSET_VODSLMH
        OCTET oLine;
        for (oLine=1; oLine<=g_oNumHandsetLines; oLine++) {
          ioctl(g_iSlicFd, SLIC_IOCTL_RINGFRQVOL, oLine, 0x7F60, 0x13B);
        }
#endif
        memcpy(pSEQ_RING_WITH_CID, pSEQ_JP_CID_ONHOOK, sizeof(pSEQ_JP_CID_ONHOOK));
        AudioSetCallerIdBFSK(&xCID_ONHOOK_JAPAN, NULL, &xCID_BFSK_JAPAN);
        break;
      }
    case CID_UNKNOWN:
    case CID_USA:
    default:
      /* BFSK Default: Bellcore Spec */
      AudioSetCallerIdBFSK(NULL, NULL, NULL);
      break;
    }
  }
#endif // HANDSET_NO_CALLER_ID
  
  /* Change the main thread schedule policy */
  {
#define MS_VALUE 1000000L /* nanoseconds per millisecond */ 
    int nPolicy; 
    struct sched_param spParam; 
    pthread_getschedparam(pthread_self(), &nPolicy, &spParam); 
    spParam.itRR.it_interval.tv_sec = 0; 
    spParam.itRR.it_interval.tv_nsec = 8 * MS_VALUE; 
    spParam.sched_priority++;
    pthread_setschedparam(pthread_self(), nPolicy, &spParam);
  }  
  
  /* Registered display information */
  g_pcOnHookDisplayString = (char **)calloc(g_oNumHandsetLines,sizeof(char *));
  g_pcOnHookDisplayNumber = (char **)calloc(g_oNumHandsetLines,sizeof(char *));
  
  return INIT_NO_ERROR;
}


/**************************************************************************
 * HandsetStart
 *   Must be called after HandsetInitialize()
 *   Starts up the handset state machines. Initializes the handset audio
 *   channels and audio subsystem.
 *     oNumLines - Number of handset lines to use in the system
 **************************************************************************/
LONG HandsetStart(OCTET oNumLines)
{
#ifndef HANDSET_NO_AUD_INIT /* KOKO */
  LONG lReturn;
  OCTET oComplexCodecs = 0;
#endif /* KOKO */
  
  int j;
  
  if (!g_bHandsetStarted) {
    g_bHandsetStarted = TRUE;
  } else {
    ASSERT(0);
    return -1;
  }
  
  if (oNumLines > g_oNumHandsetLines) {
    ASSERT(0);
    return -1;
  }
  
  /* From now on, the system will assume this many lines
   * Other lines are unused */
  g_oNumHandsetLines = oNumLines;
  
  /* Allocate memory for handset info */
  pxHandset = (HANDSET *)calloc(g_oNumHandsetLines,sizeof(HANDSET));
  ASSERT(pxHandset);  
  
  /* Initialize handset states */
  for (j=0;j<HANDSET_MAXLINES;j++) {
    pxHandset[j].oDtmfPressed = 0xff;
    pxHandset[j].bOffHook = FALSE;
    pxHandset[j].oVMWIStatus = VMWI_CURRENT;
    pxHandset[j].dwLastAudioTone = 0;
    pxHandset[j].oPhoneState = HSTATE_ONHOOK_IDLE;
    pxHandset[j].dwStateTimer = 0;
    pxHandset[j].dwRingTimer = 0;
    pxHandset[j].pCID = NULL;
    pxHandset[j].oRingPatternCount = 0;
    pxHandset[j].bFirstRing = FALSE;
    pxHandset[j].bRinging = FALSE;
  }
  
#ifndef HANDSET_NO_AUD_INIT /* KOKO */  
  /* Load (overlay) complex codec libs */
  oComplexCodecs = LoadComplexCodecs();
  
  /* initialize and start audio subsystem */
  AudioInit(HANDSET_MAXLINES);
  
  /* Initialize channels */
  {
    int i;
    for (i=1;i<=HANDSET_MAXLINES;i++) {
#ifdef HANDSET_USEDISPLAY
      char chLine[50];
      sprintf(chLine,"Audio channel %d ...",i);
      HandsetDisplayString(chLine,3);
#endif // HANDSET_USEDISPLAY
      
      lReturn = AudioChannelInit(i);
      if (lReturn == AUDIO_CHANNEL_INIT_NOERR) {
        DWORD dwSpkr=0;
        DWORD dwMic=0;
        
        switch(i) {
        case 1:
          dwSpkr=DEV_AUD_SPKR_CH0;
          dwMic=DEV_AUD_MIC_CH0;
          break;
        case 2:
          dwSpkr=DEV_AUD_SPKR_CH1;
          dwMic=DEV_AUD_MIC_CH1;
          break;
        case 3:
          dwSpkr=DEV_AUD_SPKR_CH2;
          dwMic=DEV_AUD_MIC_CH2;
          break;
        case 4:
          dwSpkr=DEV_AUD_SPKR_CH3;
          dwMic=DEV_AUD_MIC_CH3;
          break;
        default:
          ASSERT(0);
        }
        
        lReturn |= AudioAssocDevice(i, AUDIO_DEV_SPKR, dwSpkr);
        lReturn |= AudioAssocDevice(i, AUDIO_DEV_MIC, dwMic);
      }
      
      if (lReturn != AUDIO_CHANNEL_INIT_NOERR) {
#ifdef HANDSET_USEDISPLAY
        sprintf(chLine,"Audio channel %d FAIL",i);
        HandsetDisplayString(chLine,3);
#endif // HANDSET_USEDISPLAY
        ASSERT(0);
        return INIT_ERROR;
      }
    }
  }
  
  /* Register DTMF detection callback function */
  AudioRegisterDtmfCallback1(_DtmfCallBack);
  
#ifndef HANDSET_NO_CALLER_ID
  /* Register DTMF detection callback function */
  AudioRegisterCallerIDStatusCallback(_CallerIdCallBack);
#endif // HANDSET_NO_CALLER_ID
  
  /* Configure audio tones */
  memset(asHandsetToneConfig,0,TONE_MAX_TYPE*sizeof(HANDSET_TONE_CONFIG));
  ConfigureTones(asHandsetToneConfig);
  
  /* Configure ring cadences */
  ConfigureRings();
  
  if (oComplexCodecs > 1) {
#ifdef HANDSET_USEDISPLAY
    HandsetDisplayString("Complex codec error",3);
#endif // HANDSET_USEDISPLAY
    ASSERT(0);
    return INIT_MULTIPLE_COMPLEX_CODECS;
  }
  
#endif /* HANDSET_NO_AUD_INIT */  
  
  return INIT_NO_ERROR;
}


/**************************************************************************
 * HandsetInitializeClock
 *   Initialization of NTP stack
 **************************************************************************/
void HandsetInitializeClock(void)
{
  char chParamValue[CONFIG_MAXPARAMLENGTH+1];
  DWORD dwNtpIPAddress=0;       /* use default */

  if (ConfigGetParam("NTPSERVERIP",chParamValue,CONFIG_MAXPARAMLENGTH)
      ==CONFIG_OK) {
    /* use the specified NTP server */
    dwNtpIPAddress=ntohl(inet_addr(chParamValue));
  }
  NtpInit(dwNtpIPAddress);

  /* get timezone */
  if (ConfigGetParam("TIMEZONE",chParamValue,CONFIG_MAXPARAMLENGTH)
      ==CONFIG_OK) {
    g_lTimeZone=strtol(chParamValue,NULL,0);
    if (g_lTimeZone<-12*60 || g_lTimeZone>12*60) {
      g_lTimeZone=-8*60;        /* Pacific Time */
    }
  }

  /* get daylight savings flag */
  if (ConfigGetParam("DST",chParamValue,CONFIG_MAXPARAMLENGTH)
      ==CONFIG_OK) {
    if (strcmp(chParamValue,"YES")==0) {
      g_bDSTObserved=TRUE;
    } else {
      g_bDSTObserved=FALSE;
    }
  }
}


/**************************************************************************
 * HandsetUpdateClock
 *   Update the time on the display clock
 **************************************************************************/
void HandsetUpdateClock(void)
{
  /* only check once per second */
  g_iTimeUpdateCountdown--;
  if (g_iTimeUpdateCountdown==0) {
    struct tm tmTime;
    
    /* reset countdown */
    g_iTimeUpdateCountdown=TIMEUPDATECOUNTDOWN;
    
    /* get current time (corrected for TZ and DST) */
    if (NtpGetLocaltime(&tmTime, g_lTimeZone, g_bDSTObserved)==TRUE) {
      /* only update date if changed */
      if (tmTime.tm_mon!=g_tmTimeLastUpdate.tm_mon ||
          tmTime.tm_mday!=g_tmTimeLastUpdate.tm_mday ||
          tmTime.tm_hour!=g_tmTimeLastUpdate.tm_hour ||
          tmTime.tm_min!=g_tmTimeLastUpdate.tm_min) {
        HandsetDisplayDateAndTime(tmTime);
      }
      memcpy(&g_tmTimeLastUpdate,&tmTime,sizeof(struct tm));
    }
  }
}


/**************************************************************************
 * HandsetQueryNumberOfLines
 *   Returns the number of lines (SLICs) detected on the hardware
 **************************************************************************/
OCTET HandsetQueryNumberOfLines(void)
{
  return g_oNumHandsetLines;
}

#endif // HANDSET_MH

/**************************************************************************/
/*********************** END OF FILE **************************************/
/**************************************************************************/