keyword_spotting.cpp

This example shows how to use the SKeywordSpottingI interface.

/*****************************************************************
 *  BSAPI Keyword Spotting Example                               *
 *                                                               *
 *  Copyright   : (C) 2006-2008 by Petr Schwarz & Pavel Matejka  *
 *                         & Tomas Cipr                          *
 *                                                               *
 *  Email       : {schwarz,matejka,cipr}@phonexia.com            *
 ****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <cstring>
#include <string>
#include <cassert>

#include "bsapi.h"
#include "getopt.h"
#include "labtarget.h"

#ifdef WIN32
  #define DIRSEP "\\"
#else
  #define DIRSEP "/"
#endif

#define KWS_LIC_SECS_TO_EXPIRE_WARN  (10 * 24 * 3600)

SLabelTarget gHypTarget;
SLabelTarget gDetTarget;

// This is an error handling object. If an error occur, a message is sent to this object at first. 
// Then the running function will exit with the false or 0 return value. The object also accept 
// warning and logging messages.
class ErrorHandler : public SErrorCallbackI 
{
  public:
    ErrorHandler() : mVerbose(false) {;}
    virtual void BSAPI_METHOD OnTextMessage(unsigned int iId, message_type type, unsigned int messageId, char *pMessage)
    {
      switch(type)
      {
        case mtError:
          fprintf(stdout, "ERROR: %s - %s\n", BSAPIInterfaceId2Text(iId), pMessage);
          break;
        case mtWarning:
          fprintf(stdout, "WARNING: %s - %s\n", BSAPIInterfaceId2Text(iId), pMessage);
          break;
        case mtLog:
          LogMessage(pMessage);
          break;
      }
    }

    void LogMessage(const char *pMessage, ...)
    {
      if (mVerbose)
      {
        va_list ap;
        va_start(ap, pMessage);
        vfprintf(stdout, pMessage, ap);
        fprintf(stdout, "\n");
        va_end(ap);
      }
    }
    
    void SetVerbose(bool verbose) {mVerbose = verbose;}
  
  protected:
    bool mVerbose;
} gErrorHandler;

std::string change_file_suffix(const char *pFilename, const char *pNewSuffix)
{
  assert(pFilename);
  assert(pNewSuffix);
  std::string res = pFilename;
  size_t pos_dot = res.rfind('.');
  size_t pos_slash1 = res.rfind('/');
  size_t pos_slash2 = res.rfind('\\');
  size_t pos_slash = std::string::npos;
  if (pos_slash1 != std::string::npos && pos_slash2 != std::string::npos)
    pos_slash = pos_slash1 > pos_slash2 ? pos_slash1 : pos_slash2;
  else
    pos_slash = pos_slash1 != std::string::npos ? pos_slash1 : pos_slash2;

  if (pos_dot == std::string::npos || (pos_slash != std::string::npos && pos_slash > pos_dot))
    res += pNewSuffix;
  else
    res.replace(pos_dot, strlen(pNewSuffix), pNewSuffix);

  return res;
}

void help()
{ 
  puts("\n Keyword spotting                                               ");
  printf(" %s\n", BSAPIVersion());
  puts(" ================================================================ ");
  puts("                                                                  ");
  puts(" USAGE: kws [options]                                             ");
  puts("                                                                  ");
  puts(" system configuration:                                            ");
  puts("   -c file         configuration file                             ");
  puts("                                                                  ");
  puts(" processing one file:                                             ");
  puts("   -i file         input file                                     ");
  puts("   -o file         detection file                                 ");
  puts("   -h file         hypothesis file                                ");
  puts("                                                                  ");
  puts(" processing list of files:                                        ");
  puts("   -l file         list of input files                            ");
  puts("   -p file         detection master file (for all input files)    ");
  puts("   -q file         hypothesis master file (for all input files)   ");
  puts("   -o \"none\"       will not produce detection file per each file ");
  puts("   -h \"none\"       will not produce hypothesis file per each file");
  puts("                                                                  ");
  puts(" processing directory:                                            ");
  puts("   -d dir          input directory                                ");
  puts("   -e str [raw]    extension of audio files                       ");
  puts("   -p file         detection master file (for all input files)    ");
  puts("   -q file         hypothesis master file (for all input files)   ");
  puts("   -o \"none\"       will not produce detection file per each file ");
  puts("   -h \"none\"       will not produce hypothesis file per each file");
  puts("                                                                  ");
  puts(" NOTE: in case of -l or -d the output will be written             ");
  puts("       to *.hyp and *.det where * is the audio filename           ");
  puts("       without extension. Can be switched off by -o none, -h none ");
  puts("                                                                  ");
  puts(" other options:                                                   ");
  puts("   -v              verbose mode                                   ");
  puts("   -s fmt [mlf]    time format (seconds, mlf)                     ");
  puts("   -y file         list of keywords and pronunciations in XML     ");
  puts("   -t file         XSLT to be linked with the list of keywords    ");
  puts("   -w fmt [lin16]  waveform format (lin16, lin8, alaw, mulaw)     ");
  puts("   -n num [1]      number of channels in audio files, takes into  ");
  puts("                   account for non header files (.raw)            ");
  puts("   -x file         list of keywords in XML format                 ");
  puts("   -k file         list of keywords in plain text format          ");
  puts("                                                                  ");
}

int main(int argc, char **argv)
{
  // initial configuration variables
  char *pconfig_file   = 0;
  char *pinput_file    = 0;
  char *plist_file     = 0;
  char *pinput_dir     = 0;
  char *pwave_ext      = "raw";
  char *pwave_fmt      = "lin16";
  char *pkwlxml_file   = 0;
  char *pkwltxt_file   = 0;
  char *pkwlxsl_file   = 0;
  char *poutdet_file   = 0;
  char *pouthyp_file   = 0;
  char *poutdetm_file  = 0;
  char *pouthypm_file  = 0;
  char *ptime_fmt      = "mlf";
  char *poutkwl_file   = 0;
  int  nchannels       = 1;  

  float acwf_start     = 0;
  float acwf_len       = 0;

  // command line parsing
  if(argc == 1)
  {
    help();
    return 0;
  }

  optind = 0;
  while (1)
  {
    int c = getopt(argc, argv, const_cast<char *>("-c:i:l:d:e:w:n:x:k:o:h:p:q:s:y:t:v"));
    if(c == -1)
      break;

    switch(c)
    {
      case 'c':
        pconfig_file = optarg;
        break;
      case 'i':
        pinput_file = optarg;
        break;
      case 'l':
        plist_file = optarg;
        break;
      case 'd':
        pinput_dir = optarg;
        break;
      case 'e':
        pwave_ext = optarg;
        break;
      case 'w':
        pwave_fmt = optarg;
        break;
     case 'n':
       if(sscanf(optarg, "%d", &nchannels) != 1 || nchannels < 1)
       {
         fprintf(stderr, "ERROR: Invalid number of channels: %s.\n", optarg);
         return 1;
       }
       break;
      case 'x':
        pkwlxml_file = optarg;
        break;
      case 'k':
        pkwltxt_file = optarg;
        break;
      case 'o':
        poutdet_file = optarg;
        break;
      case 'h':
        pouthyp_file = optarg;
        break;
      case 'p':
        poutdetm_file = optarg;
        break;
      case 'q':
        pouthypm_file = optarg;
        break;
      case 's':
        ptime_fmt = optarg;
        break;
      case 'y':
        poutkwl_file = optarg;
        break;
      case 't':
        pkwlxsl_file = optarg;
        break;
      case 'v':
        gErrorHandler.SetVerbose(true);
        break;
      case '?':
        fprintf(stderr, "ERROR: Command line parsing error.\n");
        return 1;
    }
  }

  if (!((pkwlxml_file == 0) ^ (pkwltxt_file == 0)))
  {
    fprintf(stderr, "ERROR: List of keywords must be given either in XML ('x') or plain text format ('k').\n");
    return 1;
  }

  // register license file for SKeywordSpottingI
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }

  gHypTarget.SetTimeFormatStr(ptime_fmt);
  gDetTarget.SetTimeFormatStr(ptime_fmt);

  SKeywordSpottingI *pkws = static_cast<SKeywordSpottingI *>(BSAPICreateInstance(SIID_KWS));
  if(!pkws)
  {
    return 1;
  }
  
  pkws->SetErrorHandler(&gErrorHandler);

  if (plicman)
  {
    long_long secs_to_expire = plicman->GetSecsToExpire(SIID_KWS);
    if (secs_to_expire < KWS_LIC_SECS_TO_EXPIRE_WARN)
      fprintf(stderr, "WARNING: License will expire in %d day(s).\n", static_cast<int>(secs_to_expire / (24 * 3600)));
  }

  // read configuration file and configure the instance
  char pdefault_cfg[1024];
  sprintf(pdefault_cfg, "settings%smain_config", DIRSEP);  // Visual C does not have snprintf
  if(!pkws->Init((pconfig_file ? pconfig_file : pdefault_cfg)))
  {
    pkws->Release();
    return 1;
  }

  // It is also possible to configure the waveform source.
  // If there are multiple channels, the channels are concatenated and just one decision made.
  SBlockSetI * pbset = pkws->GetBlockSet();
  if (!pbset)
  {
    pkws->Release();
    return 1;
  }
  
  SWaveformFormatConvertorI *pwc = static_cast<SWaveformFormatConvertorI *>(pbset->GetBlock("convertor"));
  if (pwc)
  {
    pwc->SetNChannels(nchannels);
    pwc->SetInputFormatStr(pwave_fmt);
  }

  // Prepare keyword list
  SKeywordListI * mpKeywordList;
  mpKeywordList=pkws->GetKeywordList();
  if(!mpKeywordList)
  {
    pkws->Release();
    return 1;
  }
  
  if(!mpKeywordList->Load(
    pkwlxml_file ? pkwlxml_file : pkwltxt_file,
    pkwlxml_file ? SKeywordListI::ffXML : SKeywordListI::ffPlain))
  {
    pkws->Release();
    return 1;
  }
  
  if(!mpKeywordList->AddPronunciations(SKeywordListI::apmCondAdd))
  {
    pkws->Release();
    return 1;
  }
  
  if(!mpKeywordList->CheckKeywords())
  {
    pkws->Release();
    return 1;
  }
  
  if(poutkwl_file && !mpKeywordList->Save(poutkwl_file, pkwlxsl_file))
  {
    pkws->Release();
    return 1;
  }

  // Set targets
  pkws->SetDetectionsTarget(&gDetTarget);
  pkws->SetHypothesesTarget(&gHypTarget);

  gHypTarget.StartProcessing(pouthypm_file);
  gDetTarget.StartProcessing(poutdetm_file);

  // the input is one file
  if(pinput_file)
  {
    gErrorHandler.LogMessage("Processing file: %s", pinput_file);

    gHypTarget.StartProcessingFile(pinput_file, pouthyp_file);
    gDetTarget.StartProcessingFile(pinput_file, poutdet_file);
    if(!pkws->ProcessFile(pinput_file, 0, 0))
    {
      pkws->Release();
      return 1;
    }
    gHypTarget.FinishProcessingFile();
    gDetTarget.FinishProcessingFile();
  }

  // the input is listfile
  if(plist_file)
  {
    SFileListI *plist = static_cast<SFileListI *>(BSAPICreateInstance(SIID_FILELIST));
    if(!plist)
    {
      fprintf(stderr, "Memory allocation error.");
      pkws->Release();
      return 1;
    }
    plist->SetErrorHandler(&gErrorHandler);
    if(!plist->AddList(plist_file))
    {
      plist->Release();
      pkws->Release();
      return 1;
    }

    plist->FirstLine();
    char ptarget[1024];
    char psource[1024];
    int start;
    int end;
    float prob;
    while(plist->GetLine(ptarget, psource, &start, &end, &prob))
    {
      gErrorHandler.LogMessage("Processing file: %s", psource);

      std::string outhyp_file = change_file_suffix(psource, ".hyp");
      std::string outdet_file = change_file_suffix(psource, ".det");
      
      if( !pouthyp_file || (pouthyp_file &&  strcmp(pouthyp_file,"none") != 0 &&  strcmp(pouthyp_file,"") != 0 )){
        gHypTarget.StartProcessingFile(psource, outhyp_file.c_str());
      }else{
        gHypTarget.StartProcessingFile(psource, 0);
      }

      if( !poutdet_file || (poutdet_file && strcmp(poutdet_file,"none") != 0 &&  strcmp(poutdet_file,"") != 0 )){
        gDetTarget.StartProcessingFile(psource, outdet_file.c_str());
      }else{
        gDetTarget.StartProcessingFile(psource, 0);
      }

      if(!pkws->ProcessFile(psource, 0, 0))
      {
        plist->Release();
        pkws->Release();
        return 1;
      }
      gHypTarget.FinishProcessingFile();
      gDetTarget.FinishProcessingFile();
    }
    plist->Release();
  }

  // the input is a directory
  // The FileSniffer can monitor a directory for incoming files. Here, the dictionary is searched just once.
  if(pinput_dir)
  {
    SFileSnifferI *psniffer = static_cast<SFileSnifferI *>(BSAPICreateInstance(SIID_FILESNIFFER));
    if(!psniffer)
    {
      fprintf(stderr, "Memory allocation error.");
      pkws->Release();
      return 1;
    }
    psniffer->SetErrorHandler(&gErrorHandler);
    psniffer->AddDirectory(pinput_dir);
    psniffer->AddWantedSuffix(pwave_ext);

    if(!psniffer->FirstFile())
    {
      psniffer->Release();
      pkws->Release();
      return 1;
    }

    char psource[1024];
    while(psniffer->GetFile(psource, sizeof(psource) - 1))
    {
      gErrorHandler.LogMessage("Processing file: %s", psource);

      std::string outhyp_file = change_file_suffix(psource, ".hyp");
      std::string outdet_file = change_file_suffix(psource, ".det");

      if( !pouthyp_file || (pouthyp_file &&  strcmp(pouthyp_file,"none") != 0 &&  strcmp(pouthyp_file,"") != 0 )){
        gHypTarget.StartProcessingFile(psource, outhyp_file.c_str());
      }else{
        gHypTarget.StartProcessingFile(psource, 0);
      }

      if( !poutdet_file || (poutdet_file && strcmp(poutdet_file,"none") != 0 &&  strcmp(poutdet_file,"") != 0 )){
        gDetTarget.StartProcessingFile(psource, outdet_file.c_str());
      }else{
        gDetTarget.StartProcessingFile(psource, 0);
      }

      if(!pkws->ProcessFile(psource, 0, 0))
      {
        psniffer->Release();
        pkws->Release();
        return 1;
      }
      gHypTarget.FinishProcessingFile();
      gDetTarget.FinishProcessingFile();
    }
    psniffer->Release();
  }

  gHypTarget.FinishProcessing();
  gDetTarget.FinishProcessing();

  pkws->Release();
  return 0;
}

---