lid.cpp

This example shows how to use the SLID2I interface.

/*****************************************************************
 *  BSAPI Language Identification Example                        *
 *                                                               *
 *  Author      : Petr Schwarz, Pavel Matejka, Tomas Cipr        *
 *  Copyright   : (C) 2006-2011 by Phonexia s.r.o                *
 *                                                               *
 *  For more info, please contact us at support@phonexia.com     *
 *****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <assert.h>
#include <new>

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

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

// compile time program options
#define LID_MIN_LEN_TO_PROCESS    2.0f       // 2 seconds
#define LID_BELOW_MIN_LEN_TEXT    "(too_short)"
#define LID_MAX_WEIGHTS           64
#define LID_OUT_COLUMN_CHARS      "snlr"

// default option values
#define LID_DEF_WAVE_FMT          "lin16"
#define LID_DEF_WAVE_EXT          "raw"
#define LID_DEF_NCHANNELS         1

// 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(SUnknownI *pSender, message_type type, unsigned int messageId, const char *pMessage)
    {
      unsigned int iid = pSender ? pSender->GetIID() : SIID_UNDEFINED;
      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: lid2 [options]                                             ");
  puts("                                                                  ");
  puts(" system configuration:                                            ");
  puts("   -c file         configuration file                             ");
  puts("   -m dir          model directory                                ");
  puts("   -a str1,str2... active languages                               ");
  puts("   -v              verbose mode                                   ");
  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("   -o              suppress the 'too short' output                ");
  puts("   -r              produce scores for all languages               ");
  puts("   -u              add even the UBM score                         ");
  puts("   -k columns      enable column output format (see columns)      ");
  puts("                                                                  ");
  puts(" columns:          (columns to print are specified by string of   ");
  puts("                    the characters below, e.g. lsn)               ");
  puts("    s              raw score                                      ");
  puts("    n              score normalized to <0, 100>                   ");
  puts("    l              speech length                                  ");
  puts("    r              record length                                  ");
  puts("                                                                  "); 
  puts(" training:                                                        ");
  puts("   -t              enable training                                ");
  puts("   -g str          name of language to be trained                 ");
  puts("                                                                  ");
}

// The line format is: input_file_name language [optional columns]
void DumpColWise(FILE *pFileHandle, const char *pInputName, char **ppNames, float *pScores, int nModels, 
  float recordLength, float speechLength, const char *pColumnFmt, bool ubmPresent, bool suppressTooShort)
{
  for (int i = 0; i < nModels; i++)
  {
    fprintf(pFileHandle, "%s %s", pInputName, ppNames[i]);
    for (const char *pc = pColumnFmt; *pc != '\0'; pc++)
    {
      switch (*pc)
      {
        case 's':
          if (speechLength < LID_MIN_LEN_TO_PROCESS && !suppressTooShort)
            fprintf(pFileHandle, " -inf");
          else
            fprintf(pFileHandle, " %.3f", pScores[i]);
          break;
          
        case 'n':
          if (speechLength < LID_MIN_LEN_TO_PROCESS && !suppressTooShort)
            fprintf(pFileHandle, " 0.000");
          else
            fprintf(pFileHandle, " %.3f", (i == 0 && ubmPresent) ? pScores[i] : expf(pScores[i]) * 100.0f);
          break;
          
        case 'l':
          fprintf(pFileHandle, " %.3f", speechLength);
          break;
          
        case 'r':
          fprintf(pFileHandle, " %.3f", recordLength);
          break;
      }
    }
    
    if (speechLength < LID_MIN_LEN_TO_PROCESS && !suppressTooShort)
      fprintf(pFileHandle, " %s", LID_BELOW_MIN_LEN_TEXT);
    
    fprintf(pFileHandle, "\n");
  }
}

// The line format is: input_file_name score1 score2 ... scoreN
// In addition, the first line will contain names of all languages
void DumpRowWise(FILE *pFileHandle, const char *pInputName, char **ppNames, float *pScores, int nModels, 
  float speechLength, bool suppressTooShort)
{
  static bool first_time = true;
  
  if (first_time)
  {
    if (nModels > 0)
      fprintf(pFileHandle, "%s", ppNames[0]);
    for (int i = 1; i < nModels; i++)
      fprintf(pFileHandle, " %s", ppNames[i]);
    fprintf(pFileHandle, "\n");
    first_time = false;
  }

  fprintf(pFileHandle, "%s", pInputName);
  for (int i = 0; i < nModels; i++)
  {
    if (speechLength < LID_MIN_LEN_TO_PROCESS && !suppressTooShort)
      fprintf(pFileHandle, " -inf");
    else
      fprintf(pFileHandle, " %.3f", pScores[i]);
  }
  
  if (speechLength < LID_MIN_LEN_TO_PROCESS && !suppressTooShort)
    fprintf(pFileHandle, " %s", LID_BELOW_MIN_LEN_TEXT);
    
  fprintf(pFileHandle, "\n");
}

// This function outputs the winning language or scores for all of them
bool DumpScore(FILE *pFileHandle, const char *pInputName, SScoresI *pScores, bool dumpAllScores, 
  const char *pColumnFmt, bool addUBMScore, bool suppressTooShort)
{
  float speech_length = pScores->GetTestLength();
  float record_length = 0.0f;
  
  if (dumpAllScores)
  {
    int num = pScores->GetNScores();
    char **ppnames = addUBMScore ? pScores->GetExtendedNames() : pScores->GetNames();
    float *pscores = addUBMScore ? pScores->GetExtendedScores() : pScores->GetScores();

    // the functions above can return 0 in case of an error
    if (!ppnames || !pscores) 
      return false;

    if (addUBMScore)
      num++;

    // 0th array element is for UBM
    if (pColumnFmt)
    {
      DumpColWise(pFileHandle, pInputName, ppnames, pscores, num, record_length, 
        speech_length, pColumnFmt, addUBMScore, suppressTooShort);
    }
    else
    {
      DumpRowWise(pFileHandle, pInputName, ppnames, pscores, num, speech_length, suppressTooShort);
    }
  }
  else
  {
    float score;
    char *pname = pScores->GetBestName(&score);

    if (!pname) 
      return false;
    
    DumpColWise(pFileHandle, pInputName, &pname, &score, 1, record_length, 
      speech_length, (pColumnFmt ? pColumnFmt : "s"), !strcmp(pname, "other"), suppressTooShort);
  }
  
  return true;
}

#ifdef PROCESS_WAVEFORM 
char *LoadFileToMem(const char *pFile, int *pLen)
{
  // open the file
  FILE *pf;
  pf = fopen(pFile, "rb");
  if(!pf) 
    return 0;

  // get file length
  fseek(pf, 0, SEEK_END);
  size_t size = ftell(pf);
  rewind(pf);

  if(pLen)
    *pLen = static_cast<int>(size);

  char *pbuffer = new (std::nothrow) char [size + 1];
  if(!pbuffer) 
  {
    fclose(pf);
    return 0;
  }

  size_t nbytes = fread(pbuffer, 1, size, pf);
  if(nbytes != size) 
  {
    fclose(pf);
    delete [] pbuffer;
    return 0;
  }
  fclose(pf);
  pbuffer[size] = '\0';
  return pbuffer;
}
#endif

int main(int argc, char *argv[])
{
  // initial configuration variables
  const char *pconfig_file   = 0;
  const char *pmodel_dir     = 0;
  const char *pinput_file    = 0;
  const char *plist_file     = 0;
  const char *pinput_dir     = 0;
  const char *pwave_fmt      = LID_DEF_WAVE_FMT;
  const char *pwave_ext      = LID_DEF_WAVE_EXT;
  const char *poutput_file   = 0;
  const char *pcolumn_fmt    = 0;
  const char *plang_name     = 0;
  const char *pactive_langs  = 0;
  int  nchannels             = LID_DEF_NCHANNELS;
  bool training_mode         = false;
  bool dump_all_scores       = false;
  bool add_ubm_score         = false;
  bool supp_too_short        = 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:otrvg:uk:p:"));
    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 'o':
        supp_too_short = true;
        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 'k':
        pcolumn_fmt = optarg;
        if (strspn(pcolumn_fmt, LID_OUT_COLUMN_CHARS) != strlen(pcolumn_fmt))
        {
          fprintf(stderr, "ERROR: Wrong format of output columns string. "
          "The set of allowed characters is '%s'.\n", LID_OUT_COLUMN_CHARS);
          return 1;
        }
        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;
      default :
        fprintf(stderr, "ERROR: Command line parsing error. Unexpected argument '%s'.\n", optarg);
        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
  SLID2I *plid = static_cast<SLID2I *>(BSAPICreateInstance(SIID_LID2));
  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;
      }

#ifdef PROCESS_WAVEFORM
      // This is for demonstration purposes only! MS WAVE files can not
      // be processed correctly in this simplified case because AddWaveform()
      // accepts raw waveform data only (without any header)!
      if(pinput_file)
      {
        int nbytes = 0;
        char *pwaveform = LoadFileToMem(pinput_file, &nbytes);
        if(!pwaveform)
        {
          plid->Release();
          return 1;
        }
        
        bool result = plid->AddWaveform(plang_name, pwaveform, nbytes);
        delete [] pwaveform;
        if(!result)
        {
          plid->Release();
          return 1;
        }
      }
#else
      // the input is one file
      if(pinput_file && !plid->AddFile(plang_name, pinput_file))
      {
        plid->Release();
        return 1;
      }
#endif
      
      // 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.

    // By default, the scores are sent from the speaker identification system using a callback function.
    // It is possible to attach a score memory that remembers the last scores and enables to access them any time
    // by the GetScores function.
    SScoreMemoryI *pscore_mem = static_cast<SScoreMemoryI *>(BSAPICreateInstance(SIID_SCOREMEMORY));
    if(!pscore_mem)
    {
      plid->Release();
      return 1;
    }
    pscore_mem->SetErrorHandler(&gErrorHandler);
    plid->SetTarget(pscore_mem);

    // 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();
      pscore_mem->Release();
      return 1;
    }

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

    // It is necesary to activate some or all models before scoring.
    if(pactive_langs)
    {
      if (!plid->ActivateModels(pactive_langs))
      {
        plid->Release();
        pscore_mem->Release();
        return 1;
      }
    }
    else
    {
      if (!plid->ActivateAllModels())
      {
        plid->Release();
        pscore_mem->Release();
        return 1;
      }
    }
    
    // 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();
        pscore_mem->Release();
        return 1;
      }
    }

    // the input is one file
    if(pinput_file)
    {
      gErrorHandler.LogMessage("Processing file: %s", pinput_file);
#ifdef PROCESS_WAVEFORM
      // This is for demonstration purposes only! MS WAVE files can not
      // be processed correctly in this simplified case because TestWaveform()
      // accepts raw waveform data only (without any header)!
      int nbytes = 0;
      char *pwaveform = LoadFileToMem(pinput_file, &nbytes);
      if(!pwaveform)
      {
        plid->Release();
        pscore_mem->Release();
        return 1;
      }

      bool result = plid->TestWaveform(pwaveform, nbytes);
      delete [] pwaveform;
      if(!result)
#else
      if(!plid->TestFile(pinput_file))
#endif
      {
        plid->Release();
        pscore_mem->Release();
        return 1;
      }
      if(!pscore_mem->Empty())
        DumpScore(pf_out, pinput_file, pscore_mem->GetScores(), dump_all_scores, pcolumn_fmt, add_ubm_score, supp_too_short);
    }

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

      if(!psniffer->FirstFile())
      {
        psniffer->Release();
        plid->Release();
        pscore_mem->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();
          pscore_mem->Release();
          return 1;
        }
        if(!pscore_mem->Empty())
          DumpScore(pf_out, psource, pscore_mem->GetScores(), dump_all_scores, pcolumn_fmt, add_ubm_score, supp_too_short);
      }
      psniffer->Release();
    }

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

    pscore_mem->Release();
  }

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

  return 0;
}

---