offlinerec3.cpp

This example shows how to use the SOfflineSpeechRecognizer3I interface.

/*****************************************************************
 *  BSAPI LVCSR Example                                          *
 *                                                               *
 *  Author      : Petr Schwarz, Pavel Matejka,                   *
 *                Igor Szoke, Tomas Cipr                         *
 *  Copyright   : (C) 2006-2011 by Phonexia s.r.o                *
 *                                                               *
 *  For more info, please contact us at support@phonexia.com     *
 *****************************************************************/

#include "bsapi.h"
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <time.h>

#include "stimer.h"
#include "getopt.h"

#if _MSC_VER
#define snprintf _snprintf
#endif

// default option values
#define SID_DEF_IN_DATA_TYPE      "waveform"
#define SID_DEF_FEA_FMT           "htk"

static void change_file_path(char *pFileName, const char *pNewPath);
static void change_file_suffix(char *pFileName, const char *pNewSuffix);
static void get_file_path(const char *pFileName, char *pRetPath);
static void get_file_suffix(const char *pFileName, char *pRetSuffix);
static bool rename_file(const char *pOldFile, const char *pNewFile);
static void change_file_suffix(char *pFileName, const char *pNewSuffix);

static bool process_file(
  const char *pInputFile,
  const char *pOutputFile,
  const char *pOutputDir,
  const char *pTransSuffix,
  bool moveInputFile,
  SOfflineSpeechRecognizer3I *pSpeechRec);

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 SStateHandler : public SOfflineSpeechRecCallbackI
{
  public:
    SStateHandler() : mSaveLog(false), mpLogSuffix(0), mStartTime(-1), mStopTime(-1) {}

    bool BSAPI_METHOD OnFileStarted(const char *pInputFile, const char *pOutputFile)
    {
      gErrorHandler.LogMessage("Processing file '%s'", pInputFile);
      time(&mStartTime);
      mProcessingTimer.Start();
      return true;
    }

    bool BSAPI_METHOD OnSegmentStarted(long_long segmentStart, long_long segmentEnd, int channel, const char *pTranscriptionFile)
    {
      gErrorHandler.LogMessage("  segment [%d, %d]", static_cast<int>(segmentStart / 100000), static_cast<int>(segmentEnd / 100000));
      return true;
    }

    bool BSAPI_METHOD OnTranscription(SUnknownI *pSender, STranscriptionI *pTrans)
    {
      return true;
    }

    bool BSAPI_METHOD OnSegmentDone(long_long segmentStart, long_long segmentEnd, int channel, const char *pTranscriptionFile, bool isValid)
    {
      return true;
    }

    bool BSAPI_METHOD OnFileDone(const char *pInputFile, const char *pOutputFile)
    {
      mProcessingTimer.Stop();
      time(&mStopTime);

      if (mSaveLog)
        SaveLog(pInputFile, pOutputFile);

      return true;
    }

    void SetSaveLog(bool saveLog) {mSaveLog = saveLog;}
    void SetLogSuffix(const char *pLogSuffix) {mpLogSuffix = pLogSuffix;}

  protected:
    bool SaveLog(const char *pInputFile, const char *pOutputFile)
    {
      char plog_file_name[1024];
      plog_file_name[sizeof(plog_file_name) - 1] = '\0';
      strncpy(plog_file_name, pOutputFile, sizeof(plog_file_name) - 1);
      change_file_suffix(plog_file_name, mpLogSuffix);

      FILE *plog_file = fopen(plog_file_name, "a");
      if (!plog_file)
      {
        fprintf(stderr, "ERROR: Can not open log file '%s'.\n", plog_file_name);
        return false;
      }

      if (ftell(plog_file) != 0)
        fputc('\n', plog_file);

      fprintf(plog_file, "[lvcsr_software]\n");
      fprintf(plog_file, "bsapi_release=%s\n", BSAPIVersion());

      fputc('\n', plog_file);
      fprintf(plog_file, "[processing_info]\n");
      fprintf(plog_file, "input_file=%s\n", pInputFile);
      fprintf(plog_file, "output_file=%s\n", pOutputFile);
      fprintf(plog_file, "processing_start=%s", ctime(&mStartTime));
      fprintf(plog_file, "processing_stop=%s", ctime(&mStopTime));
      fprintf(plog_file, "duration_sec=%.3f\n", mProcessingTimer.GetInterval());

      fclose(plog_file);
      return true;
    }

  protected:
    bool mSaveLog;
    const char *mpLogSuffix;
    time_t mStartTime;
    time_t mStopTime;
    SSimpleTimer mProcessingTimer;

} gStateHandler;

class SFileSnifferCallback : public SFileSnifferCallbackI
{
  public:
    SFileSnifferCallback() : 
      mpSpeechRec(0),
      mpOutputDir(0),
      mpTransSuffix(0),
      mMoveInputToOutput(0),
      mResult(true)
    {
    }

    ~SFileSnifferCallback() {}

    bool BSAPI_METHOD OnFile(const char *pFile)
    {
      mResult &= process_file(pFile, 0, mpOutputDir, mpTransSuffix, mMoveInputToOutput, mpSpeechRec);
      return true;
    }

    bool BSAPI_METHOD OnStateChanged(state_type state)
    {
      switch (state)
      {
        case stLoopStarted: mResult = true; break;
        case stWaitForData: printf("Waiting for input files... Press ENTER to stop.\n"); break;
        case stTerminated:  break;
      }
      return true;
    }

    void SetSpeechRec(SOfflineSpeechRecognizer3I *pSpeechRec)  {mpSpeechRec = pSpeechRec;}
    void SetOutputDir(const char *pOutputDir)                 {mpOutputDir = pOutputDir;}
    void SetTransSuffix(const char *pTransSuffix)             {mpTransSuffix = pTransSuffix;}
    void SetMoveInputToOutput(bool moveInputToOutput)         {mMoveInputToOutput = moveInputToOutput;}
    bool GetResult()                                          {return mResult;}

  protected:
    SOfflineSpeechRecognizer3I *mpSpeechRec;
    const char *mpOutputDir;
    const char *mpTransSuffix;
    bool mMoveInputToOutput;
    bool mResult;

} gFileSnifferHandler;


void help(const char *pProgName)
{
  puts("\n Offline speech recognizer                                             ");
  printf(" %s\n", BSAPIVersion());
  puts(" ======================================================================= ");
  puts("                                                                         ");
  printf(" USAGE: %s [options]\n", pProgName);
  puts("                                                                         ");
  puts(" system configuration:                                                   ");
  puts("   -c file         config file                                           ");
  puts("                                                                         ");
  puts(" input from single file:                                                 ");
  puts("   -i file         input waveform or features file                       ");
  puts("   -j str [waveform] input data type (waveform, features)                ");
  puts("   -o file         output transcription file                             ");
  puts("                                                                         ");
  puts(" input data type = features:                                             ");
  puts("   -u fmt [htk]    feature format (ascii, binary, htk)                   ");
  puts("                                                                         ");
  puts(" input from list file:                                                   ");
  puts("   -l file         list of input [and output files]                      ");
  puts("                                                                         ");
  puts(" input from directory:                                                   ");
  puts("   -r dir          input directory                                       ");
  puts("   -e str [wav]    extensions of audio files (comma separated)           ");
  puts("   -a              input directory auto-scan mode                        ");
  puts("                                                                         ");
  puts(" output specification:                                                   ");
  puts("   -f type         list of output types (comma separated)                ");
  puts("                   str - one best string                                 ");
  puts("                   lat - lattice (graph with alternative sentences)      ");
  puts("                   cn  - confusion network (graph with alternative words)");
  puts("   -b flags        format flags for transctiption strings                ");
  puts("                     TXT:SEn      use pure text format                   ");
  puts("                       S,E include start/end time                        ");
  puts("                       n   deletes the auxiliary symbols                 ");
  puts("                     LBF:PSEl     use HTK label format                   ");
  puts("                       S,E include start/end time                        ");
  puts("                       l   include word likelihood                       ");
  puts("                       P   include word confidence                       ");
  puts("                     FST:NWPSEl   use graph format                       ");
  puts("                       N   include graph nodes                           ");
  puts("                       W   include word identification                   ");
  puts("                       S,E include start/end time                        ");
  puts("                       l   include word likelihood                       ");
  puts("                       P   include word confidence                       ");
  puts("   -h flags        format flags for lattices NWPpSELAl                   ");
  puts("                       N   include graph nodes                           ");
  puts("                       W   include word identification                   ");
  puts("                       P   include word posterior probability            ");
  puts("                       p   include word posterior probability in log     ");
  puts("                       S,E include start/end time                        ");
  puts("                       A   include word acoustic likelihood              ");
  puts("                       L   include word language likelihood              ");
  puts("                       l   include word total likelihood                 ");
  puts("   -k flags        format flags for confusion networks TNWPpSE           ");
  puts("                       T   include time slot                             ");
  puts("                       N   include graph nodes                           ");
  puts("                       W   include word identification                   ");
  puts("                       P   include word posterior probability            ");
  puts("                       p   include word posterior probability in log     ");
  puts("                       S,E include start/end time                        ");
  puts("   -n num [0]      maximal number of parallel words in CN (0 means inf)  ");
  puts("   -p num [-70]    minimal posterior probability of word in log for CN   ");
  puts("   -t str [default] time format (htk, frames, s, ms, hms, dhms, default) ");
  puts("                      htk     - time in htk time units = 100 nanoseconds ");
  puts("                      frames  - time in number of frames = 10 milliseconds");
  puts("                      s       - time in seconds                          ");
  puts("                      ms      - time in format minutes:seconds           ");
  puts("                      hms     - hours:minutes:seconds                    ");
  puts("                      dhms    - days hours:minutes:seconds               ");
  puts("                      default - htk for str LBF output type, s for others");
  puts("   -s str [trn]    one best string file suffix                           ");
  puts("   -y str [lat]    lattice file suffix                                   ");
  puts("   -z str [cn]     confusion network file suffix                         ");
  puts("                                                                         ");
  puts(" common options:                                                         ");
  puts("   -w fmt [lin16]  waveform format (lin16, lin8, alaw, mulaw)            ");
  puts("   -d dir          output directory                                      ");
  puts("   -m              move input waveform file to output directory          ");
  puts("   -g              save log file                                         ");
  puts("   -x str [log]    log file suffix                                       ");
  puts("   -v              verbose mode                                          ");
  puts("                                                                         ");
}


void change_file_path(char *pFileName, const char *pNewPath)
{
  char pbuff[1024];
  strcpy(pbuff, pFileName);
        
  char *psep_pos1 = strrchr(pbuff, '/');
  char *psep_pos2 = strrchr(pbuff, '\\');
  char *psep_pos = (psep_pos1 > psep_pos2 ? psep_pos1 : psep_pos2);

  if(!psep_pos)
    return;

  strcpy(pFileName, pNewPath);
  strcat(pFileName, psep_pos);
}

void change_file_suffix(char *pFileName, const char *pNewSuffix)
{
  char *pdot_pos = strrchr(pFileName, '.');
  char *psep_pos1 = strrchr(pFileName, '/');
  char *psep_pos2 = strrchr(pFileName, '\\');
  char *psep_pos = (psep_pos1 > psep_pos2 ? psep_pos1 : psep_pos2);

  if(!pdot_pos || (psep_pos && psep_pos > pdot_pos))  // dot is not found or dot is in path 
  {
    strcat(pFileName, ".");
    strcat(pFileName, pNewSuffix);
  }
  else
  {
    strcpy(pdot_pos + 1, pNewSuffix);
  }
}

void cutof_file_suffix(char *pFileName)
{
  char *sep_pos1 = strrchr(pFileName, '/');
  char *sep_pos2 = strrchr(pFileName, '\\');
  char *dot_pos = strrchr(pFileName, '.');
  char *sep_pos = (sep_pos1 > sep_pos2 ? sep_pos1 : sep_pos2);
  if(dot_pos && (!sep_pos || dot_pos > sep_pos))
    *dot_pos = '\0';
}

void get_file_path(const char *pFileName, char *pRetPath)
{
  strcpy(pRetPath, pFileName);

  char *psep_pos1 = strrchr(pRetPath, '/');
  char *psep_pos2 = strrchr(pRetPath, '\\');
  char *psep_pos = (psep_pos1 > psep_pos2 ? psep_pos1 : psep_pos2);

  if(psep_pos)
    *psep_pos = '\0';
  else
    pRetPath[0] = '\0';
}

void get_file_suffix(const char *pFileName, char *pRetSuffix)
{
  const char *psep_pos1 = strrchr(pFileName, '/');
  const char *psep_pos2 = strrchr(pFileName, '\\');
  const char *pdot_pos = strrchr(pFileName, '.');
  const char *psep_pos = (psep_pos1 > psep_pos2 ? psep_pos1 : psep_pos2);
        
  *pRetSuffix = '\0';
  if(pdot_pos && (!psep_pos || pdot_pos > psep_pos))
  strcpy(pRetSuffix, pdot_pos + 1);
}

bool rename_file(const char *pOldFile, const char *pNewFile)
{
  return (rename(pOldFile, pNewFile) == 0);
}

bool process_file(
  const char *pInputFile,
  const char *pOutputFile,
  const char *pOutputDir,
  const char *pTransSuffix,
  bool moveInputFile,
  SOfflineSpeechRecognizer3I *pSpeechRec)
{
  char poutput_file[1024];
  poutput_file[sizeof(poutput_file) - 1] = '\0';

  if (!pOutputFile || strlen(pOutputFile) == 0)
  {
    strncpy(poutput_file, pInputFile, sizeof(poutput_file) - 1);
    if (pOutputDir)
     change_file_path(poutput_file, pOutputDir);
    if(strlen(pTransSuffix) == 0 || strcmp(pTransSuffix, "") == 0)
      cutof_file_suffix(poutput_file);
    else
      change_file_suffix(poutput_file, pTransSuffix);
    pOutputFile = poutput_file;
  }

  if (!pOutputDir)
  {
    char poutput_dir[1024];
    poutput_dir[sizeof(poutput_dir) - 1] = '\0';
    get_file_path(pOutputFile, poutput_dir);
    pSpeechRec->SetOutputDirectory(poutput_dir);
  }

  if (!pSpeechRec->ProcessFile(pInputFile, pOutputFile))
    return false;

  if (moveInputFile)
  {
    char psuffix[1024];
    psuffix[sizeof(psuffix) - 1] = '\0';
    get_file_suffix(pInputFile, psuffix);

    if (poutput_file != pOutputFile)
      strncpy(poutput_file, pOutputFile, sizeof(poutput_file) - 1);

    change_file_suffix(poutput_file, psuffix);
    if (strcmp(pInputFile, poutput_file) != 0)
      rename_file(pInputFile, poutput_file);
  }

  return true;
}

bool process_list(
  const char *pListFile,
  const char *pOutputDir,
  const char *pTransSuffix,
  bool moveInputFile,
  SOfflineSpeechRecognizer3I *pSpeechRec)
{
  SFileListI *pfile_list = static_cast<SFileListI *>(BSAPICreateInstance(SIID_FILELIST));
  if (!pfile_list)
  {
    fprintf(stderr, "ERROR: Memory allocation error.\n");
    return false;
  }

  pfile_list->SetErrorHandler(&gErrorHandler);
  pfile_list->SetVerbose(false);
  pfile_list->SetTarget(0);
  pfile_list->Clear();

  if (!pfile_list->AddList(pListFile))
  {
    pfile_list->Release();
    return false;
  }

  char ptarget[1024];
  char psource[1024];
  int start;
  int end;
  float prob;

  bool result = true;
  pfile_list->FirstLine();
  while (pfile_list->GetLine(ptarget, psource, &start, &end, &prob))
  {
    result &= process_file(psource, ptarget, pOutputDir, pTransSuffix, moveInputFile, pSpeechRec);
  }

  pfile_list->Release();
  return result;
}

bool process_dir(const char *pInputDir, const char *pSuffixes, bool asyncMode)
{
  SFileSnifferI *psniffer = static_cast<SFileSnifferI *>(BSAPICreateInstance(SIID_FILESNIFFER));
  if (!psniffer)
  {
    fprintf(stderr, "ERROR: Memory allocation error.\n");
    return false;
  }

  psniffer->SetErrorHandler(&gErrorHandler);
  psniffer->SetTarget(&gFileSnifferHandler);
  psniffer->SetUseLocking(asyncMode);

  if (!psniffer->AddDirectory(pInputDir))
  {
    psniffer->Release();
    return false;
  }

  char psuffixes[1024];
  psuffixes[sizeof(psuffixes) - 1] = '\0';
  strncpy(psuffixes, pSuffixes, sizeof(psuffixes) - 1);
  char *psuffix = strtok(psuffixes, ",; ");
  while (psuffix)
  {
    psniffer->AddWantedSuffix(psuffix);
    psuffix = strtok(0, ",; ");
  }

  if (asyncMode)
  {
    if (!psniffer->ProcessFilesAsync())
    {
      psniffer->Release();
      return false;
    }

    getchar();
    psniffer->Terminate(); // stop scan, blocks until processing terminates
  }
  else
  {
    psniffer->ProcessFiles();
  }

  psniffer->Release();
  return gFileSnifferHandler.GetResult();
}

int main(int argc, char *pArgs[])
{
  const char *pinput_file   = 0;
  const char *pinput_dir    = 0;
  const char *poutput_file  = 0;
  const char *poutput_dir   = 0;
  const char *plist_file    = 0;
  const char *pconfig_file  = 0;
  const char *pwave_fmt     = "lin16";
  const char *psuffixes     = "wav";
  const char *pone_best_suffix = "trn";
  const char *plattice_suffix  = "lat";
  const char *pcn_suffix       = "cn";
  const char *plog_suffix   = "log";
  const char *pin_data_type     = SID_DEF_IN_DATA_TYPE;
  const char *pfea_fmt          = SID_DEF_FEA_FMT;
  bool auto_dir_scan_mode   = false;
  bool move_input_to_ouput  = false;
  const char *poutput_format= "str";
  unsigned int output_types = 0;
  const char *pone_best_output_format = "TXT";
  const char *plattice_output_format  = "NWPSELAl";
  const char *pcn_output_format       = "TWPSE";
  const char *ptimet_format = "default";
  int max_parallel_words    = 0;
  float min_word_log_post   = -70.0f;

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

  optind = 0;
  while (1)
  {
    int c = getopt(argc, pArgs, const_cast<char *>("-i:o:r:e:af:b:h:k:n:p:t:w:d:l:c:s:y:z:mgx:j:u:v"));
    if(c == -1)
      break;

    switch(c)
    {
      case 'i':
        pinput_file = optarg;
        break;
      case 'o':
        poutput_file = optarg;
        break;
      case 'r':
        pinput_dir = optarg;
        break;
      case 'e':
        psuffixes = optarg;
        break;
      case 'a':
        auto_dir_scan_mode = true;
        break;
      case 'f':
        poutput_format = optarg;
        break;
      case 'b':
        pone_best_output_format = optarg;
        break;
      case 'h':
        plattice_output_format = optarg;
        break;
      case 'k':
        pcn_output_format = optarg;
        break;
      case 'n':
        if(sscanf(optarg, "%d", &max_parallel_words) != 1 || max_parallel_words < 0)
        {
          fprintf(stderr, "ERROR: Invalid maximal number of parallel words in CN '%s'. "
                          "Must be positive integer or 0.\n", optarg);
          return 1;
        }
        break;
      case 'p':
        if(sscanf(optarg, "%f", &min_word_log_post) != 1 || min_word_log_post > 0)
        {
          fprintf(stderr, "ERROR: Invalid minimal posterior probability of word in log for CN '%s'. "
                          "Must be negative floating point number.\n", optarg);
          return 1;
        }
        break;
      case 't':
        ptimet_format = optarg;
        break;
      case 'w':
        pwave_fmt = optarg;
        break;
      case 'd':
        poutput_dir = optarg;
        break;
      case 'l':
        plist_file = optarg;
        break;
      case 'c':
        pconfig_file = optarg;
        break;
      case 's':
        pone_best_suffix = optarg;
        break;
      case 'y':
        plattice_suffix = optarg;
        break;
      case 'z':
        pcn_suffix = optarg;
        break;
      case 'm':
        move_input_to_ouput = true;
        break;
      case 'g':
        gStateHandler.SetSaveLog(true);
        break;
      case 'x':
        plog_suffix = optarg;
        break;
      case 'j':
        pin_data_type = optarg;
        break;
      case 'u':
        pfea_fmt = optarg;
        break;
      case 'v':
        gErrorHandler.SetVerbose(true);
        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 (!pconfig_file)
  {
    fprintf(stderr, "ERROR: Config file (-c) must be specified.\n");
    return 1;
  }

  if (!pinput_file && !plist_file && !pinput_dir)
  {
    fprintf(stderr, "ERROR: Either input file (-i), list of files (-l) or directory (-r) must be specified.\n");
    return 1;
  }

  SLicenseManagerI *plicman = BSAPIGetLicenseManager();
  if (plicman)
  {
    plicman->SetErrorHandler(&gErrorHandler);
    plicman->RegisterLicenseFile("license.dat");
  }
  
  SOfflineSpeechRecognizer3I *psrec = static_cast<SOfflineSpeechRecognizer3I *>(BSAPICreateInstance(SIID_OFFLINESREC3));
  if (!psrec)
  {
    return 1;
  }

  psrec->SetErrorHandler(&gErrorHandler);

  if (!psrec->Init(pconfig_file))
  {
    psrec->Release();
    return 1;
  }

  gStateHandler.SetLogSuffix(plog_suffix);
  psrec->SetStateHandler(&gStateHandler);

  char pout_format[128];
  snprintf(pout_format, sizeof(pout_format) -1 , ",%s,", poutput_format);
  pout_format[sizeof(pout_format) - 1] = '\0';

  if(strstr(pout_format, ",str,"))
  {
    output_types |= OOT_ONEBEST;
  }

  if(strstr(pout_format, ",lat,"))
  {
    output_types |= OOT_LATTICE;
  }

  if(strstr(pout_format, ",cn,"))
  {
    output_types |= OOT_CONFUSIONNETWORK;
  }

  psrec->SetOutputTypes(output_types);

  psrec->SetOneBestOutputFormat(pone_best_output_format);
  psrec->SetLatticeOutputFormat(plattice_output_format);
  psrec->SetConfusionNetworkOutputFormat(pcn_output_format);

  psrec->SetOutputOneBestFileSuffix(pone_best_suffix);
  psrec->SetOutputLatticeFileSuffix(plattice_suffix);
  psrec->SetOutputConfusionNetworkFileSuffix(pcn_suffix);

  psrec->SetTimeFormat(ptimet_format);

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

  // configure the waveform source
  SWaveformFormatConvertorI *pwc = static_cast<SWaveformFormatConvertorI *>(pbset->GetBlock("waveform_convertor"));
  if (!pwc)
  {
    psrec->Release();
    return 1;
  }

  pwc->SetInputFormatStr(pwave_fmt);

  // configure maximal number of parallel words in CN
  SFSTToConfusionNetworkConvertorI *pfst_cn = static_cast<SFSTToConfusionNetworkConvertorI *>(pbset->GetBlock("fst_cn_convertor"));
  if (!pfst_cn)
  {
    psrec->Release();
    return 1;
  }

  pfst_cn->SetMaxParallelWords(max_parallel_words);
  pfst_cn->SetMinWordLogPosteriorProbability(min_word_log_post);

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

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

  if (poutput_dir)
    psrec->SetOutputDirectory(poutput_dir);

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

  bool result = true;
  if (pinput_file)
    result = process_file(pinput_file, poutput_file, poutput_dir, "", move_input_to_ouput, psrec);

  if (plist_file)
    result = process_list(plist_file, poutput_dir, "", move_input_to_ouput, psrec);

  if (pinput_dir)
  {
    gFileSnifferHandler.SetOutputDir(poutput_dir);
    gFileSnifferHandler.SetTransSuffix("");
    gFileSnifferHandler.SetMoveInputToOutput(move_input_to_ouput);
    gFileSnifferHandler.SetSpeechRec(psrec);
    result = process_dir(pinput_dir, psuffixes, auto_dir_scan_mode);
  }

  psrec->Release();
  return (result ? 0 : 1);
}

---