language_identification.cpp

This example shows how to use the SLIDI interface.

/*****************************************************************
 *  BSAPI Language Identification 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 <dirent.h>

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

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

#define LID_MIN_LEN_TO_PROCESS    2.0f       // 2 seconds
#define LID_BELOW_MIN_LEN_TEXT    "(too_short)"

// 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(stderr, "ERROR: %s - %s\n", BSAPIInterfaceId2Text(iId), pMessage);
          break;
        case mtWarning:
          fprintf(stderr, "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(stderr, pMessage, ap);
        fprintf(stderr, "\n");
        va_end(ap);
      }
    }
    
    void SetVerbose(bool verbose) {mVerbose = verbose;}
  
  protected:
    bool mVerbose;
} gErrorHandler;

void help()
{ 
  puts("\n Language identification                                        ");
  printf(" %s\n", BSAPIVersion());
  puts(" ================================================================ ");
  puts("                                                                  ");
  puts(" USAGE: lid [options]                                             ");
  puts("                                                                  ");
  puts(" system configuration:                                            ");
  puts("   -c file         configuration file                             ");
  puts("   -m dir          model directory                                ");
  puts("   -a str1,str2... active languages                               ");
  puts("                                                                  ");
  puts(" input:                                                           ");
  puts("   -i file         input file                                     ");
  puts("   -l file         list of input files                            ");
  puts("   -d dir          input directory                                ");
  puts("   -e str [raw]    extension of audio files                       ");
  puts("   -w fmt [lin16]  waveform format (lin16, lin8, alaw, mulaw)     ");
  puts("   -n num [1]      number of channels in audio files              ");
  puts("   -p start,len    active waveform part (in seconds)              ");
  puts("                                                                  ");
  puts(" output:                                                          ");
  puts("   -s file         output score file                              ");
  puts("   -r              produce scores for all languages               "); 
  puts("   -u              add even the UBM score                         ");
  puts("   -v              verbose mode                                   ");
  puts("                                                                  ");
  puts(" training:                                                        ");
  puts("   -t              enable training                                ");
  puts("   -g str          name of language to be trained                 ");
  puts("                                                                  ");
}

// This function outputs the winning language or scores for all of them
bool DumpScore(char *pInputName, SLIDI *plid, bool dumpAllScores, bool addUBMScore, FILE *pFileHandle)
{
  // Dump scores for all languages. 
  // The line format is: input_file_name score1 score2 ... scoreN
  // In addition, the first line will contain names of all languages
  if(dumpAllScores)
  {
    static bool first_time = true;
    int i;
    int num;
    if(first_time)
    {

      char **pplang_names = plid->GetModelNames(&num);   // this function can return 0 in case of an error
      if(!pplang_names) 
        return false;
      if(addUBMScore)
        fprintf(pFileHandle, "UBM");      
      for(i = 1; i < num; i++)      // index 0 is reserved to universal background model
      {
        if(i == 1 && !addUBMScore)
          fprintf(pFileHandle, "%s", pplang_names[i]);
        else
          fprintf(pFileHandle, " %s", pplang_names[i]);
      }
      fprintf(pFileHandle, "\n");
      first_time = false;
    }
    float *pscores = plid->GetModelScores(&num);
    if(!pscores)
      return false;
    fprintf(pFileHandle, "%s", pInputName);
    if (plid->GetTestLength() < LID_MIN_LEN_TO_PROCESS)
    {
      if(addUBMScore)
        fprintf(pFileHandle, " -inf");
      for(i = 1; i < num; i++)                           
        fprintf(pFileHandle, " -inf");
      fprintf(pFileHandle, " %s", LID_BELOW_MIN_LEN_TEXT);
    }
    else
    {
      if(addUBMScore)
        fprintf(pFileHandle, " %f", pscores[0]);
      for(i = 1; i < num; i++)                           
        fprintf(pFileHandle, " %f", pscores[i]);
    }     
    fprintf(pFileHandle, "\n");
  }
  // Dump just the winning language
  // The line format is: input_file_name winning_language score
  else
  {
    float score;
    char *pwinning_lang = plid->GetBestModel(&score);    
    if(!pwinning_lang)
      return false;
    if (plid->GetTestLength() < LID_MIN_LEN_TO_PROCESS)
      fprintf(pFileHandle, "%s %s -inf", pInputName, LID_BELOW_MIN_LEN_TEXT);
    else
      fprintf(pFileHandle, "%s %s %f", pInputName, pwinning_lang, score);
    fprintf(pFileHandle, "\n");
  }
  return true;
}

bool DirectoryExists(const char *pPath)
{
  DIR *pdir = opendir(pPath);
  if (!pdir)
    return false;

  closedir(pdir);
  return true;
}

int main(int argc, char *argv[])
{
  // initial configuration variables
  char *pconfig_file   = 0;
  char *pmodel_dir     = 0;
  char *pinput_file    = 0;
  char *plist_file     = 0;
  char *pinput_dir     = 0;
  char *pwave_fmt      = "lin16";
  char *pwave_ext      = "raw";
  char *poutput_file   = 0;
  char *plang_name     = 0;
  char *pactive_langs  = 0;
  int  nchannels       = 1;  
  bool training_mode   = false;
  bool dump_all_scores = false;
  bool add_ubm_score   = false;
  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:m:i:l:d:e:n:w:s:a:o:trvg:up:"));
    if(c == -1)
      break;

    switch(c)
    {
      case 'c':
        pconfig_file = optarg;
        break;
      case 'm':
        pmodel_dir = optarg;
        break;
      case 'i':
        pinput_file = optarg;
        break;
      case 'l':
        plist_file = optarg;
        break;
      case 'd':
        pinput_dir = optarg;
        break;
      case 'w':
        pwave_fmt = optarg;
        break;
      case 'e':
        pwave_ext = 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 's':
        poutput_file = optarg;
        break;
      case 'v':
        gErrorHandler.SetVerbose(true);
        break;
      case 't':
        training_mode = true;
        break;     
      case 'r':
        dump_all_scores = true;
        break;
      case 'u':
        add_ubm_score = true;
        break;
      case 'g':
        plang_name = optarg;
        break;
      case 'a':
        pactive_langs = optarg;
        break;
      case 'p':
        if(sscanf(optarg, "%f,%f", &acwf_start, &acwf_len) != 2)
        {
          fprintf(stderr, "ERROR: Can not parse active waveform part '%s'\n", optarg);
          return 1;
        }
        break;
      case '?':
        fprintf(stderr, "ERROR: Command line parsing error.\n");
        return 1;
    }
  }

  // register license file for SLIDI
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }
  
  // ask for an instance of language identification system
  SLIDI *plid = static_cast<SLIDI *>(BSAPICreateInstance(SIID_LID));
  if(!plid)
  {
    return 1;
  }

  // tell the instance where to send error messages
  plid->SetErrorHandler(&gErrorHandler);
  
  // read configuration file and configure the instance
  char pdefault_cfg[1024];
  sprintf(pdefault_cfg, "settings%ssigmodelling", DIRSEP);  // Visual C does not have snprintf
  if(!plid->Init((pconfig_file ? pconfig_file : pdefault_cfg)))
  {
    plid->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.
  SWaveformFormatConvertorI *pwc = plid->GetWaveformFormatConvertor();
  if (pwc)
  {
    pwc->SetNChannels(nchannels);
    pwc->SetInputFormatStr(pwave_fmt);
  }

  // Train language models. 
  // There are more possibilities of input: memory block, file, list of files, directory.
  // The training mode is enabled when one of AddXXX functions is entred first time.
  // There is possibility to train multiple languages together. This could be requested in future for discriminative training.
  if(training_mode)
  {
    // Set a directory saving models of languages.
    // If it is not set, a default one (pre-set in config file) is used.
    if(pmodel_dir && !plid->SetModelDirectory(pmodel_dir))
    {
      plid->Release();
      return 1;
    }

    // verify that we have the language name
    if((pinput_file || pinput_dir) && !plang_name)
    {
      fprintf(stderr, "ERROR: Training using one file or directory without knowing language name. Please set -g language\n");
      plid->Release();
      return 1;
    }

    // Get number of requested training iterations. This will return value one very likly, but the iterative
    // training procedure was chosen for the API to allow more difficult (discriminative) training procedures.
    // in future.
    int nreq_iters = plid->GetNRequestedTrainingIters();

    int i;
    for(i = 0; i < nreq_iters; i++)
    {

      // it is not necessary to call StartTrainingIteration if all the signal modelling subsystems 
      // are known to request just one iteration
      if(!plid->StartTrainingIteration())
      {
        plid->Release();
        return 1;
      }

      // the input is one file
      if(pinput_file && !plid->AddFile(plang_name, pinput_file))
      {
        plid->Release();
        return 1;
      }
      
      // The input is listfile. Each line of the file has two columns - language name and waveform file.
      // The list can be also in memory (AddFilesFromMemList).
      if(plist_file && !plid->AddFilesFromListFile(plist_file))
      {
        plid->Release();
        return 1;
      }

      // the input is directory
      if(pinput_dir && !plid->AddFilesFromDirectory(plang_name, pinput_dir, pwave_ext))
      {
        plid->Release();
        return 1;
      }
    }

    // It is enough to call FinishTraining when all speech files/segments are added.
    // The system will estimate new models. The models are ready to use in the current instance
    // and also saved to the actual model directory for next use.
    if(!plid->FinishTraining())
    {
      plid->Release();
      return 1;
    }

    if (plang_name && (plid->GetTrainingLength(plang_name) < LID_MIN_LEN_TO_PROCESS))
    {
      fprintf(stderr, "WARNING: Training record(s) contain only %.3f seconds of speech. "
        "At least %f seconds are needed to obtain significant results.\n",
        plid->GetTrainingLength(plang_name), LID_MIN_LEN_TO_PROCESS);
    }
  }
  else
  {
    // Scoring files.

    if (pmodel_dir && !DirectoryExists(pmodel_dir))
    {
      fprintf(stderr, "ERROR: Model directory '%s' does not exist.\n", pmodel_dir);
      plid->Release();
      return 1;
    }

    // Set a directory from which language models will be loaded.
    // If it is not set, a default one (pre-set in config file) is used.
    if(pmodel_dir && !plid->SetModelDirectory(pmodel_dir))
    {
      plid->Release();
      return 1;
    }

    // Set active waveform part. This can significantlu speed up identification if the records are long.
    if(!plid->SetActiveWaveformPart(acwf_start, acwf_len))
    {
      plid->Release();
      return 1;
    }

    // It is necesary to activate some or all models before scoring.
    if(pactive_langs)
      plid->ActivateModels(pactive_langs);
    else
      plid->ActivateAllModels();

    // Just one speech file or memory block can be scored. But the library have another possibilities to simplify 
    // processing of listfiles and directories

    // open output file
    FILE *pf_out = stdout;
    if(poutput_file)
    {
      pf_out = fopen(poutput_file, "w");
      if(!pf_out)
      {
        fprintf(stderr, "ERROR: Can not open output score file '%s'.", poutput_file);
        plid->Release();
        return 1;
      }
    }

    // the input is one file
    if(pinput_file)
    {
      gErrorHandler.LogMessage("Processing file: %s", pinput_file);
      if(!plid->TestFile(pinput_file))
      {
        plid->Release();
        return 1;
      }
      DumpScore(pinput_file, plid, dump_all_scores, add_ubm_score, pf_out);
    }

    // the input is listfile
    if(plist_file)
    {
      SFileListI *plist = static_cast<SFileListI *>(BSAPICreateInstance(SIID_FILELIST));
      if(!plist)
      {
        fprintf(stderr, "Memory allocation error.");
        plid->Release();
        return 1;
      }
      plist->SetErrorHandler(&gErrorHandler);
      if(!plist->AddList(plist_file))
      {
        plist->Release();
        plid->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);
        if(!plid->TestFile(psource))
        {
          plist->Release();
          plid->Release();
          return 1;
        }
        DumpScore(psource, plid, dump_all_scores, add_ubm_score, pf_out);
      }
      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.");
        plid->Release();
        return 1;
      }
      psniffer->SetErrorHandler(&gErrorHandler);
      psniffer->AddDirectory(pinput_dir);
      psniffer->AddWantedSuffix(pwave_ext);

      if(!psniffer->FirstFile())
      {
        psniffer->Release();
        plid->Release();
        return 1;
      }
      
      char psource[1024];
      while(psniffer->GetFile(psource, sizeof(psource) - 1))
      {
        gErrorHandler.LogMessage("Processing file: %s", psource);
        if(!plid->TestFile(psource))
        {
          psniffer->Release();
          plid->Release();
          return 1;
        }
        DumpScore(psource, plid, dump_all_scores, add_ubm_score, pf_out);
      }
      psniffer->Release();
    }

    // close output file
    if(pf_out != stdout)
      fclose(pf_out);
  }

  // release the LID instance
  plid->Release();

  return 0;
}

---