sid.cpp

This example shows how to use the SSpeakerID2I interface.

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

#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   1.0f

// This is an error handling object. If an error occurs, 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 accepts 
// 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 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("   -k file          use calibration file                          ");
  puts("                                                                  ");
  puts(" training:                                                        ");
  puts("   -t               enable training                               ");
  puts("   -g str           name of the speaker to be trained             ");
  puts("                                                                  ");
  puts(" calibration estimation:                                          ");
  puts("   -y file          make calibration file                         ");
  puts("                                                                  ");
  puts(" output:                                                          ");
  puts("   -s file          output score file                             ");
  puts("   -u               suppress the 'too short' output               ");
  puts("   -r               produce scores for all speakers               "); 
  puts("   -f columns       enable column output format (see columns)     ");
  puts("   -z num [1.0]     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, bool suppressTooShort)
{
  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 && !suppressTooShort)
            fprintf(pFileHandle, " -inf");
          else
            fprintf(pFileHandle, " %.3f", pScores[i]);
          break;
          
        case 'n':
          if (speechLength < SID_MIN_LEN_TO_PROCESS && !suppressTooShort)
            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 && !suppressTooShort)
      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, bool suppressTooShort)
{
  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 && !suppressTooShort)
      fprintf(pFileHandle, " 0.000");
    else
      fprintf(pFileHandle, " %.3f", RescaleScore(pScores[i], sharpness));
  }
  
  if (speechLength < SID_MIN_LEN_TO_PROCESS && !suppressTooShort)
    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, SScoresI *pScores, bool dumpAllScores, 
  const char *pColumnFmt, float sharpness, FILE *pFileHandle, bool suppressTooShort)
{
  /* !!! this should be moved to scores
  SWaveformFormatConvertorI *pwfconv = psid->GetWaveformFormatConvertor();
  if (!pwfconv)
    return false;
  */

  float speech_length = pScores->GetTestLength();
  float record_length = 0;
 
  
  if (dumpAllScores)
  {
    int num = pScores->GetNScores();
    char **ppnames = pScores->GetNames();
    float *pscores = pScores->GetScores();

    // 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, pscores, num, record_length, 
        speech_length, sharpness, pColumnFmt, pFileHandle, suppressTooShort);
    }
    else
    {
      DumpRowWise(pInputName, ppnames, pscores, num, speech_length, 
        sharpness, pFileHandle, suppressTooShort);
    }
  }
  else
  {
    float score = 0.0f;
    char *pname = pScores->GetBestName(&score);
    
    if (!pname) 
      return false;
    
    DumpColWise(pInputName, &pname, &score, 1, record_length, 
      speech_length, sharpness, (pColumnFmt ? pColumnFmt : "n"), pFileHandle, 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        = SID_DEF_WAVE_FMT;
  const char *pwave_ext        = SID_DEF_WAVE_EXT;
  const char *poutput_file     = 0;
  const char *pcolumn_fmt      = 0;
  const char *pspeaker_name    = 0;
  const char *pactive_speakers = 0;
  const char *pin_calib_file   = 0;
  const char *pout_calib_file  = 0;
  bool training_mode           = false;
  bool dump_all_scores         = false;
  int  nchannels               = SID_DEF_NCHANNELS;
  float sharpness              = SID_DEF_SCORE_SHARPNESS;
  float acwf_start             = 0;
  float acwf_len               = 0;
  bool supp_too_short          = false;

  // 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:k:y:p:z:u"));
    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 'u':
        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 '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 'k':
        pin_calib_file = optarg;
        break;
      case 'y':
        pout_calib_file = 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 SSpeakerID2I
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }

  // ask for an instance of speaker identification system
  SSpeakerID2I *psid = static_cast<SSpeakerID2I *>(BSAPICreateInstance(SIID_SPKID2));
  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);
  }
  
  // Get calibration object if the calibration is turned on
  SUserCalibrationI *pcalib = 0;
  if (pin_calib_file || pout_calib_file)
  {
    SBlockSetI *pbset = psid->GetBlockSet();
    if(!pbset)
    {
      psid->Release();
      return 1;
    }
  
    pcalib = static_cast<SUserCalibrationI *>(pbset->GetBlock("user_calibration"));
    if(!pcalib)
    {
      psid->Release();
      return 1;
    }
  }

  // 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;
    }

    // load calibration parameters if requested
    if (pin_calib_file)
    {
      assert(pcalib);
      pcalib->SetEnabled(true);
      if (!pcalib->Load(pin_calib_file))
      {
        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;
      }

#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)
        {
          psid->Release();
          return 1;
        }
        
        bool result = psid->AddWaveform(pspeaker_name, pwaveform, nbytes);
        delete [] pwaveform;
        if(!result)
        {
          psid->Release();
          return 1;
        }
      }
#else
      // the input is one file
      if(pinput_file && !psid->AddFile(pspeaker_name, pinput_file))
      {
        psid->Release();
        return 1;
      }
#endif

      // 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) && !supp_too_short)
    {
      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 if (pout_calib_file)
  {
    assert(pcalib);

    // Start calibration estimation
    pcalib->StartEstimation();

    // 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;
    }

    // the input is one file
    if(pinput_file)
    {
      gErrorHandler.LogMessage("Processing file: %s", pinput_file);
      fprintf(stderr, "WARNING: Calibration estimated on just one file is not significant.\n");
      if(!psid->TestFile(pinput_file))
      {
        psid->Release();
        return 1;
      }
    }

    // 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;
        }
      }
      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;
        }
      }
      psniffer->Release();
    }

    // All files has been processed, end calibration estimation
    pcalib->EndEstimation();

    // Save calibration parameters
    if (!pcalib->Save(pout_calib_file))
    {
      psid->Release();
      return 1;
    }
  }
  else
  {
    // Scoring files.

    // By default, the scores are sent from the speaker identification system using a callback function.
    // It is possible 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)
    {
      psid->Release();
      return 1;
    }
    pscore_mem->SetErrorHandler(&gErrorHandler);
    psid->SetTarget(pscore_mem);

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

    // It is necesary to activate some or all models before scoring.
    if(pactive_speakers)
    {
      if (!psid->ActivateModels(pactive_speakers))
      {
        psid->Release();
        pscore_mem->Release();
        return 1;
      }
    }
    else
    {
      if (!psid->ActivateAllModels())
      {
        psid->Release();
        pscore_mem->Release();
        return 1;
      }
    }

    // load calibration parameters if requested
    if (pin_calib_file)
    {
      assert(pcalib);
      pcalib->SetEnabled(true);
      if (!pcalib->Load(pin_calib_file))
      {
        psid->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);
        psid->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)
      {
        psid->Release();
        pscore_mem->Release();
        return 1;
      }

      bool result = psid->TestWaveform(pwaveform, nbytes);
      delete [] pwaveform;
      if(!result)
#else
      if(!psid->TestFile(pinput_file))
#endif
      {
        psid->Release();
        pscore_mem->Release();
        return 1;
      }
      if(!pscore_mem->Empty())
        DumpScore(pinput_file, pscore_mem->GetScores(), dump_all_scores, pcolumn_fmt, sharpness, pf_out, 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.");
        psid->Release();
        pscore_mem->Release();
        return 1;
      }
      plist->SetErrorHandler(&gErrorHandler);
      if(!plist->AddList(plist_file))
      {
        plist->Release();
        psid->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(!psid->TestFile(psource))
        {
          plist->Release();
          psid->Release();
          pscore_mem->Release();
          return 1;
        }
        if(!pscore_mem->Empty())
          DumpScore(psource, pscore_mem->GetScores(), dump_all_scores, pcolumn_fmt, sharpness, pf_out, 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.");
        psid->Release();
        pscore_mem->Release();
        return 1;
      }
      psniffer->SetErrorHandler(&gErrorHandler);
      psniffer->AddDirectory(pinput_dir);
      psniffer->AddWantedSuffix(pwave_ext);

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

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

    pscore_mem->Release();
  }

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

  return 0;
}

---