vpextract.cpp

This example shows how to use the SVoicePrintExtractorI interface for speaker identification.

/*****************************************************************
 *  BSAPI Voice-print Extractor Example                          *
 *                                                               *
 *  Author      : Petr Schwarz, Pavel Matejka, Tomas Cipr        *
 *  Copyright   : (C) 2006-2012 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 "bsapi.h"
#include "getopt.h"

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

// default option values
#define SID_DEF_IN_DATA_TYPE      "waveform"
#define SID_DEF_WAVE_FMT          "lin16"
#define SID_DEF_WAVE_EXT          "raw"
#define SID_DEF_FEA_FMT           "htk"
#define SID_DEF_NCHANNELS         1
#define SID_DEF_VPRINT_EXT        "vp"

// 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 Voice-print extractor                                          ");
  printf(" %s\n", BSAPIVersion());
  puts(" ================================================================ ");
  puts("                                                                  ");
  puts(" USAGE: vpextract [options]                                       ");
  puts("                                                                  ");
  puts(" system configuration:                                            ");
  puts("   -c file           configuration file                           ");
  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 input files                     ");
  puts("   -s str [waveform] input data type (waveform, features)         ");
  puts("   -k file           use calibration file                         ");
  puts("                                                                  ");
  puts(" input data type = waveform:                                      ");
  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(" input data type = features:                                      ");
  puts("   -f fmt [htk]      feature format (ascii, binary, htk)          ");
  puts("                                                                  ");
  puts(" output:                                                          ");
  puts("   -o file           output file                                  ");
  puts("   -h dir            output directory                             ");
  puts("   -x str [vp]       extension of voice-print files               ");
  puts("   -y file           make calibration file instead of voice-prints");
  puts("                                                                  ");
  puts(" diarization options:                                             ");
  puts("   -t num            total number of speakers                     ");
  puts("   -m num [6]        maximal number of speakers                   ");
  puts("   -a num [0.75]     constant sets the number of speakers         ");
  puts("                                                                  ");
}

int main(int argc, char *argv[])
{
  // initial configuration variables
  const char *pconfig_file      = "settings/extract.bs";
  const char *pinput_file       = 0;
  const char *plist_file        = 0;
  const char *pinput_dir        = 0;
  const char *pin_data_type     = SID_DEF_IN_DATA_TYPE;
  const char *pwave_fmt         = SID_DEF_WAVE_FMT;
  const char *pwave_ext         = SID_DEF_WAVE_EXT;
  const char *pfea_fmt          = SID_DEF_FEA_FMT;
  const char *poutput_file      = 0;
  const char *poutput_dir       = 0;
  const char *pvprint_ext       = SID_DEF_VPRINT_EXT;
  const char *pin_calib_file    = 0;
  const char *pout_calib_file   = 0;
  int nchannels                 = SID_DEF_NCHANNELS;
  int total_speakers            = 0;
  int max_speakers              = 0;
  float acwf_start              = 0.0f;
  float acwf_len                = 0.0f;
  float max_avg_distance        = 0.0f;

  // 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:s:e:w:n:p:f:o:h:x:k:y:t:m:a: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 's':
        pin_data_type = 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 '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 'f':
        pfea_fmt = optarg;
        break;
      case 'o':
        poutput_file = optarg;
        break;
      case 'h':
        poutput_dir = optarg;
        break;
      case 'v':
        gErrorHandler.SetVerbose(true);
        break;
      case 'x':
        pvprint_ext = optarg;
        break;
      case 'k':
        pin_calib_file = optarg;
        break;
      case 'y':
        pout_calib_file = optarg;
        break;
      case 't':
        if(sscanf(optarg, "%d", &total_speakers) != 1 || total_speakers < 0)
        {
          fprintf(stderr, "ERROR: Invalid total number of speakers '%s'. "
                          "Must be positive integer or 0.\n", optarg);
          return 1;
        }
        break;
      case 'm':
        if(sscanf(optarg, "%d", &max_speakers) != 1 || max_speakers < 0)
        {
          fprintf(stderr, "ERROR: Invalid maximal number of speakers '%s'. "
                          "Must be positive integer or 0.\n", optarg);
          return 1;
        }
        break;
      case 'a':
        if(sscanf(optarg, "%f", &max_avg_distance) != 1 || max_avg_distance < 0)
        {
          fprintf(stderr, "ERROR: Invalid constant sets the number of speakers  '%s'. "
                          "Must be positive floating point number or 0.\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 SSpeakerIDI
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }

  // ask for an instance of voice-print extractor
  SVoicePrintExtractorI *pvp_extract = static_cast<SVoicePrintExtractorI *>(BSAPICreateInstance(SIID_VPRINTEXTRACTOR));
  if(!pvp_extract)
  {
    return 1;
  }

  // tell the instance where to send error messages
  pvp_extract->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(!pvp_extract->Init((pconfig_file ? pconfig_file : pdefault_cfg)))
  {
    pvp_extract->Release();
    return 1;
  }

  SBlockSetI *pbset = pvp_extract->GetBlockSet();
  if(!pbset)
  {
    pvp_extract->Release();
    return 1;
  }

  SWaveformFormatConvertorI *pwc = static_cast<SWaveformFormatConvertorI *>(pbset->GetBlock("waveform_convertor"));
  if(!pwc)
  {
    pvp_extract->Release();
    return 1;
  }

  pwc->SetNChannels(nchannels);
  if (!pwc->SetInputFormatStr(pwave_fmt))
  {
    pvp_extract->Release();
    return 1;
  }

  if(pbset->Exists("feature_source"))
  {
    SFeatureSourceI *pfeature_source = static_cast<SFeatureSourceI *>(pbset->GetBlock("feature_source"));
    if(!pfeature_source)
    {
      pvp_extract->Release();
      return 1;
    }

    if (!pfeature_source->SetFileFormatStr(pfea_fmt))
    {
      pvp_extract->Release();
      return 1;
    }
  }

  // set active waveform part, this can significantly speed up identification if the records are long
  if(acwf_len > 0.0f)
  {
    SActiveWaveformPartSelectorI *pacwf_sel = static_cast<SActiveWaveformPartSelectorI *>(pbset->GetBlock("param.waveform_part_selector"));
    if(!pacwf_sel)
    {
      pvp_extract->Release();
      return 1;
    }

    pacwf_sel->SetSelectionStartSec(acwf_start);
    pacwf_sel->SetSelectionLengthSec(acwf_len);
  }

  if(pbset->Exists("diar.quantizer"))
  {
    SVectorQuantizerI *pquantizer = static_cast<SVectorQuantizerI *>(pbset->GetBlock("diar.quantizer"));
    if(!pquantizer)
    {
      pvp_extract->Release();
      return 1;
    }

    if(total_speakers)   pquantizer->SetTotalClusters(total_speakers);
    if(max_avg_distance) pquantizer->SetMaxAvgDistance(max_avg_distance);
    if(max_speakers)     pquantizer->SetMaxClusters(max_speakers);
  }
  else
  {
    if(total_speakers != 0 || max_speakers != 0 || max_avg_distance != 0.0f)
      fprintf(stderr, "WARNING: Diarization options were not applied. Config file '%s' does not support diarization. \n", (pconfig_file ? pconfig_file : pdefault_cfg));
  }

  // if user calibration is turned on load calibration parameters and/or start estimation
  SUserCalibrationI *pcalib = 0;
  if(pin_calib_file || pout_calib_file)
  {
    pcalib = static_cast<SUserCalibrationI *>(pbset->GetBlock("user_calibration"));
    if(!pcalib)
    {
      pvp_extract->Release();
      return 1;
    }

    if(pout_calib_file)
    {
      pcalib->StartEstimation();
    }
    else // pin_calib_file
    {
      pcalib->SetEnabled(true);
      if(!pcalib->Load(pin_calib_file))
      {
        pvp_extract->Release();
        return 1;
      }
    }
  }

  if(!pvp_extract->SetInputDataTypeStr(pin_data_type))
  {
    pvp_extract->Release();
    return 1;
  }

  // process one file
  if(pinput_file && !pvp_extract->ProcessFile(pinput_file, poutput_file))
  {
    pvp_extract->Release();
    return 1;
  }

  // Set output directory and voice-print file suffix. In the file list, this directory is used if the output file name is not specified.
  pvp_extract->SetOutputDirectory(poutput_dir);
  pvp_extract->SetWaveformFileSuffix(pwave_ext);
  pvp_extract->SetVoicePrintFileSuffix(pvprint_ext);


  // process list of files
  if(plist_file && !pvp_extract->ProcessList(plist_file))
  {
    pvp_extract->Release();
    return 1;
  }

  if(pinput_dir && !pvp_extract->ProcessDirectory(pinput_dir))
  {
    pvp_extract->Release();
    return 1;
  }

  // end calibration estimation and save calibration parameters
  if(pout_calib_file)
  {
    assert(pcalib);
    pcalib->EndEstimation();
    if (!pcalib->Save(pout_calib_file))
    {
      pvp_extract->Release();
      return 1;
    }
  }

  pvp_extract->Release();
  return 0;
}

---