gid.cpp

This example shows how to use the SGenderID2I interface.

/*****************************************************************
 *  BSAPI Gender 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 <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include "bsapi.h"

#ifdef _WIN32
  #include "getopt.h"
  #define DIRSEP "\\"
#else
  #include <unistd.h>
  #define DIRSEP "/"
#endif

#define GID_LOG_0                 -1.0e10
#define GID_LOG_MIN                (0.5 * GID_LOG_0)
#define GID_MIN_LOG_DIFF           log(DBL_EPSILON)
#define GID_LOWER_SCORE_THRESHOLD -1e5
#define GID_DEF_SCORE_SHARPNESS    4.0f
#define GID_DEF_GENDER_BALANCE     0.0f
#define GID_DEF_UNK_CLASS_THR      80.0f
#define GID_DEF_NCHANNELS          1
#define GID_UNKNOWN_CLASS_LETTER   'U'
#define GID_UNKNOWN_CLASS_NAME     "UNKNOWN"

enum InputModeType
{
  GID_IMT_NONE,
  GID_IMT_FILE,
  GID_IMT_LIST,
  GID_IMT_DIR,
};

enum GenderType
{
  GID_GNDR_FEMALE = 0,
  GID_GNDR_MALE,
  GID_GNDR_NGENDERS
};

void help(const char *pProgName)
{ 
  puts("\n Gender Identification                                          ");
printf(" %s\n", BSAPIVersion());
  puts(" ================================================================ ");
  puts("                                                                  ");
printf(" USAGE: %s [options]\n", pProgName);
  puts("                                                                  ");
  puts(" options:                                                         ");
  puts("   -c file           configuration file                           ");
  puts("   -i file           input file                                   ");
  puts("   -l file           list of input files                          ");
  puts("   -d dir            input directory                              ");
  puts("   -e str  [alw,wav] extensions of input files (comma separated)  ");     
  puts("   -w fmt  [alaw]    waveform format (lin16, lin8, alaw, mulaw)   ");
  puts("   -n num  [1]       number of channels in audio files            ");
  puts("   -o file [stdout]  output score file                            ");
  puts("   -r                produce scores for both genders              ");
  puts("   -s num  [4.0]     score sharpness (positive number)            ");
  puts("   -b num  [0.0]     gender balance (-1.0, 1.0)                   ");
  puts("                        -1.0 ... 100% males                       ");
  puts("                         0.0 ... equally balanced                 ");
  puts("                         1.0 ... 100% females                     ");
printf("   -u num  [80.0]    unknown class (%c) score thr. (50.0, 100.0)\n", GID_UNKNOWN_CLASS_LETTER);
  puts("                        50.0 ... unknown class off                ");
  puts("                       >50.0 ... unknown class if less than thr.  ");
  puts("   -v                verbose mode                                 ");
  puts("                                                                  ");
}

// 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 = true) {mVerbose = verbose;}
  
  protected:
    bool mVerbose;
} gErrorHandler;

bool str2float(const char *pStr, float *pValue)
{
  char *pend_ptr = 0;
  
  errno = 0;
  *pValue = strtod(pStr, &pend_ptr);
    
  if (errno != 0 || *pend_ptr != '\0')
  {
    fprintf(stderr, 
      "ERROR: Can not convert string '%s' to floating point number.\n", pStr);
    return false;
  }

  return true;
}

double log_add(double x, double y)
{
  double diff;
  
  if (x < y)
  {
    diff = x - y;
    x = y;
  }
  else
  {
    diff = y - x;
  }
  
  if (x < GID_LOG_MIN)
    return GID_LOG_0;
  
  if (diff < GID_MIN_LOG_DIFF)
    return  x;
  
  return x + log(1.0 + exp(diff));
} 

void log_like2post_prob(
    float& scoreFemale, 
    float& scoreMale, 
    float sharpness = 1.0f, 
    float balance = 0.0f)
{
  balance = (balance + 1.0f) / 2.0f;
  scoreMale   = sharpness * scoreMale   + logf(1.0f - balance);
  scoreFemale = sharpness * scoreFemale + logf(balance);
  
  if (scoreMale < GID_LOWER_SCORE_THRESHOLD)
    scoreMale = GID_LOWER_SCORE_THRESHOLD;
    
  if (scoreFemale < GID_LOWER_SCORE_THRESHOLD)
    scoreFemale = GID_LOWER_SCORE_THRESHOLD;
  
  float sum = log_add(scoreMale, scoreFemale);
  
  scoreMale   -= sum;
  scoreFemale -= sum;

  // renormalization - in the first pass, the registers could have been in 
  // an arrea of saturation with very high rounding
  sum = log_add(scoreMale, scoreFemale);

  scoreMale   = expf(scoreMale   - sum) * 100.0f;
  scoreFemale = expf(scoreFemale - sum) * 100.0f;
}

bool process_file(const char *pInputFile,
                  FILE *pOutput,
                  SGenderID2I *pGenderId,
                  SScoreMemoryI *pScoreMemory,
                  float sharpness,
                  float balance,
                  float unkThreshold,
                  bool  dumpAllScores)
{
  static bool header_printed = false;

  gErrorHandler.LogMessage("Processing file: %s", pInputFile);
  if (!pGenderId->TestFile(pInputFile))
    return false;

  if (pScoreMemory->Empty())
    return false;

  SScoresI *pscores_container = pScoreMemory->GetScores();
  assert(pscores_container);
  int length = pscores_container->GetNScores();
  char **ppnames = pscores_container->GetNames();
  float *pscores = pscores_container->GetScores();

  assert(pscores && ppnames && (GID_GNDR_NGENDERS == length));
  
  log_like2post_prob(
    pscores[GID_GNDR_FEMALE], 
    pscores[GID_GNDR_MALE], 
    sharpness, balance);
  
  int winner = (pscores[GID_GNDR_FEMALE] > pscores[GID_GNDR_MALE]) ? 
    GID_GNDR_FEMALE : GID_GNDR_MALE;
  
  if (dumpAllScores)
  {
    if (!header_printed)
    {
      // print output score file header
      for (int i = 0; i < length; i++)
        fprintf(pOutput, "%s ", ppnames[i]);
      fprintf(pOutput, "\n");

      header_printed = true;
    }

    fprintf(pOutput, "%s %f %f %c\n", 
      pInputFile,
      pscores[GID_GNDR_FEMALE], 
      pscores[GID_GNDR_MALE],
      (pscores[winner] < unkThreshold) ? GID_UNKNOWN_CLASS_LETTER : ppnames[winner][0]);
  }
  else
  {
    if (pscores[winner] < unkThreshold)
      fprintf(pOutput, "%s %s %f %c\n", pInputFile, GID_UNKNOWN_CLASS_NAME, pscores[winner], ppnames[winner][0]);
    else
      fprintf(pOutput, "%s %s %f\n", pInputFile, ppnames[winner], pscores[winner]);
  }

  return true;
}

bool process_list(const char *pInputList,
                  FILE *pOutput,
                  SGenderID2I *pGenderId,
                  SScoreMemoryI *pScoreMemory,
                  float sharpness,
                  float balance,
                  float unkThreshold,
                  bool  dumpAllScores)
{
  gErrorHandler.LogMessage("Processing list of files: %s", pInputList);
  SFileListI *plist = static_cast<SFileListI *>(BSAPICreateInstance(SIID_FILELIST));
  if (!plist)
  {
    fprintf(stderr, "ERROR: Memory allocation error.\n");
    return false;
  }

  plist->SetErrorHandler(&gErrorHandler);
  if (!plist->AddList(pInputList))
  {
    plist->Release();
    return false;
  }
  
  char ptarget[1024], psource[1024];
  int start, end;
  float prob;
  
  plist->FirstLine();      
  while (plist->GetLine(ptarget, psource, &start, &end, &prob))
  {
    process_file(psource, pOutput, pGenderId, pScoreMemory, sharpness, 
      balance, unkThreshold, dumpAllScores);
  }
  
  plist->Release();
  return true;
}

bool process_dir(const char *pInputDir,
                 const char *pSuffixes,
                 FILE *pOutput,
                 SGenderID2I *pGenderId,
                 SScoreMemoryI *pScoreMemory,
                 float sharpness,
                 float balance,
                 float unkThreshold,
                 bool  dumpAllScores)
{
  gErrorHandler.LogMessage("Processing directory: %s", pInputDir);
  SFileSnifferI *pdir = static_cast<SFileSnifferI *>(BSAPICreateInstance(SIID_FILESNIFFER));
  if (!pdir)
  {
    fprintf(stderr, "ERROR: Memory allocation error.\n");
    return false;
  }
  
  pdir->SetErrorHandler(&gErrorHandler);
  if (!pdir->AddDirectory(pInputDir))
  {
    pdir->Release();
    return false;
  }
  
  char psuffixes[1024];
  psuffixes[sizeof(psuffixes) - 1] = '\0';
  strncpy(psuffixes, pSuffixes, sizeof(psuffixes) - 1);
  char *psuffix = strtok(psuffixes, ",; ");
  while (psuffix)
  {
    pdir->AddWantedSuffix(psuffix);
    psuffix = strtok(0, ",; ");
  }

  if (!pdir->FirstFile())
  {
    pdir->Release();
    return false;
  }
      
  char psource[1024];
  while(pdir->GetFile(psource, sizeof(psource) - 1))
  {
    process_file(psource, pOutput, pGenderId, pScoreMemory, sharpness, 
      balance, unkThreshold, dumpAllScores);
  }
  
  pdir->Release();
  return true; 
}

int main(int argc, char *argv[])
{
  // init configuration variables
  InputModeType mode        = GID_IMT_NONE;
  const char *pconfig_file  = 0;
  const char *pinput_format = "alaw";
  const char *pinput_ext    = "alw,wav";
  const char *pinput        = 0;
  const char *poutput_file  = 0;
  float sharpness           = GID_DEF_SCORE_SHARPNESS;
  float balance             = GID_DEF_GENDER_BALANCE;
  float unk_thr             = GID_DEF_UNK_CLASS_THR;
  int   nchannels           = GID_DEF_NCHANNELS;
  bool  dump_all_scores     = false;

  // no input parameters given
  if(argc == 1)
  {
    help(argv[0]);
    return 0;
  }

  // command line parsing
  int c;
  optind = 0;
  while ((c = getopt(argc, argv, const_cast<char *>("c:i:l:d:e:w:n:o:rs:b:u:v"))) != -1)
  {
    switch(c)
    {
      case 'c': pconfig_file  = optarg; break;
      case 'i': pinput = optarg; mode = GID_IMT_FILE; break;
      case 'l': pinput = optarg; mode = GID_IMT_LIST; break;
      case 'd': pinput = optarg; mode = GID_IMT_DIR;  break;
      case 'e': pinput_ext    = optarg; break;
      case 'w': pinput_format = optarg; break;
      case 'o': poutput_file  = optarg; break;
      case 'r': dump_all_scores = true; break;
      case 's': if (!str2float(optarg, &sharpness)) return 1; break;
      case 'b': if (!str2float(optarg, &balance))   return 1; break;
      case 'u': if (!str2float(optarg, &unk_thr))   return 1; break;
      case 'n': nchannels = atoi(optarg);   break;
      case 'v': gErrorHandler.SetVerbose(); break;
      case '?':
        fprintf(stderr, "ERROR: Command line parsing error.\n");
        return 1;
    }
  }
  
  // check if the config file was set
  if (!pconfig_file)
  {
    fprintf(stderr, "ERROR: Configuration file was not set (-c).\n");
    return 1;
  }

  // check if either input file or list file was set
  if (GID_IMT_NONE == mode)
  {
    fprintf(stderr, "ERROR: Input file, list or directory must be set (-i | -l | -d).\n");
    return 1;
  }

  // check the number of channels
  if (nchannels < 1)
  {
    fprintf(stderr, "ERROR: Invalid number of channels (-n).\n");
    return 1;
  }

  // check if sharpness is in allowed interval
  if (sharpness < 0.0f)
  {
    fprintf(stderr, "ERROR: Wrong value of sharpness '%f'. "
      "Must be positive number. (-s)\n", sharpness);
    return 1;
  }

  // check if balance is in allowed interval
  if (balance < -1.0f || balance > 1.0f)
  {
    fprintf(stderr, "ERROR: Wrong value of balance '%f'. "
      "Must be in (-1.0, 1.0). (-b)\n", balance);
    return 1;
  }

  // check if unknown class threshold is in allowed interval
  if (unk_thr < 50.0f || unk_thr > 100.0f)
  {
    fprintf(stderr, "ERROR: Wrong value of unknown class score threshold '%f'. "
      "Must be in (50.0, 100.0). (-u)\n", unk_thr);
    return 1;
  }

  // register license file for SGenderID2I
  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }
  
  // init gender ID
  SGenderID2I *pgender_id = static_cast<SGenderID2I *>(BSAPICreateInstance(SIID_GENDERID2));
  if (!pgender_id)
  {
    return 1;
  }

  pgender_id->SetErrorHandler(&gErrorHandler);

  if (!pgender_id->Init(pconfig_file))
  {
    pgender_id->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 = pgender_id->GetWaveformFormatConvertor();
  if (pwc)
  {
    pwc->SetNChannels(nchannels);
    pwc->SetInputFormatStr(pinput_format);
  }

  // By default, the scores are sent from the gender 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)
  {
    fprintf(stderr, "ERROR: Memory allocation error.\n");
    pgender_id->Release();
    return 1;
  }

  pscore_mem->SetErrorHandler(&gErrorHandler);
  pgender_id->SetTarget(pscore_mem);

  // activate gender models before scoring
  if (!pgender_id->ActivateAllModels())
  {
    pgender_id->Release();
    pscore_mem->Release();
    return 1;
  }

  // check that both models are activated
  SModelListI *pmodel_list = pgender_id->GetModelList();
  if (!pmodel_list)
  {
    pgender_id->Release();
    pscore_mem->Release();
    return 1;
  }

  if (GID_GNDR_NGENDERS != pmodel_list->GetNModels())
  {
    fprintf(stderr, "ERROR: Some of gender models are missing.\n");
    pgender_id->Release();
    pscore_mem->Release();
    return 1;
  }

  // open output file
  FILE *poutput = poutput_file ? fopen(poutput_file, "w") : stdout;
  if (!poutput)
  {
    fprintf(stderr, "ERROR: Could not open output file '%s'.\n", poutput_file);
    pgender_id->Release();
    pscore_mem->Release();
    return 1;
  }

  // process file(s)
  bool processed = false;
  switch (mode)
  {
    case GID_IMT_FILE:
      processed = process_file(
        pinput, poutput, pgender_id, pscore_mem, sharpness, balance, unk_thr, dump_all_scores);
      break;
      
    case GID_IMT_LIST:
      processed = process_list(
        pinput, poutput, pgender_id, pscore_mem, sharpness, balance, unk_thr, dump_all_scores);
      break;
      
    case GID_IMT_DIR:
      processed = process_dir(
        pinput, pinput_ext, poutput, pgender_id, pscore_mem, sharpness, balance, unk_thr, dump_all_scores);
      break;
      
    case GID_IMT_NONE:
      break;
  }

  // cleanup
  if (poutput_file)
    fclose(poutput);

  pgender_id->Release();
  pscore_mem->Release();
  return (processed ? 0 : 1);
}

---