decoder.h

这是处理语音信号的程序

  }

  logical_1 set_num_feat_cc(int_4 value) {
    num_feat_d = value;
    return ISIP_TRUE;
  }

  logical_1 set_num_nbest_cc(int_4 value) {
    num_nbest_d = value;
    return ISIP_TRUE;
  }

  logical_1 set_num_hist_cc(int_4 value) {
    num_hist_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_beams_cc(float_4* values);

  logical_1 set_mapmi_limit_cc(int_4 value) {
    mapmi_limit_d = value;
    return ISIP_TRUE;
  }

  logical_1 set_max_words_cc(int_4 value) {
    num_wordends_d = value;
    return ISIP_TRUE;
  }

  logical_1 set_nbest_maxpaths_cc(int_4 value) {
    nbest_max_paths_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_nbest_beam_cc(int_4 value) {
    nbest_beam_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_lmscale_cc(float_4 value) {
    lmscale_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_wdpenalty_cc(float_4 value) {
    wdpenalty_d = value;
    return ISIP_TRUE;
  }

  logical_1 set_manager_cc(Memory_manager* manager) {
    manager_d = manager;
    Link_list::set_manager_cc(manager_d);
    return ISIP_TRUE;
  }
  
  logical_1 set_num_levels_cc(int_4 value) {
    num_levels_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_context_size_cc(int_4 value) {
    cd_size_d = value;
    return ISIP_TRUE;
  }
  
  logical_1 set_ngram_order_cc(int_4 value) {
    ngram_order_d = value;
    return ISIP_TRUE;
  }

  // method to determine and set the history length
  //
  logical_1 set_hist_length_cc();

  // set the flag if the decoder writes compacted output lattice
  //
  logical_1 set_compact_lattice_cc(logical_1 compact_lattice) {
    compact_lattice_d = compact_lattice;
    return ISIP_TRUE;
  }
  
  // methods to get parameters
  //
  logical_1 get_restructure_memory_cc() {
    return restructure_memory_d;
  }
  
  logical_1 get_function_mode_cc(int_4& value) {
    value = function_mode_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_context_mode_cc(int_4& value) {
    value = context_mode_d;
    return ISIP_TRUE;
  }

  logical_1 get_align_mode_cc(int_4& value) {
    value = align_mode_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_input_format_cc(int_4& value) {
    value = input_format_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_delta_win_cc(int_4& value) {
    value = delta_win_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_delta_cc(logical_1& value) {
    value = delta_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_acc_cc(logical_1& value) {
    value = acc_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_input_feature_format_cc(int_4& value) {
    value = input_feature_format_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_demo_mode_cc(logical_1& value) {
    value = demo_mode_d;
    return ISIP_TRUE;
  }

  logical_1 get_frame_cc(int_4& value) {
    value = frame_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_frame_dur_cc(float_4& value) {
    value = frame_dur_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_num_feat_cc(int_4& value) {
    value = num_feat_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_num_nbest_cc(int_4& value) {
    value = num_nbest_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_num_hist_cc(int_4& value) {
    value = num_hist_d;
    return ISIP_TRUE;
  }

  logical_1 get_beams_cc(float_4*& values) {
    values = beam_d;
    return ISIP_TRUE;
  }

  logical_1 get_mapmi_limit_cc(int_4& value) {
    value = mapmi_limit_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_max_words_cc(int_4& value) {
    value = num_wordends_d;
    return ISIP_TRUE;
  }

  logical_1 get_nbest_maxpaths_cc(int_4& values) {
    values = nbest_max_paths_d;
    return ISIP_TRUE;
  }

  logical_1 get_nbest_beam_cc(int_4& values) {
    values = nbest_beam_d;
    return ISIP_TRUE;
  }

  logical_1 get_lmscale_cc(float_4& value) {
    value = lmscale_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_wdpenalty_cc(float_4& value) {
    value = wdpenalty_d;
    return ISIP_TRUE;
  }

  logical_1 get_manager_cc(Memory_manager*& manager) {
    manager = manager_d;
    return ISIP_TRUE;
  }

  logical_1 get_num_levels_cc(int_4& value) {
    value = num_levels_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_context_size_cc(int_4& value) {
    value = cd_size_d;
    return ISIP_TRUE;
  }
  
  logical_1 get_ngram_order_cc(int_4& value) {
    value = ngram_order_d;
    return ISIP_TRUE;
  }

  logical_1 get_decode_time_cc(float_8& time) {
    time = decode_time_d;
    return ISIP_TRUE;
  }

  // methods to set the decoder state for decoding and do cleanup
  //
  logical_1 init_cc();
  logical_1 reset_cc();
  logical_1 clean_cc(logical_1 isCommunicator = ISIP_FALSE);
  logical_1 clean_instances_cc();
  logical_1 active_instances_cc();

  // methods to decode an utterance
  //
  logical_1 decode_cc(FILE* fin, FILE* fout) {
    return decode_cc(fin, fout, (FILE*)NULL, (FILE*)NULL);
  }
  
  logical_1 decode_cc(FILE* fin, FILE* fout, FILE* flat, FILE* fnbest);

  // Communicator API
  //
  logical_1 decode_cc(double* data, int num_samples);  
  logical_1 decode_cc(char_1*& hypo, char_1*& align, char_1* hypo_file = NULL,
		      char_1* mfc_file = NULL);
  
  // special model functions
  //
  logical_1 find_sp_cc();
  logical_1 find_sil_cc();

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

  // read a feature vector for decoding
  //
  logical_1 read_features_cc(FILE* fp, logical_1& start);

  // read a HTK header
  //
  logical_1 read_htk_header_cc(FILE* fp);

  // Communicator API
  // rad a feature vector from data buffer for decoding
  //
  logical_1 read_features_cc();  

  // functions to read keyborad input in demo mode
  //
  logical_1 read_key_cc();

  // get the cd model index
  //
  int_4 get_model_index_cc(int_4* phn);

  // methods to project state-level traces and advance model-internal
  // paths, and activate instances
  //
  logical_1 project_states_cc();
  
  // method to handle short pause skips in non-crossword modes
  //
  logical_1 project_sp_word_cc(Trace* trace, Lex_node* lexnode, int_4 phone);

  // method to propagate traces between models i.e. model and word
  // levels
  //
  logical_1 enter_models_cc();

  // method to generate next model indices including handling of word
  // boundaries
  //
  logical_1 next_models_cc(Trace* trace);

  // method to add LM lookahead scores and grow correct models,
  // handling word boundary conditions properly
  //
  logical_1 grow_models_cc(Trace* trace, Lex_node* lexch, int_4* phn);

  // method to create traces in the entry states of models
  //
  logical_1 grow_trace_cc(Trace* trace, Instance* inst, int_4 phone,
			  Lex_node* lexnext);

  // method to project traces to word level
  //
  logical_1 exit_word_cc();

  // method to determine word history and add word penalty score
  //
  logical_1 set_history_cc(Trace* trace, Lex_node* lexnode, int_4 phone);
  
  // method to gets the next histwords based on the current histwords
  // and the current node
  //
  void_p* next_histwords_cc(void_p* histwords, void_p curr_node);
  
  // methods to switch from an ngram LM to a temporary network LM
  //
  logical_1 switch_lm_cc(Trace* trace, Lex_node* strlex);
  void_p* get_newhist_cc(Lex_node* strlex);
  
  // methods to find or update an instance
  //
  logical_1 get_instance_cc(Instance*& inst, History* hist, Lex_node* lex,
			    int_4 phn);

  // method to compute lm look-ahead score
  //
  float_4 get_lmahead_cc(Lex_node* lex, History* hist);
  
  // methods for instance pruning
  //
  logical_1 prune_inst_cc();

  // methods for beam pruning of traces
  //
  logical_1 beam_prune_cc();
  logical_1 set_beam_cc(int_4 level);
  
  // method for finding the max number of word ends pruning threshold
  //
  logical_1 word_cutoff_cc();

  // methods to insert traces in appropriate lists
  //
  logical_1 insert_model_cc(Link_list*& tr_list, Trace* trace);
  logical_1 insert_word_cc(Link_list*& tr_list, Trace* trace);

  // methods to perform partial cleanup
  //
  logical_1 update_history_cc();

  // methods to determine output hypotheses
  //
  logical_1 find_nbest_cc();      // partial word-end hypotheses for demo
  logical_1 backtrace_cc();       // full paths to be output at the end  
  
  // methods to create output word graph (lattice)
  //
  logical_1 build_lattice_cc(FILE* fp);
  logical_1 build_lattice_cc(Lattice*& outlat);
  logical_1 ngram_to_lattice_cc(int_4& num_nodes, int_4& num_arcs,
				Hash_table*& newlat, History* hist,
				Lattice_node* latnode, void_p oldnode,
				float_4 score);
  logical_1 lattice_to_lattice_cc(int_4& num_nodes, int_4& num_arcs,
				  Hash_table*& newlat, History* hist,
				  Lattice_node* latnode,
				  Lattice_node* oldnode, float_4 score);
  logical_1 add_arcs_cc (int_4 level, Word** words,
			 int_4 wdcount, float_4 score,
			 History* hist, Lattice_node* latnode,
			 Lattice_node* latn, int_4& num_arcs);
  
  // methods to access the grammars used wiht hierarchical grammars
  //
  Lattice* get_lattice_cc(char_1* grammar_name);

  // methods to write decoder output to file
  //
  logical_1 write_output_cc(FILE* fp);
  logical_1 write_output_cc(char_1*& hypo);  

  // methods to write the nbest list to file
  //
  logical_1 write_nbest_cc(FILE* fp, Path_list* final_path_list);
  logical_1 write_nbest_cc(char_1*& hypo, Path_list* final_path_list);

  // method of check if the current frame is in the model-level
  // endpoint-list
  //
  logical_1 is_curframe_mendpt_cc();
};

// end of file
//
# endif