hmm_03.cc

这是一个从音频信号里提取特征参量的程序

// file: $isip/class/pr/HiddenMarkovModel/hmm_03.cc
// version: $Id: hmm_03.cc,v 1.38 2003/04/16 13:23:33 alphonso Exp $
//

// isip include files
//
#include "HiddenMarkovModel.h"
#include <Sof.h>

// method: read
//
// arguments:
//  Sof& sof: (input) sof file object
//  long tag: (input) sof object instance tag
//  const String& name: (input) sof object instance name
//
// return: a boolean indicating status
//
// this method has the object read itself from an Sof file
//
boolean HiddenMarkovModel::read(Sof& sof_a, long tag_a, const String& name_a) {

  // get the instance of the object from the Sof file
  //
  if (!sof_a.find(name_a, tag_a)) {
    return false;
  }

  // read the actual data from the sof file
  //
  return readData(sof_a);
}

// method: readData
//
// arguments:
//  Sof& sof: (input) sof file object
//  const String& pname: (input) parameter name
//  long size: (input) number of bytes in file
//  boolean param: (input) is the parameter specified?
//  boolean nested: (input) is this nested?
//
// return: logical error status
//
// this method has the object read itself from an Sof file. it assumes
// that the Sof file is already positioned correctly.
//
boolean HiddenMarkovModel::readData(Sof& sof_a, const String& pname_a,
				    long size_a,
				    boolean param_a, boolean nested_a) {

  // allocate a parser
  //
  SofParser parser;
  parser.setDebug(debug_level_d);

  // ignore implicit parameter setting
  //
  
  // are we nested?
  //
  if (nested_a) {
    parser.setNest();
  }
    
  // load the parser
  //
  if (!parser.load(sof_a, size_a)) {

      // return a warning message
      //
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
  }
  
  // read the algorithm
  //
  if (parser.isPresent(sof_a, PARAM_ALGORITHM)) {
    if (!ALGO_MAP.readElementData((long&)algorithm_d, sof_a, PARAM_ALGORITHM,
				  parser.getEntry(sof_a, PARAM_ALGORITHM))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    algorithm_d = DEF_ALGORITHM;
  }

  // read the implementation
  //
  if (parser.isPresent(sof_a, PARAM_IMPLEMENTATION)) {
    if (!IMPL_MAP.readElementData((long&)implementation_d, sof_a,
				  PARAM_IMPLEMENTATION,
			      parser.getEntry(sof_a, PARAM_IMPLEMENTATION))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    implementation_d = DEF_IMPLEMENTATION;
  }
  
  // read the adaptation supervision mode
  //
  if (parser.isPresent(sof_a, PARAM_ADAPT_SUPERVISION_MODE)) {
    if (!ADAPT_SUP_MODE_MAP.readElementData(
			      (long&)adapt_supervision_mode_d, sof_a,
			      PARAM_ADAPT_SUPERVISION_MODE,
			      parser.getEntry(sof_a,
					      PARAM_ADAPT_SUPERVISION_MODE))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    adapt_supervision_mode_d = DEF_ADAPT_SUPERVISION_MODE;
  }
  
  // read the adaptation sequence mode
  //
  if (parser.isPresent(sof_a, PARAM_ADAPT_SEQUENCE_MODE)) {
    if (!ADAPT_SEQ_MODE_MAP.readElementData(
				  (long&)adapt_sequence_mode_d, sof_a,
				  PARAM_ADAPT_SEQUENCE_MODE,
			      parser.getEntry(sof_a,
					      PARAM_ADAPT_SEQUENCE_MODE))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    adapt_sequence_mode_d = DEF_ADAPT_SEQUENCE_MODE;
  }
  
  // read the number of search levels
  //
  if (parser.isPresent(sof_a, PARAM_NUM_LEVELS)) {
    if (!num_levels_d.readData(sof_a, PARAM_NUM_LEVELS,
			       parser.getEntry(sof_a,
						PARAM_NUM_LEVELS))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    num_levels_d.assign(DEF_NUM_LEVELS);
  }
  
  // read the transcription bounds flag
  //
  if (parser.isPresent(sof_a, PARAM_TRANSCRIPTION_BOUNDS)) {
    if (!transcription_bounds_d.readData(sof_a, PARAM_TRANSCRIPTION_BOUNDS,
					 parser.getEntry(sof_a,
					       PARAM_TRANSCRIPTION_BOUNDS))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    transcription_bounds_d.assign(DEF_TRANSCRIPTION_BOUNDS);
  }
  
  // read the number of mixtures
  //
  if (parser.isPresent(sof_a, PARAM_NUM_MIXTURES)) {
    if (!num_mixtures_d.readData(sof_a, PARAM_NUM_MIXTURES,
			       parser.getEntry(sof_a,
						PARAM_NUM_MIXTURES))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    num_mixtures_d.assign(DEF_NUM_MIXTURES);
  }
  
  // read the levels to update
  //
  if (parser.isPresent(sof_a, PARAM_UPDATE_LEVELS)) {
    if (!update_levels_str_d.readData(sof_a, PARAM_UPDATE_LEVELS,
				      parser.getEntry(sof_a,
						      PARAM_UPDATE_LEVELS))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }
  }
  
  // read the levels to decoding output
  //
  if (parser.isPresent(sof_a, PARAM_OUTPUT_LEVELS)) {
    if (!output_levels_str_d.readData(sof_a, PARAM_OUTPUT_LEVELS,
				      parser.getEntry(sof_a,
						      PARAM_OUTPUT_LEVELS))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }
  }
  
  // read the number of iterations across the data
  //
  if (parser.isPresent(sof_a, PARAM_NUM_ITERATIONS)) {
    if (!num_iterations_d.readData(sof_a, PARAM_NUM_ITERATIONS,
			       parser.getEntry(sof_a,
						PARAM_NUM_ITERATIONS))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    num_iterations_d.assign(DEF_NUM_ITERATIONS);
  }  

  // read the minimum model probability deviance
  //
  if (parser.isPresent(sof_a, PARAM_MIN_MPD)) {
    if (!min_mpd_d.readData(sof_a, PARAM_MIN_MPD,
			       parser.getEntry(sof_a,
						PARAM_MIN_MPD))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    min_mpd_d.assign(DEF_MIN_MPD);
  }

  // read the floor on the occupancy probability
  //
  if (parser.isPresent(sof_a, PARAM_MIN_OCCUPANCY)) {
    if (!min_occupancy_d.readData(sof_a, PARAM_MIN_OCCUPANCY,
			       parser.getEntry(sof_a,
						PARAM_MIN_OCCUPANCY))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    min_occupancy_d.assign(DEF_MIN_OCCUPANCY);
  }

  // read the minimum number of times a model must occur before update
  //
  if (parser.isPresent(sof_a, PARAM_MIN_MODEL_COUNT)) {
    if (!min_model_count_d.readData(sof_a, PARAM_MIN_MODEL_COUNT,
			       parser.getEntry(sof_a,
						PARAM_MIN_MODEL_COUNT))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    min_model_count_d.assign(DEF_MIN_MODEL_COUNT);
  }      

  // read the context level
  //
  if (parser.isPresent(sof_a, PARAM_CONTEXT_LEVEL)) {
    if (!context_level_d.readData(sof_a, PARAM_CONTEXT_LEVEL,
			       parser.getEntry(sof_a,
						PARAM_CONTEXT_LEVEL))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }

  // read the context order
  //
  if (parser.isPresent(sof_a, PARAM_CONTEXT_ORDER)) {
    if (!context_order_d.readData(sof_a, PARAM_CONTEXT_ORDER,
			       parser.getEntry(sof_a,
						PARAM_CONTEXT_ORDER))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }    

  // read the transcription level
  //
  if (parser.isPresent(sof_a, PARAM_TRANSCRIPTION_LEVEL)) {
    if (!transcription_level_d.readData(sof_a, PARAM_TRANSCRIPTION_LEVEL,
			       parser.getEntry(sof_a,
						PARAM_TRANSCRIPTION_LEVEL))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    transcription_level_d.assign(DEF_TRANSCRIPTION_LEVEL);
  }

  // read the force alignment level
  //
  if (parser.isPresent(sof_a, PARAM_FORCE_ALIGNMENT_LEVEL)) {
    if (!force_alignment_level_d.readData(sof_a, PARAM_FORCE_ALIGNMENT_LEVEL,
					  parser.getEntry(sof_a,
					      PARAM_FORCE_ALIGNMENT_LEVEL))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }
  else {
    force_alignment_level_d.assign(DEF_FORCE_ALIGNMENT_LEVEL);
  }
  
  // read the model file
  //
  if (parser.isPresent(sof_a, PARAM_LANGUAGE_MODEL_FILE)) {
    if (!lm_model_file_d.readData(sof_a, PARAM_LANGUAGE_MODEL_FILE,
			       parser.getEntry(sof_a,
						PARAM_LANGUAGE_MODEL_FILE))) {
      return Error::handle(name(), L"readData", Error::READ,
			   __FILE__, __LINE__, Error::WARNING);
    }       
  }

  // read the stat file
  //
  if (parser.isPresent(sof_a, PARAM_ACOUSTIC_MODEL_FILE)) {
    if (!ac_model_file_d.readData(sof_a, PARAM_ACOUSTIC_MODEL_FILE,
 			      parser.getEntry(sof_a,
 					      PARAM_ACOUSTIC_MODEL_FILE))) {
       
      // return a warning message
      //
      return Error::handle(name(), L"readData", Error::READ,
  			   __FILE__, __LINE__, Error::WARNING);
    }       
  }