speaker_identification.cpp

This example shows how to use the SSpeakerIDI interface.

/*****************************************************************
 *  BSAPI Speaker 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 <stdarg.h>
#include <string.h>
#include <errno.h>
#include <math.h>

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

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

// compile time program options
#define SID_MIN_LEN_TO_PROCESS    10.0f       // 10 seconds
#define SID_BELOW_MIN_LEN_TEXT    "(too short)"
#define SID_OUT_COLUMN_CHARS      "snlr"

// default option values
#define SID_DEF_WAVE_FMT          "alaw"
#define SID_DEF_WAVE_EXT          "alw"
#define SID_DEF_NCHANNELS         1
#define SID_DEF_SCORE_SHARPNESS   0.3f

// 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 Speaker identification                                         ");
  printf(" %s\n", BSAPIVersion());
  puts(" ================================================================ ");
  puts("                                                                  ");
  puts(" USAGE: sid [options]                                             ");
  puts("                                                                  ");
  puts(" system configuration:                                            ");
  puts("   -c file          configuration file                            ");
  puts("   -m dir           model directory                               ");
  puts("   -a str1,str2...  active speaker models                         ");
  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 [alw]     extension of audio files                      ");
  puts("   -w fmt [alaw]    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(" training:                                                        ");
  puts("   -t               enable training                               ");
  puts("   -g str           name of the speaker to be trained             ");
  puts("                                                                  ");
  puts(" output:                                                          ");
  puts("   -s file          output score file                             ");
  puts("   -r               produce scores for all speakers               "); 
  puts("   -f columns       enable column output format (see columns)     ");
  puts("   -z num [0.3]     score sharpness (positive number)             ");
  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("                                                                  "); 
}

inline float RescaleScore(float score, float scale = 1.0f)
{
  return (100.0f / (1.0f + expf(-(scale * score))));
}

// The line format is: input_file_name speaker [optional columns]
void DumpColWise(const char *pInputName, char **ppNames, float *pScores, int nSpeakers, 
  float recordLength, float speechLength, float sharpness, const char *pColumnFmt, FILE *pFileHandle)
{
  for (int i = 0; i < nSpeakers; i++)
  {
    fprintf(pFileHandle, "%s %s", pInputName, ppNames[i]);
    for (const char *pc = pColumnFmt; *pc != '\0'; pc++)
    {
      switch (*pc)
      {
        case 's':
          if (speechLength < SID_MIN_LEN_TO_PROCESS)
            fprintf(pFileHandle, " -inf");
          else
            fprintf(pFileHandle, " %.3f", pScores[i]);
          break;
          
        case 'n':
          if (speechLength < SID_MIN_LEN_TO_PROCESS)
            fprintf(pFileHandle, " 0.000");
          else
            fprintf(pFileHandle, " %.3f", RescaleScore(pScores[i], sharpness));
          break;
          
        case 'l':
          fprintf(pFileHandle, " %.3f", speechLength);
          break;
          
        case 'r':
          fprintf(pFileHandle, " %.3f", recordLength);
          break;
      }
    }
    
    if (speechLength < SID_MIN_LEN_TO_PROCESS)
      fprintf(pFileHandle, " %s", SID_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 speakers
void DumpRowWise(const char *pInputName, char **ppNames, float *pScores, int nSpeakers, 
  float speechLength, float sharpness, FILE *pFileHandle)
{
  static bool first_time = true;
  
  if (first_time)
  {
    if (nSpeakers > 0)
      fprintf(pFileHandle, "%s", ppNames[0]);
    for (int i = 1; i < nSpeakers; i++)
      fprintf(pFileHandle, " %s", ppNames[i]);
    fprintf(pFileHandle, "\n");
    first_time = false;
  }

  fprintf(pFileHandle, "%s", pInputName);
  for (int i = 0; i < nSpeakers; i++)
  {
    if (speechLength < SID_MIN_LEN_TO_PROCESS)
      fprintf(pFileHandle, " 0.000");
    else
      fprintf(pFileHandle, " %.3f", RescaleScore(pScores[i], sharpness));
  }
  
  if (speechLength < SID_MIN_LEN_TO_PROCESS)
    fprintf(pFileHandle, " %s", SID_BELOW_MIN_LEN_TEXT);
    
  fprintf(pFileHandle, "\n");
}

// This function outputs the winning speaker or scores for all of them
bool DumpScore(const char *pInputName, SSpeakerIDI *psid, bool dumpAllScores, 
  const char *pColumnFmt, float sharpness, FILE *pFileHandle)
{
  SWaveformFormatConvertorI *pwfconv = psid->GetWaveformFormatConvertor();
  if (!pwfconv)
    return false;
 
  float speech_length = psid->GetTestLength();
  float record_length = pwfconv->GetInputLength(); 
  
  if (dumpAllScores)
  {
    int num = 0;
    char **ppnames = psid->GetModelNames(&num);
    float *pscores = psid->GetModelScores(&num);
    
    // the functions above can return 0 in case of an error
    if (!ppnames || !pscores) 
      return false;
    
    // 0th array element is for UBM, skip it
    if (pColumnFmt)
    {
      DumpColWise(pInputName, ppnames + 1, pscores + 1, num - 1, record_length, 
        speech_length, sharpness, pColumnFmt, pFileHandle);
    }
    else
    {
      DumpRowWise(pInputName, ppnames + 1, pscores + 1, num - 1, speech_length, 
        sharpness, pFileHandle);
    }
  }
  else
  {
    float score = 0.0f;
    char *pname = psid->GetBestModel(&score);
    
    if (!pname) 
      return false;
    
    DumpColWise(pInputName, &pname, &score, 1, record_length, 
      speech_length, sharpness, (pColumnFmt ? pColumnFmt : "n"), pFileHandle);
  }
  
  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      = SID_DEF_WAVE_FMT;
  char *pwave_ext      = SID_DEF_WAVE_EXT;
  char *poutput_file   = 0;
  char *pcolumn_fmt    = 0;
  char *pspeaker_name  = 0;
  char *pactive_speakers = 0;
  int  nchannels       = SID_DEF_NCHANNELS;  
  bool training_mode   = false;
  bool dump_all_scores = false;
  float sharpness      = SID_DEF_SCORE_SHARPNESS;
  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:trf:vg:p:z:"));
    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 'f':
        pcolumn_fmt = optarg;
        if (strspn(pcolumn_fmt, SID_OUT_COLUMN_CHARS) != strlen(pcolumn_fmt))
        {
          fprintf(stderr, "ERROR: Wrong format of output columns string. "
          "The set of allowed characters is '%s'.\n", SID_OUT_COLUMN_CHARS);
          return 1;
        }
        break;
      case 'z':
        if(sscanf(optarg, "%f", &sharpness) != 1)
        {
          fprintf(stderr, "ERROR: Wrong value of score sharpness '%s'. Must be positive number.\n", optarg);
          return 1;
        }
        break;
      case 'g':
        pspeaker_name = optarg;
        break;
      case 'a':
        pactive_speakers = 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 SSpeakerIDI
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }

  // ask for an instance of speaker identification system
  SSpeakerIDI *psid = static_cast<SSpeakerIDI *>(BSAPICreateInstance(SIID_SPKID));
  if(!psid)
  {
    return 1;
  }

  // tell the instance where to send error messages
  psid->SetErrorHandler(&gErrorHandler);
  
  // read configuration file and configure the instance
  char pdefault_cfg[1024];
  sprintf(pdefault_cfg, "settings%sconfig", DIRSEP);  // Visual C does not have snprintf
  if(!psid->Init((pconfig_file ? pconfig_file : pdefault_cfg)))
  {
    psid->Release();
    return 1;
  }
  
  // Set a directory saving models of speakers.
  // If it is not set, a default one (pre-set in config file) is used.
  if(pmodel_dir && !psid->SetModelDirectory(pmodel_dir))
  {
    psid->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 = psid->GetWaveformFormatConvertor();
  if (pwc)
  {
    pwc->SetNChannels(nchannels);
    pwc->SetInputFormatStr(pwave_fmt);
  }
  
  // Train speaker 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 speakers together. This could be requested in future for discriminative training.
  if(training_mode)
  {
    // verify that we have the speaker name
    if((pinput_file || pinput_dir) && !pspeaker_name)
    {
      fprintf(stderr, "ERROR: Training using one file or directory without knowing speaker name. Please set -g speaker\n");
      psid->Release();
      return 1;
    }

    // Get number of requested training iterations. This will return value one very likely, but the iterative
    // training procedure was chosen for the API to allow more difficult (discriminative) training procedures.
    // in future.
    int nreq_iters = psid->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(!psid->StartTrainingIteration())
      {
        psid->Release();
        return 1;
      }

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

      // the input is directory
      if(pinput_dir && !psid->AddFilesFromDirectory(pspeaker_name, pinput_dir, pwave_ext))
      {
        psid->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(!psid->FinishTraining())
    {
      psid->Release();
      return 1;
    }
    
    if (pspeaker_name && (psid->GetTrainingLength(pspeaker_name) < SID_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",
        psid->GetTrainingLength(pspeaker_name), SID_MIN_LEN_TO_PROCESS);
    }
  }
  else
  {
    // Scoring files.

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

    // It is necesary to activate some or all models before scoring.
    if(pactive_speakers)
      psid->ActivateModels(pactive_speakers);
    else
      psid->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);
        psid->Release();
        return 1;
      }
    }

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

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

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

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

  // release the SID instance
  psid->Release();

  return 0;
}

---