online-speex-wrapper.h

Go to the documentation of this file.

// online2/online-speex-wrapper.h

// Copyright   2014  IMSL, PKU-HKUST (author: Wei Shi)

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.


#ifndef KALDI_ONLINE2_ONLINE_SPEEX_WRAPPER_H_
#define KALDI_ONLINE2_ONLINE_SPEEX_WRAPPER_H_

#ifdef HAVE_SPEEX
  #include <speex/speex.h>
  typedef SpeexBits SPEEXBITS;
#else
  typedef char SPEEXBITS;
#endif

#include "matrix/kaldi-vector.h"
#include "itf/options-itf.h"

namespace kaldi {

struct SpeexOptions {
  BaseFloat sample_rate;

  int32 speex_quality;

  int32 speex_bits_frame_size;

  int32 speex_wave_frame_size;

  SpeexOptions(): sample_rate(16000.0),
                  speex_quality(10),
                  speex_bits_frame_size(106),
                  speex_wave_frame_size(320) { }

  void Register(OptionsItf *opts) {
    opts->Register("sample-rate", &sample_rate, "Sample frequency of the waveform.");
    opts->Register("speex-quality", &speex_quality, "Speex speech quality.");
    opts->Register("speex-bits-frame-size", &speex_bits_frame_size,
                   "#bytes of each Speex compressed frame.");
    opts->Register("speex-wave-frame-size", &speex_wave_frame_size,
                   "#samples of each waveform frame.");
  }
};

class OnlineSpeexEncoder {
  public:
    OnlineSpeexEncoder(const SpeexOptions &config);
    ~OnlineSpeexEncoder();

    void AcceptWaveform(int32 sample_rate,
           const VectorBase<BaseFloat> &waveform);

    void InputFinished();

    void GetSpeexBits(std::vector<char> *spx_bits) {  // call it after AcceptWaveform
      *spx_bits = speex_encoded_char_bits_;
      speex_encoded_char_bits_.clear();
    }
  private:
    int32 speex_frame_size_;  // in bytes, will be different according to the quality
    int32 speex_encoded_frame_size_;  // in samples, typically 320 in wideband mode, 16kHz
#ifdef HAVE_SPEEX
    void *speex_state_;  // Holds the state of the speex encoder
#endif
    SPEEXBITS speex_bits_;

    Vector<BaseFloat> waveform_remainder_;      // Holds the waveform that have not been processed

    // Holds the Speex-encoded char bits, will be peaked by GetSpeexBits().
    // We use a vector container rather than a char-type pointer because
    // it's a little easier to expand.
    std::vector<char> speex_encoded_char_bits_;

    BaseFloat sample_rate_;
    bool input_finished_;

    void Encode(const VectorBase<BaseFloat> &wave,
                std::vector<char> *speex_encoder_bits) ;
};

class OnlineSpeexDecoder {
  public:
    OnlineSpeexDecoder(const SpeexOptions &config);
    ~OnlineSpeexDecoder();

    void AcceptSpeexBits(const std::vector<char> &spx_enc_bits);

    void GetWaveform(Vector<BaseFloat> *waveform) {  // call it after AcceptSpeexBits
      *waveform = waveform_;
      waveform_.Resize(0);
    }
  private:
    int32 speex_frame_size_;  // in bytes, will be different according to the quality
    int32 speex_decoded_frame_size_;  // in samples, typically 320 in wideband mode, 16kHz

#ifdef HAVE_SPEEX
    void *speex_state_;  // Holds the state of the speex decoder
#endif
    SPEEXBITS speex_bits_;


    Vector<BaseFloat> waveform_;  // Holds the waveform decoded from speex bits
    std::vector<char> speex_bits_remainder_;

    void Decode(const std::vector<char> &speex_char_bits,
                Vector<BaseFloat> *decoded_wav) ;
};

}  // namespace kaldi

#endif  // KALDI_ONLINE2_ONLINE_SPEEX_WRAPPER_H_