extend-wav-with-silence.cc File Reference

#include "base/kaldi-common.h"
#include "util/common-utils.h"
#include "feat/wave-reader.h"

Include dependency graph for extend-wav-with-silence.cc:

Go to the source code of this file.

Namespaces
	kaldi
	This code computes Goodness of Pronunciation (GOP) and extracts phone-level pronunciation feature for mispronunciations detection tasks, the reference:

Functions
void	FindQuietestSegment (const Vector< BaseFloat > &wav_in, BaseFloat samp_rate, Vector< BaseFloat > *wav_sil, BaseFloat search_dur=0.5, BaseFloat seg_dur=0.1, BaseFloat seg_shift_dur=0.05)
void	ExtendWaveWithSilence (const Vector< BaseFloat > &wav_in, BaseFloat samp_rate, Vector< BaseFloat > *wav_out, BaseFloat sil_search_len, BaseFloat sil_extract_len, BaseFloat sil_extract_shift)
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 43 of file extend-wav-with-silence.cc.

References kaldi::ClassifyRspecifier(), WaveData::Data(), kaldi::ExtendWaveWithSilence(), ParseOptions::GetArg(), rnnlm::i, KALDI_ASSERT, KALDI_ERR, KALDI_LOG, kaldi::kNoRspecifier, ParseOptions::NumArgs(), MatrixBase< Real >::NumCols(), MatrixBase< Real >::NumRows(), kaldi::PrintableRxfilename(), kaldi::PrintableWxfilename(), ParseOptions::PrintUsage(), ParseOptions::Read(), WaveHolder::Read(), ParseOptions::Register(), MatrixBase< Real >::Row(), WaveData::SampFreq(), Output::Stream(), Input::Stream(), WaveHolder::Value(), and WaveHolder::Write().

                                 {
  try {
    typedef kaldi::int32 int32;
    using namespace kaldi;
    const char *usage =
        "Extend wave data with a fairly long silence at the end (e.g. 5 seconds).\n"
        "The input waveforms are assumed having silences at the begin/end and those\n"
        "segments are extracted and appended to the end of the utterance.\n"
        "Note this is for use in testing endpointing in decoding.\n"
        "\n"
        "Usage: extend-wav-with-silence [options] <wav-rspecifier> <wav-wspecifier>\n"
        "       extend-wav-with-silence [options] <wav-rxfilename> <wav-wxfilename>\n";

    ParseOptions po(usage);
    BaseFloat sil_len = 5.0,
      sil_search_len = 0.5,
      sil_extract_len = 0.05,
      sil_extract_shift = 0.025;
    po.Register("extra-silence-length", &sil_len, "the length of silence that will be "
                "appended to the end of each waveform, in seconds.");
    po.Register("silence-search-length", &sil_search_len, "the length at the beginning "
                "or end of each waveform in which to search for the quietest segment of "
                "silence, in seconds.");
    po.Register("silence-extract-length", &sil_extract_len, "the length of silence segments "
                "to be extracted from the waveform, which must be smaller than silence-"
                "search-length, in seconds.");
    po.Register("silence-extract-shift", &sil_extract_shift, "the shift length when searching "
                "for segments of silences, typically samller than silence-extract-length, "
                "in seconds.");

    po.Read(argc, argv);

    if (po.NumArgs() != 2) {
      po.PrintUsage();
      exit(1);
    }

    if (ClassifyRspecifier(po.GetArg(1), NULL, NULL) != kNoRspecifier) {
      SequentialTableReader<WaveHolder> reader(po.GetArg(1));
      TableWriter<WaveHolder> writer(po.GetArg(2));
      int32 num_success = 0;

      for(; !reader.Done(); reader.Next()){
        std::string wav_key = reader.Key();
        const WaveData &wave = reader.Value();
        BaseFloat samp_freq = wave.SampFreq();  // read sampling fequency
        const Matrix<BaseFloat> &wave_data = wave.Data();
        int32 num_chan = wave_data.NumRows(),       // number of channels in recording
          num_ext_samp  = (int32)(samp_freq * sil_len); // number of samples that will be extended
        KALDI_ASSERT(num_ext_samp > 0);
        Matrix<BaseFloat> new_wave(wave_data.NumRows(), wave_data.NumCols() + num_ext_samp);
        for(int32 i = 0; i < num_chan; i++){
          Vector<BaseFloat> wav_this_chan(wave_data.Row(i));
          Vector<BaseFloat> wav_extend(wav_this_chan.Dim() + num_ext_samp);
          ExtendWaveWithSilence(wav_this_chan, samp_freq, &wav_extend,
                                sil_search_len, sil_extract_len, sil_extract_shift);
          KALDI_ASSERT(wav_extend.Dim() == wav_this_chan.Dim() + num_ext_samp);
          new_wave.CopyRowFromVec(wav_extend, i);
        }
        WaveData wave_out(samp_freq, new_wave);
        writer.Write(wav_key, wave_out);
        num_success++;
      }
      KALDI_LOG << "Successfully extended " << num_success << " files.";
      return 0;
    } else {
      std::string wav_rxfilename = po.GetArg(1);
      std::string wav_wxfilename = po.GetArg(2);
      bool binary = true;
      Input ki(wav_rxfilename, &binary);
      WaveHolder wh;
      if (!wh.Read(ki.Stream())) {
        KALDI_ERR << "Read failure from "
                  << PrintableRxfilename(wav_rxfilename);
      }

      const WaveData& wave = wh.Value();

      BaseFloat samp_freq = wave.SampFreq();  // read sampling fequency
      const Matrix<BaseFloat> &wave_data = wave.Data();
      int32 num_chan = wave_data.NumRows(),       // number of channels in recording
        num_ext_samp  = (int32)(samp_freq * sil_len); // number of samples that will be extended
      KALDI_ASSERT(num_ext_samp > 0);
      Matrix<BaseFloat> new_wave(wave_data.NumRows(), wave_data.NumCols() + num_ext_samp);
      for(int32 i = 0; i < num_chan; i++){
        Vector<BaseFloat> wav_this_chan(wave_data.Row(i));
        Vector<BaseFloat> wav_extend(wav_this_chan.Dim() + num_ext_samp);
        ExtendWaveWithSilence(wav_this_chan, samp_freq, &wav_extend,
                              sil_search_len, sil_extract_len, sil_extract_shift);
        KALDI_ASSERT(wav_extend.Dim() == wav_this_chan.Dim() + num_ext_samp);
        new_wave.CopyRowFromVec(wav_extend, i);
      }
      WaveData wave_out(samp_freq, new_wave);

      Output ko(wav_wxfilename, binary, false);
      if (!WaveHolder::Write(ko.Stream(), true, wave_out)) {
        KALDI_ERR << "Write failure to "
                  << PrintableWxfilename(wav_wxfilename);
      }
      // we do not print any log messages here
    }
  } catch(const std::exception &e) {
    std::cerr << e.what();
    return -1;
  }
}