g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_sp.a

SignalDetector();
SignalDetector(ALGORITHM algorithm,IMPLEMENTATION implementation);
boolean apply(Vector<VectorFloat> signal);
boolean getStartPoints(float& t1);
boolean getEndTime(VectorFloat& start_time, 
		   VectorFloat& end_time, 
		   long channel_index_a);

SignalDetector sig_det;
  Sof sof;
  String file;
  int num_quit_try = 100;
  file.assign(L"./diagnose_param.sof");
  sof.open(file, File::READ_ONLY);
  sig_det.read(sof, (long)0);
  sig_det.init();
  Vector<VectorFloat> data(1);
  AudioFile src;
  src.setFileFormat(AudioFile::RAW);  
  src.setFileType(AudioFile::BINARY);  
  src.setSampleFrequency(8000);
  src.setSampleNumBytes(2);
  src.setNumChannels(1);
  src.open(L"./diagnose.raw");
  long N = sig_det.getNSamplesToRead(); 
  long i = 0;
  long len = src.getNumSamples(); 
  len = (long)len / N;     
  float t1, t2;
  long num_utt, nf = 0;
  while (i <= len + num_quit_try) {
 	
    src.getData(data(0), 0, i * N, N); 
    i++;	
    sig_det.apply(data);
    nf++;
}
  VectorFloat start_points;	
  VectorFloat stop_points; 			
  sig_det.getEndTime(start_points, stop_points, 0);	
  src.close();
  sof.close();

An example with comments can be found at the end of the page.

This class is used to detect the start and stop times of a segment of data in a stream of data. The audio data, which is represented as a multichannel sequence of floating point data is handled as a vector of vector floats. The audio data is passed to this class in variable-sized amounts of data. Methods are provided to determine the state of the detection, including when a valid signal has been detected.

• algorithm name:

  ALGORITHM algorithm_d;

• implementation name:

  IMPLEMENTATION implementation_d;

• static memory manager:

  static MemoryManager mgr_d;

• debugging parameters:

  DebugLevel debug_level_d;

• circular buffer which is used to hold audio:

  Vector<CircularBuffer<Float> > cbuf_d;

• signal processing parameters:

  Long num_channels_d;

  Float sample_frequency_d;

  Long sample_num_bytes_d;

  Long channel_to_be_processed_d;

  Float frame_duration_d;

  Float window_duration_d;

  Float preemphasis_d;

• utterance pad time:

  Float pad_time_d;

• signal level-related energy parameters:

  Float signal_nominal_level_d;

  Float signal_adaptation_delta_d;

  Float signal_adaptation_constant_d;

• noise level-related energy parameters:

  Float noise_nominal_level_d;

  Float noise_adaptation_delta_d;

  Float noise_adaptation_constant_d;

  Float noise_floor_d;

• utterance related parameters:

  Float utterance_minimum_duration_d;

  Float utterance_minimum_separation_d;

  Float utterance_maximum_duration_d

  Float utt_delta_d;

• adaptive thresholds:

  Float noise_threshold_d;

  Float signal_threshold_d;

• variables relating to signal processing:

   long frame_sample_duration_d;

  long window_sample_duration_d;

• utterance-related parameters:

  long utterance_minimum_sample_duration_d;

  long utterance_minimum_sample_separation_d;

• state machine:

  Vector<Long> states_d;

  Vector<Long> durations_d;

• useful counters:

  Vector<Long> num_frame_d;

• circular buffer that holds energy states:

  Vector<CircularBuffer<Long> > egy_d;

• circular buffer related parameters:

  long egy_len_d;

  long egy_cur_d;

  long egy_rlse_d;

  Vector<VectorFloat> egy_data_window_d;

• utterance pattern matching parameters:

  Vector<Long> sig_patn_d;

  long sig_patn_len_d;

  Vector<Long> nse_patn_d;

  long nse_patn_len_d;

• flag that keeps track whether an utterance is in progress:

  Vector<Boolean> utt_in_progress_d;

• enpoint related values:

  Vector<VectorFloat> start_points_d;

  Vector<VectorFloat> stop_points_d;

  Vector<Long> utt_coarse_beg_d;

  Vector<Long> utt_coarse_end_d;

  Vector<Long> utt_egy_beg_d;

  Vector<Long> utt_egy_end_d;

  Vector<Long> utt_zc_beg_d;

  Vector<Long> utt_zc_end_d;

  Vector<Long> num_endpoints_d;

• zerocrossing related values:

  Vector<CircularBuffer<Long> > zc_d;

  Vector<VectorFloat> zc_data_window_d;

  Long zc_utterance_thresh_d;

  Long zc_negative_thresh_d;

  Long zc_positive_thresh_d;

• useful sacling factor:

  Float win_dur_scale_factor_d;

• This example demonstrates how to use SignalDetector class:

    SignalDetector sig_det;
    Sof sof;
    String file;
  
    // the number of times to try after the end of file
    //
    int num_quit_try = 100;
    file.assign(L"./diagnose_param.sof");
   
    // try opening the file
    //
    sof.open(file, File::READ_ONLY);
  
    // read the sof file into the signal detector object
    //
    sig_det.read(sof, (long)0);
  
    // initialise the signal detector object
    //
    sig_det.init();
    Vector<VectorFloat> data(1);
    AudioFile src;
  
    // set the file format
    //
    src.setFileFormat(AudioFile::RAW);  
  
    // set the file type
    //
    src.setFileType(AudioFile::BINARY);  
  
    // set the sample frequency, number of bytes per sample and number
    // of channels
    //
    src.setSampleFrequency(8000);
    src.setSampleNumBytes(2);
    src.setNumChannels(1);
    
    // open file, default is read only
    //
    src.open(L"./diagnose.raw");
  
    // defined the sample number for one process
    //
    long N = sig_det.getNSamplesToRead(); 
    
    // define local variable
    //
    long i = 0;  
  
    // get number of samples in this file
    //
    long len = src.getNumSamples(); 
    
    // get how many frames we need to process
    //
    len = (long)len / N;     
    
    // define the start and the stop times
    //
    float t1, t2;
    
    // define the number od utterances anf the number of frames
    //
    long num_utt, nf = 0;
    
    // check to see if an utterance has been detected. quit reading the data
    // only if a valid utterance has been detected.
    //
    while (i <= len + num_quit_try) {
      
      src.getData(data(0), 0 ,i * N, N); 
      i++;
         
      // process data
      //
      sig_det.apply(data);
          
    }
   
    // get the endpoints
    //
    VectorFloat start_points;	
    VectorFloat stop_points; 			
    sig_det.getEndTime(start_points, stop_points, 0);	
    // close the audiofile object and the sof file object
    //
    src.close();
    sof.close();
   

• none.