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

#include <FeatureFile.h>

FeatureFile();
long getBufferedData(Vector<AlgorithmData>& data,
	             long start_pos = DEF_START_POS,
	             long num_elem = DEF_NUM_ELEM);
long getBufferedData(VectorFloat& data, long channel_tag,
	             long start_pos, long num_elem);
boolean setFileType(FILE_TYPE file_type);

FeatureFile src;
src.open(L"/tmp/input.sof");

Vector <VectorFloat> data(1);
src.getBufferedData(data(0), 0, 50, 10);

Filename output(L"/tmp/output.sof");

FeatureFile dst;
dst.open(output, File::WRITE_ONLY);
dst.writeFeatureData(data, 0);

• define file format-related parameters

  FILE_TYPE file_type_d;

  FILE_FORMAT file_format_d;

  COMP_TYPE compression_type_d;

  Double amplitude_range__d;

• define signal-related parameters:

  Double amplitude_range_d;

  Long num_channels_d;

  String id_d;

  Long num_features_d;

  DATA_TYPE data_type_d;

  AlgorithmData::COEF_TYPE coef_type_d;

• define Sof file-related parameters:

  Long tag_d;

  Sof in_sof_d;

• define buffer-related variables:

  Long block_size_d;

  Long buf_size_d;

• signal processing-related parameters:

  Float frame_duration_d;

  Float sample_frequency_d;

• define a variable to hold the data:

  Vector v_d;

• raw feature file-related parameters:

  File raw_features_d;

  Vector<CircularBuffer<VectorFloat> > buffers_d;

  Vector buf_end_ftr_d;

• define a flag to keep track of the presence of data: since the FeatureFile class can either hold configuration information for auxiliary file types (RAW FEATURES) or the actual features data, this flag lets the class keep track of whether data is actually present in the file.

  boolean no_data_d;

• define an end of file flag:

  boolean end_of_file_d;

• define a variable to keep track of file position: if we are writing to a binary Sof file we need to keep track of where we write the FeatureFile object's size and the vector's length

  long sof_length_pos_d;

• declare a static debug level for all class instantiations

  static Integral::DEBUG debug_level_d;

• define a static memory manager

  static MemoryManager mgr_d;

• This example demonstrates how to use read data from a FeatureFile and write this data to another FeatureFile.

  // isip include files
  //
  #include <FeatureFile.h>
         
  // main program starts here
  //
  int main() {
    // declare FeatureFile objects for read and write
    //
    FeatureFile ftr_in;
    FeatureFile ftr_out;
  
    // define local variable to hold data
    //
    Vector<AlgorithmData> data;
  
    // define input and output file name
    //
    Filename ftr_filename(L"$ISIP_DEVEL/doc/examples/data/features/AD.sof");;
    Filename ftr_text(L"AD_text.sof");;
  
    // prepare parameters for input file
    //
    ftr_in.setNumChannels(1);                  // set number of channel
    ftr_in.setFileType(FeatureFile::BINARY);   // set file type
    ftr_in.setFileFormat(FeatureFile::SOF);    // set file format 
    ftr_in.setID(L"AD");                       // set id
    ftr_in.setName(L"FEATURES");               // set feature name
  
    // prepare parameters for output file
    ftr_out.setNumChannels(1);                 // set number of channel
    ftr_out.setFileType(FeatureFile::TEXT);    // set file type
    ftr_out.setFileFormat(FeatureFile::SOF);   // set file format 
    ftr_out.setID(L"AD");                      // set id
    ftr_out.setName(L"FEATURES");              // set feature name
  
    // open input and output file
    //
    ftr_in.open(ftr_filename);
    ftr_out.open(ftr_text, File::WRITE_ONLY);
  
    // define local variable
    //
    long num_input=0;
    data.setLength(1);
  
    // get number of frames stored in file
    //
    long len = ftr_in.getNumFrames();
  
    // loop for read data from a input file and write data out to a file
    //
    for(long i=0; i<(long)len; i++) {
  
      // get feature data from the input file
      //
      num_input = ftr_in.getBufferedData(data, i, (long)1);
  
      // write feature data to the output file
      //
      ftr_out.writeFeatureData(data);
    }
  
    // close input and output file
    //
    ftr_in.close();  
    ftr_out.close();
  
    // exit gracefully
    //
    Integral::exit();
  }

• FeatureFile provides two interfaces for most of its methods: one uses AlgorithmData, the other uses VectorFloat. The reason for these are:
  
  
  • VectorFloat is the most popular data type currently in use for features;
    
    
  • AlgorithmData is a wrapper that handles most data types supported in the IFCs.
  
  Though using the AlgorithmData interface is more powerful, for application programmers focused on basic DSP operations, it might be a little cumbersome. Hence, we provide a simpler alternative in the form of VectorFloat.