vpcompare.cpp

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

/*****************************************************************
 *  BSAPI Voice-print Comparator 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 <float.h>
#include <errno.h>
#include <math.h>
#include <locale.h>

#include <vector>
#include <algorithm>

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

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

// compile time program options
#define SID_LOCALE                "C"             // use "" for environment's default locale
#define SID_MIN_LEN_TO_PROCESS    3.0f            // in seconds
#define SID_BELOW_MIN_LEN_TEXT    "(too short)"
#define SID_OUT_COLUMN_CHARS      "snkl"

// default option values
#define SID_DEF_VPRINT_EXT        "vp"
#define SID_DEF_SCORE_SHARPNESS   1.0f
#define SID_DEF_ADAPT_CONST       1.0f

inline float GetSpeechLengthSec(SVoicePrintI *pVoicePrint)
{
  return pVoicePrint->GetNFrames() / 100.0f;
}

inline bool IsTooShort(SVoicePrintI *pVoicePrint)
{
  return (GetSpeechLengthSec(pVoicePrint) < SID_MIN_LEN_TO_PROCESS);
}

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

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

class ScoreSorter
{
  public:
    ScoreSorter() : mpScores(0), mpSet(0), mSuppressTooShort(false) {}

    void SetScores(float *pScores, size_t length)
    {
      mpScores = pScores;

      mIndices.resize(length);
      for (size_t i = 0; i < mIndices.size(); i++)
        mIndices[i] = i;
    }

    void SetVoicePrints(SVoicePrintSetI *pSet, bool suppressTooShort)
    {
      mpSet = pSet;
      mSuppressTooShort = suppressTooShort;
    }

    void Sort()
    {
      sort(mIndices.begin(), mIndices.end(), *this);
    }

    int GetIndex(int nthBest) const
    {
      return mIndices[nthBest];
    }

    bool operator() (int i, int j)
    {
      assert(mpScores != 0 && mpSet != 0);
      float score1 = (IsTooShort(mpSet->GetByIndex(i)) && !mSuppressTooShort) ? -FLT_MAX : mpScores[i];
      float score2 = (IsTooShort(mpSet->GetByIndex(j)) && !mSuppressTooShort) ? -FLT_MAX : mpScores[j];
      return (score1 > score2);
    }

  private:
    std::vector<int> mIndices;
    float *mpScores;
    SVoicePrintSetI *mpSet;
    bool mSuppressTooShort;
};

void help()
{
  puts("\n Voice-print comparator                                              ");
  printf(" %s\n", BSAPIVersion());
  puts(" ===================================================================== ");
  puts("                                                                       ");
  puts(" USAGE: vpcompare [options] input1 [input2]                            ");
  puts("                                                                       ");
  puts(" system configuration:                                                 ");
  puts("   -c file            configuration file                               ");
  puts("   -m dir             model directory                                  ");
  puts("   -v                 verbose mode                                     ");
  puts("                                                                       ");
  puts(" comparison mode:                                                      ");
  puts("   input:                                                              ");
  puts("     -f               compare two voice-print files                    ");
  puts("     -l               compare two lists of voice-print files           ");
  puts("     -d               compare two directories of voice-print files     ");
  puts("     -e str [vp]      extension of voice-print file                    ");
  puts("                                                                       ");
  puts("   output:                                                             ");
  puts("     -o file          output score file                                ");
  puts("     -n               dump voice-print file names to the score file    ");
  puts("     -u               suppress the 'too short' output                  ");
  puts("     -k columns       enable column output format (see columns)        ");
  puts("     -b num           for each voice-print from input1 dump only N     ");
  puts("                      best scores from input2                          ");
  puts("     -t num           for each voice-print from input1 dump only scores");
  puts("                      from input2 which are greater than threshold     ");
  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("      k               speech length of input1 voice-print              ");
  puts("      l               speech length of input2 voice-print              ");
  puts("                                                                       ");
  puts(" training mode (enabled by option -g):                                 ");
  puts("     -x               use counts (of voice-prints) for adaptation      ");
  puts("     -a num [1.0]     adaptation constant <0.0, 1.0>                   ");
  puts("                      0.0 ... old models are used only                 ");
  puts("                      1.0 ... new models are used only                 ");
  puts("   input:                                                              ");
  puts("     -l               train from two-column list file; speaker name in ");
  puts("                      first column, voice-print file in second column  ");
  puts("     -d               train from directory with subdirectories each    ");
  puts("                      corresponding to a single speaker                ");
  puts("     -e str [vp]      extension of voice-print file                    ");
  puts("                                                                       ");
  puts("   output:                                                             ");
  puts("     -g dir           output model directory                           ");
  puts("                                                                       ");
  puts(" example:                                                              ");
  puts("   vpcompare -c settings/compare -f file1.vp file2.vp                  ");
  puts("   vpcompare -c settings/compare -l -o score.txt list1.txt list2.txt   ");
  puts("   vpcompare -c settings/compare -d -e 'vp' -o score.txt dir1 dir2     ");
  puts("   vpcompare -c settings/compare -d -e 'vp' -g models dir1             ");
  puts("                                                                       ");
}

void DumpColWiseLine(FILE *pFileHandle, float score, SVoicePrintI *pVoicePrint1, SVoicePrintI *pVoicePrint2,
  const char *pColumnFmt, float sharpness, bool suppressTooShort)
{
  fprintf(pFileHandle, "%s\t%s", pVoicePrint1->GetSegmentId(), pVoicePrint2->GetSegmentId());
  for (const char *pc = pColumnFmt; *pc != '\0'; pc++)
  {
    switch (*pc)
    {
      case 's':
        if ((IsTooShort(pVoicePrint1) || IsTooShort(pVoicePrint2)) && !suppressTooShort)
          fprintf(pFileHandle, "\t-inf");
        else
          fprintf(pFileHandle, "\t%.3f", score);
        break;

      case 'n':
        if ((IsTooShort(pVoicePrint1) || IsTooShort(pVoicePrint2)) && !suppressTooShort)
          fprintf(pFileHandle, "\t0.000");
        else
          fprintf(pFileHandle, "\t%.3f", RescaleScore(score, sharpness));
        break;

      case 'k':
        fprintf(pFileHandle, "\t%.3f", GetSpeechLengthSec(pVoicePrint1));
        break;

      case 'l':
        fprintf(pFileHandle, "\t%.3f", GetSpeechLengthSec(pVoicePrint2));
        break;
    }
  }

  if ((IsTooShort(pVoicePrint1) || IsTooShort(pVoicePrint2)) && !suppressTooShort)
    fprintf(pFileHandle, "\t%s", SID_BELOW_MIN_LEN_TEXT);

  fprintf(pFileHandle, "\n");
}

void DumpColWiseNBest(FILE *pFileHandle, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2,
  const char *pColumnFmt, float sharpness, bool suppressTooShort, int nBest)
{
  ScoreSorter score_sorter;

  for (int i = 0; i < pSet1->GetNVoicePrints(); i++)
  {
    int nscores = pScores->GetNColumns();
    float *pscores = pScores->GetRowMem(i);
    score_sorter.SetScores(pscores, nscores);
    score_sorter.SetVoicePrints(pSet2, suppressTooShort);
    score_sorter.Sort();
    SVoicePrintI *pvoice_print1 = pSet1->GetByIndex(i);
    for (int j = 0; j < std::min(nBest, nscores); j++)
    {
      int index = score_sorter.GetIndex(j);
      DumpColWiseLine(pFileHandle, pscores[index], pvoice_print1, pSet2->GetByIndex(index),
                      pColumnFmt, sharpness, suppressTooShort);
    }
  }
}

void DumpColWiseBest(FILE *pFileHandle, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2,
  const char *pColumnFmt, float sharpness, bool suppressTooShort)
{
  for (int i = 0; i < pSet1->GetNVoicePrints(); i++)
  {
    assert(pSet2->GetNVoicePrints() > 0);

    float best_score = -FLT_MAX;
    SVoicePrintI *pbest_vprint = 0;
    float *pscores = pScores->GetRowMem(i);
    for (int j = 0; j < pSet2->GetNVoicePrints(); j++)
    {
      if ((pscores[j] > best_score) && 
          ((!IsTooShort(pSet1->GetByIndex(i)) && !IsTooShort(pSet2->GetByIndex(j))) || suppressTooShort))
      {
        best_score = pScores->Get(i, j);
        pbest_vprint = pSet2->GetByIndex(j);
      }
    }

    DumpColWiseLine(pFileHandle, best_score, pSet1->GetByIndex(i), pbest_vprint ? pbest_vprint : pSet2->GetByIndex(0),
                    pColumnFmt, sharpness, suppressTooShort);
  }
}

void DumpColWiseThr(FILE *pFileHandle, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2,
  const char *pColumnFmt, float sharpness, bool suppressTooShort, float scoreThreshold)
{
  for (int i = 0; i < pSet1->GetNVoicePrints(); i++)
  {
    float *pscores = pScores->GetRowMem(i);
    SVoicePrintI *pvoice_print1 = pSet1->GetByIndex(i);
    for (int j = 0; j < pSet2->GetNVoicePrints(); j++)
    {
      if ((RescaleScore(pscores[j], sharpness) >= scoreThreshold) && 
          ((!IsTooShort(pvoice_print1) && !IsTooShort(pSet2->GetByIndex(j))) || suppressTooShort))
      {
        DumpColWiseLine(pFileHandle, pscores[j], pvoice_print1, pSet2->GetByIndex(j),
                        pColumnFmt, sharpness, suppressTooShort);
      }
    }
  }
}

void DumpColWise(FILE *pFileHandle, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2,
  const char *pColumnFmt, float sharpness, bool suppressTooShort)
{
  for (int i = 0; i < pSet1->GetNVoicePrints(); i++)
  {
    float *pscores = pScores->GetRowMem(i);
    SVoicePrintI *pvoice_print1 = pSet1->GetByIndex(i);
    for (int j = 0; j < pSet2->GetNVoicePrints(); j++)
    {
      DumpColWiseLine(pFileHandle, pscores[j], pvoice_print1, pSet2->GetByIndex(j),
                      pColumnFmt, sharpness, suppressTooShort);
    }
  }
}

void DumpRowWise(FILE *pFileHandle, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2, 
  bool dumpNames, bool suppressTooShort)
{
  if(dumpNames)
  {
    for(int i = 0; i < pSet2->GetNVoicePrints(); i++)
      fprintf(pFileHandle, "\t%s", pSet2->GetByIndex(i)->GetSegmentId());
    fprintf(pFileHandle, "\n");
  }

  bool too_short2 = false;
  float *prow = pScores->GetMem();
  for(int i = 0; i < pSet1->GetNVoicePrints(); i++)
  {
    if(dumpNames)
      fprintf(pFileHandle, "%s\t", pSet1->GetByIndex(i)->GetSegmentId());
    for(int j = 0; j < pSet2->GetNVoicePrints(); j++)
    {
      if(IsTooShort(pSet2->GetByIndex(j)))
        too_short2 = true;
      if(j != 0)
        fprintf(pFileHandle, "\t");
      if((IsTooShort(pSet1->GetByIndex(i)) || IsTooShort(pSet2->GetByIndex(j))) && !suppressTooShort)
        fprintf(pFileHandle, "-inf");
      else
        fprintf(pFileHandle, "%e", prow[j]);
    }
    if (IsTooShort(pSet1->GetByIndex(i)) && !suppressTooShort)
      fprintf(pFileHandle, "\t%s", SID_BELOW_MIN_LEN_TEXT);
    fprintf(pFileHandle, "\n");
    prow += pScores->GetStride();
  }

  if(too_short2 && !suppressTooShort)
  {
    if(dumpNames)
      fprintf(pFileHandle, "\t");
    for(int i = 0; i < pSet2->GetNVoicePrints(); i++)
    {
      if(i != 0)
        fprintf(pFileHandle, "\t");
      if(IsTooShort(pSet2->GetByIndex(i)))
        fprintf(pFileHandle, "%s", SID_BELOW_MIN_LEN_TEXT);
    }
    fprintf(pFileHandle, "\n");
  }
}

bool SaveScores(const char *pFile, SFloatMatrixI *pScores, SVoicePrintSetI *pSet1, SVoicePrintSetI *pSet2,
  const char *pColumnFmt, float sharpness, int nBestScores, float scoreThreshold, bool dumpNames, bool suppressTooShort)
{
  assert(pScores->GetNRows() == pSet1->GetNVoicePrints() && pScores->GetNColumns() == pSet2->GetNVoicePrints());

  setlocale(LC_ALL, SID_LOCALE);

  FILE *pf = fopen(pFile, "w");
  if (!pf)
  {
    fprintf(stderr, "ERROR: Can not create '%s'.\n", pFile);
    return false;
  }

  switch (nBestScores)
  {
    case 0:
      if (scoreThreshold > 0.0f)
        DumpColWiseThr(pf, pScores, pSet1, pSet2, (pColumnFmt ? pColumnFmt : "n"), sharpness, suppressTooShort, scoreThreshold);
      else if (pColumnFmt)
        DumpColWise(pf, pScores, pSet1, pSet2, pColumnFmt, sharpness, suppressTooShort);
      else
        DumpRowWise(pf, pScores, pSet1, pSet2, dumpNames, suppressTooShort);
      break;

    case 1:
      DumpColWiseBest(pf, pScores, pSet1, pSet2, (pColumnFmt ? pColumnFmt : "n"), sharpness, suppressTooShort);
      break;

    default:
      DumpColWiseNBest(pf, pScores, pSet1, pSet2, (pColumnFmt ? pColumnFmt : "n"), sharpness, suppressTooShort, nBestScores);
      break;
  }

  fclose(pf);
  return true;
}

int main(int argc, char *argv[])
{
  // initial configuration variables
  const char *pconfig_file = "settings/compare.bs";
  const char *pinput1      = 0;
  const char *pinput2      = 0;
  const char *pvprint_ext  = SID_DEF_VPRINT_EXT;
  const char *poutput_file = 0;
  const char *pcolumn_fmt  = 0;
  const char *pmodel_dir   = 0;
  const char *pout_model_dir = 0;
  bool process_files   = false;
  bool process_lists   = false;
  bool process_dirs    = false;
  int  nbest_scores    = 0;
  float score_thr      = 0.0f;
  bool dump_names      = false;
  bool supp_too_short  = false;
  float sharpness      = SID_DEF_SCORE_SHARPNESS;
  float adapt_const    = SID_DEF_ADAPT_CONST;
  bool use_counts      = false;

  // command line parsing
  if(argc == 1)
  {
    help();
    return 0;
  }

  optind = 0;
  while (1)
  {
    int c = getopt(argc, argv, const_cast<char *>("c:uvflde:o:nk:t:z:b:m:g:a:x"));
    if(c == -1)
      break;

    switch(c)
    {
      case 'c':
        pconfig_file = optarg;
        break;
      case 'm':
        pmodel_dir = optarg;
        break;
      case 'g':
        pout_model_dir = optarg;
        break;
      case 'o':
        poutput_file = optarg;
        break;
      case 'l':
        process_lists = true;
        break;
      case 'd':
        process_dirs = true;
        break;
      case 'f':
        process_files = true;
        break;
      case 'e':
        pvprint_ext = optarg;
        break;
      case 'n':
        dump_names = true;
        break;
      case 'u':
        supp_too_short = true;
        break;
      case 'x':
        use_counts = true;
        break;
      case 'b':
        if(sscanf(optarg, "%d", &nbest_scores) != 1 || nbest_scores < 0)
        {
          fprintf(stderr, "ERROR: Invalid number of best scores to print '%s'. "
                          "Must be positive integer.\n", optarg);
          return 1;
        }
        break;
      case 't':
        if(sscanf(optarg, "%f", &score_thr) != 1 || score_thr < 0.0f || score_thr > 100.0f)
        {
          fprintf(stderr, "ERROR: Wrong value of score threshold '%s'. Must be number in <0,100>.\n", optarg);
          return 1;
        }
        break;
      case 'k':
        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 || sharpness < 0.0f)
        {
          fprintf(stderr, "ERROR: Wrong value of score sharpness '%s'. Must be positive number.\n", optarg);
          return 1;
        }
        break;
      case 'a':
        if(sscanf(optarg, "%f", &adapt_const) != 1 || adapt_const < 0.0f || adapt_const > 1.0f)
        {
          fprintf(stderr, "ERROR: Wrong value of adaptation constant '%s'. Must be number in <0.0, 1.0>.\n", optarg);
          return 1;
        }
        break;
      case 'v':
        gErrorHandler.SetVerbose(true);
        break;
      case 1: // non-option arguments
        if(!pinput1)
        {
          pinput1 = optarg;
        }
        else if(!pinput2)
        {
          pinput2 = optarg;
        }
        else
        {
          fprintf(stderr, "ERROR: Only two files, lists or directories can be compared at the same time.\n");
          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;
    }
  }


  if((process_files && process_dirs) || (process_files && process_lists) || (process_lists && process_dirs))
  {
    fprintf(stderr, "ERROR: Only one of -f, -l, -d options can be used at the same time.\n");
    return 1;
  }

  if(!pinput1 || (!pout_model_dir && !pinput2))
  {
    fprintf(stderr, "ERROR: Missing input. Two inputs should be specified for comparison mode and one input for training mode.\n");
    return 1;
  }

  if(!process_dirs && !process_lists && pout_model_dir)
  {
    fprintf(stderr, "ERROR: Training is enabled but not the input list file nor the input directory is set.\n");
    return 1;
  }

  if(!process_files && !process_dirs && !process_lists)
    process_files = true;

  // 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
  SVoicePrintComparatorI *pvp_compare = static_cast<SVoicePrintComparatorI *>(BSAPICreateInstance(SIID_VPRINTCOMPARATOR));
  if(!pvp_compare)
  {
    return 1;
  }

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

  if(pmodel_dir)
    pvp_compare->SetModelDirectory(pmodel_dir);

  if(pout_model_dir)
  {
    // training mode
    pvp_compare->SetOutputModelDirectory(pout_model_dir);

    STwoSetComparisonI *pcomparer = pvp_compare->GetTwoSetComparator();
    if(!pcomparer)
    {
      pvp_compare->Release();
      return 1;
    }

    if(pcomparer->GetIID() == SIID_TWOCOVMODEL)
    {
      STwoCovarianceModelI *ptwo_cov_model = static_cast<STwoCovarianceModelI *>(pcomparer);
      ptwo_cov_model->SetAdaptConst(adapt_const);
      ptwo_cov_model->SetUseCounts(use_counts);
    }

    if(process_lists)
    {
      assert(pinput1);
      if (!pvp_compare->TrainFromList(pinput1))
      {
        pvp_compare->Release();
        return 1;
      }
    }
    else
    {
      assert(process_dirs && pinput1);
      if (!pvp_compare->TrainFromDirectory(pinput1, pvprint_ext))
      {
        pvp_compare->Release();
        return 1;
      }
    }
  }
  else
  {
    // comparison mode
    SFloatMatrixI *pscores = static_cast<SFloatMatrixI *>(BSAPICreateInstance(SIID_FLOATMATRIX));
    if(!pscores)
    {
      fprintf(stderr, "ERROR: Memory allocation error.\n");
      pvp_compare->Release();
      return 1;
    }
    pscores->SetErrorHandler(&gErrorHandler);

    if(process_files)
    {
      float score = 0.0f;
      if(!pvp_compare->Compare2VoicePrintFiles(pinput1, pinput2, &score))
      {
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }
      printf("Score: %e\n", score);
    }
    else if(process_lists || process_dirs)
    {
      if(!poutput_file)
      {
        fprintf(stderr, "ERROR: An output file must be specified (-o).\n");
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }

      SVoicePrintSetI *pset1 = static_cast<SVoicePrintSetI *>(BSAPICreateInstance(SIID_VPRINTSET));
      if(!pset1)
      {
        fprintf(stderr, "ERROR: Memory allocation error.\n");
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }

      pset1->SetErrorHandler(&gErrorHandler);

      SVoicePrintSetI *pset2 = static_cast<SVoicePrintSetI *>(BSAPICreateInstance(SIID_VPRINTSET));
      if(!pset2)
      {
        fprintf(stderr, "ERROR: Memory allocation error.\n");
        pset1->Release();
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }

      pset2->SetErrorHandler(&gErrorHandler);

      if(process_lists)
      {
        if(!pset1->LoadFromList(pinput1))
        {
          pset1->Release();
          pset2->Release();
          pscores->Release();
          pvp_compare->Release();
          return 1;
        }

        if(!pset2->LoadFromList(pinput2))
        {
          pset1->Release();
          pset2->Release();
          pscores->Release();
          pvp_compare->Release();
          return 1;
        }
      }
      else // process_dirs
      {
        if(!pset1->LoadFromDirectory(pinput1, pvprint_ext))
        {
          pset1->Release();
          pset2->Release();
          pscores->Release();
          pvp_compare->Release();
          return 1;
        }

        if(!pset2->LoadFromDirectory(pinput2, pvprint_ext))
        {
          pset1->Release();
          pset2->Release();
          pscores->Release();
          pvp_compare->Release();
          return 1;
        }
      }

      if(!pvp_compare->Compare2VoicePrintSets(pset1, pset2, pscores))
      {
        pset1->Release();
        pset2->Release();
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }

      if(!SaveScores(poutput_file, pscores, pset1, pset2, pcolumn_fmt, sharpness, nbest_scores, score_thr, dump_names, supp_too_short))
      {
        pset1->Release();
        pset2->Release();
        pscores->Release();
        pvp_compare->Release();
        return 1;
      }

      pset1->Release();
      pset2->Release();
    }

    pscores->Release();
  }

  pvp_compare->Release();
  return 0;
}

---