// gst-plugin/gst-online-gmm-decode-faster.cc

// Copyright 2013  Tanel Alumae, Tallinn University of Technology
// Copyright 2012 Cisco Systems (author: Matthias Paulik)
// Modifications to the original contribution by Cisco Systems made by:
// Vassil Panayotov

// 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.
/**
 * GStreamer plugin for automatic speecg recognition.
 * Based on Kaldi's OnlineGmmDecodeFaster decoder.
 *
 * <refsect2>
 * <title>Example launch line</title>
 * |[
 * gst-launch-1.0  filesrc location=test.wav \
 *     ! decodebin ! audioconvert ! audioresample \
 *     ! onlinegmmdecodefaster rt-min=0.8 rt-max=0.85  max-active=4000 beam=12.0 acoustic-scale=0.0769 \
 *                              model=$ac_model/model fst=$ac_model/HCLG.fst \
 *                              word-syms=$ac_model/words.txt silence-phones="1:2:3:4:5" \
 *                              lda-mat=$trans_matrix \
 *     ! filesink location=$resultfile
 * ]|
 * </refsect2>
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#else
#  define VERSION "1.0"
#endif

#include <utility>
#include <string>
#include <algorithm>

#include "gst-plugin/kaldimarshal.h"
#include "gst-plugin/gst-online-gmm-decode-faster.h"

#include "feat/feature-mfcc.h"
#include "online/online-audio-source.h"
#include "online/online-feat-input.h"
#include "online/online-decodable.h"
#include "online/online-faster-decoder.h"
#include "online/onlinebin-util.h"
#include "util/simple-options.h"
#include "util/parse-options.h"

namespace kaldi {

GST_DEBUG_CATEGORY_STATIC(gst_online_gmm_decode_faster_debug);
#define GST_CAT_DEFAULT gst_online_gmm_decode_faster_debug

enum {
  HYP_WORD_SIGNAL,
  LAST_SIGNAL
};

enum {
  PROP_0,
  PROP_SILENT,
  PROP_MODEL,
  PROP_FST,
  PROP_WORD_SYMS,
  PROP_SILENCE_PHONES,
  PROP_LDA_MAT,
  PROP_LAST
};

#define DEFAULT_MODEL           "final.mdl"
#define DEFAULT_FST             "HCLG.fst"
#define DEFAULT_WORD_SYMS       "words.txt"
#define DEFAULT_SILENCE_PHONES  "1:2:3:4:5"
#define DEFAULT_ACOUSTIC_SCALE  1.0/13
#define DEFAULT_LEFT_CONTEXT    4
#define DEFAULT_RIGHT_CONTEXT   4


/* the capabilities of the inputs and outputs.
 *
 * describe the real formats here.
 */
static GstStaticPadTemplate sink_factory =
    GST_STATIC_PAD_TEMPLATE("sink",
                            GST_PAD_SINK,
                            GST_PAD_ALWAYS,
                            GST_STATIC_CAPS(
                                "audio/x-raw, "
                                "format = (string) S16LE, "
                                "channels = (int) 1, "
                                "rate = (int) 16000 "));


static GstStaticPadTemplate src_factory =
    GST_STATIC_PAD_TEMPLATE("src",
                            GST_PAD_SRC,
                            GST_PAD_ALWAYS,
                            GST_STATIC_CAPS("text/x-raw, format= { utf8 }"));

static guint gst_online_gmm_decode_faster_signals[LAST_SIGNAL];

#define gst_online_gmm_decode_faster_parent_class parent_class
G_DEFINE_TYPE(GstOnlineGmmDecodeFaster, gst_online_gmm_decode_faster, GST_TYPE_ELEMENT);


static void
gst_online_gmm_decode_faster_set_property(GObject * object, guint prop_id,
                                          const GValue * value,
                                          GParamSpec * pspec);
static void
gst_online_gmm_decode_faster_get_property(GObject * object, guint prop_id,
                                          GValue * value, GParamSpec * pspec);
static GstStateChangeReturn
gst_online_gmm_decode_faster_change_state(GstElement *element,
                                          GstStateChange transition);
static void
gst_online_gmm_decode_faster_finalize(GObject * object);

static gboolean
gst_online_gmm_decode_faster_sink_event(GstPad * pad, GstObject * parent,
                                        GstEvent * event);

static GstFlowReturn gst_online_gmm_decode_faster_chain(GstPad * pad,
                                                        GstObject * parent,
                                                        GstBuffer * buf);

static void
gst_online_gmm_decode_faster_loop(GstOnlineGmmDecodeFaster * filter);


/* GObject vmethod implementations */

/* initialize the onlinegmmdecodefaster's class */
static void gst_online_gmm_decode_faster_class_init(GstOnlineGmmDecodeFasterClass * klass) {
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;
  gstelement_class = (GstElementClass *) klass;

  gobject_class->set_property = gst_online_gmm_decode_faster_set_property;
  gobject_class->get_property = gst_online_gmm_decode_faster_get_property;
  gobject_class->finalize = gst_online_gmm_decode_faster_finalize;

  gstelement_class->change_state = gst_online_gmm_decode_faster_change_state;

  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_SILENT,
                                  g_param_spec_boolean("silent",
                                                       "Silence the decoder",
                                                       "Determines whether incoming audio is sent to the decoder or not",
                                                       false,
                                                       (GParamFlags) G_PARAM_READWRITE));
  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_MODEL,
                                  g_param_spec_string("model",
                                                      "Acoustic model",
                                                      "Filename of the acoustic model",
                                                      DEFAULT_MODEL,
                                                      (GParamFlags) G_PARAM_READWRITE));
  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_FST,
                                  g_param_spec_string("fst",
                                                      "Decoding FST",
                                                      "Filename of the HCLG FST",
                                                      DEFAULT_FST,
                                                      (GParamFlags) G_PARAM_READWRITE));
  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_WORD_SYMS,
                                  g_param_spec_string("word-syms",
                                                      "Word symbols",
                                                      "Name of word symbols file (typically words.txt)",
                                                      DEFAULT_WORD_SYMS,
                                                      (GParamFlags) G_PARAM_READWRITE));
  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_SILENCE_PHONES,
                                  g_param_spec_string("silence-phones",
                                                      "Silence phones",
                                                      "Colon-separated IDs of silence phones, e.g. '1:2:3:4:5'",
                                                      DEFAULT_SILENCE_PHONES,
                                                      (GParamFlags) G_PARAM_READWRITE));
  g_object_class_install_property(G_OBJECT_CLASS(klass),
                                  PROP_LDA_MAT,
                                  g_param_spec_string("lda-mat",
                                                      "LDA matrix",
                                                      "Filename of the LDA transform data",
                                                      "",
                                                      (GParamFlags) G_PARAM_READWRITE));

  gst_element_class_set_details_simple(gstelement_class,
                                       "OnlineGmmDecodeFaster",
                                       "Speech/Audio",
                                       "Convert speech to text",
                                       "Tanel Alumae <tanel.alumae@phon.ioc.ee>");

  gst_element_class_add_pad_template(gstelement_class,
                                     gst_static_pad_template_get(&src_factory));
  gst_element_class_add_pad_template(gstelement_class,
                                     gst_static_pad_template_get(&sink_factory));

  gst_online_gmm_decode_faster_signals[HYP_WORD_SIGNAL]
      = g_signal_new("hyp-word", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
                     G_STRUCT_OFFSET(GstOnlineGmmDecodeFasterClass, hyp_word),
                     NULL, NULL, kaldi_marshal_VOID__STRING, G_TYPE_NONE, 1,
                     G_TYPE_STRING);
}



/* initialize the new element
 * instantiate pads and add them to element
 * set pad calback functions
 * initialize instance structure
 */
static void
gst_online_gmm_decode_faster_init(GstOnlineGmmDecodeFaster * filter) {
  bool tmp_bool;
  int32 tmp_int;
  uint32 tmp_uint;
  float tmp_float;
  double tmp_double;
  std::string tmp_string;
  filter->silent_ = false;
  filter->model_rspecifier_ = g_strdup(DEFAULT_MODEL);
  filter->fst_rspecifier_ = g_strdup(DEFAULT_FST);
  filter->word_syms_filename_ = g_strdup(DEFAULT_WORD_SYMS);
  filter->lda_mat_rspecifier_ = g_strdup("");
  filter->silence_phones_ = new std::vector<int32>;
  SplitStringToIntegers(DEFAULT_SILENCE_PHONES, ":", false, filter->silence_phones_);

  filter->simple_options_ = new SimpleOptions();

  filter->decoder_opts_ = new OnlineFasterDecoderOpts();
  filter->decoder_opts_->Register(filter->simple_options_, true);
  filter->feature_reading_opts_ = new OnlineFeatureMatrixOptions();
  filter->feature_reading_opts_->Register(filter->simple_options_);

  filter->acoustic_scale_ = DEFAULT_ACOUSTIC_SCALE;
  filter->cmn_window_ = 600;
  filter->min_cmn_window_ = 100;  // adds 1 second latency, only at utterance start.
  filter->right_context_ = DEFAULT_RIGHT_CONTEXT;
  filter->left_context_ = DEFAULT_LEFT_CONTEXT;

  filter->simple_options_->Register("left-context", &filter->left_context_,
                                    "Number of frames of left context");
  filter->simple_options_->Register("right-context", &filter->right_context_,
                                    "Number of frames of right context");
  filter->simple_options_->Register("acoustic-scale", &filter->acoustic_scale_,
                                    "Scaling factor for acoustic likelihoods");

  filter->simple_options_->Register("cmn-window", &(filter->cmn_window_),
                                    "Number of feat. vectors used in the running average CMN calculation");
  filter->simple_options_->Register("min-cmn-window", &filter->min_cmn_window_,
                                    "Minumum CMN window used at start of decoding (adds "
                                      "latency only at start)");


  filter->sinkpad_ = gst_pad_new_from_static_template(&sink_factory, "sink");
  gst_pad_set_event_function(filter->sinkpad_,
                              GST_DEBUG_FUNCPTR(gst_online_gmm_decode_faster_sink_event));
  gst_pad_set_chain_function(filter->sinkpad_,
                              GST_DEBUG_FUNCPTR(gst_online_gmm_decode_faster_chain));

  gst_pad_use_fixed_caps(filter->sinkpad_);
  gst_element_add_pad(GST_ELEMENT(filter), filter->sinkpad_);

  filter->srcpad_ = gst_pad_new_from_static_template(&src_factory, "src");
  gst_pad_use_fixed_caps(filter->srcpad_);
  gst_element_add_pad(GST_ELEMENT(filter), filter->srcpad_);

  // init properties from various Kaldi Opts
  GstElementClass * klass = GST_ELEMENT_GET_CLASS(filter);

  std::vector<std::pair<std::string, SimpleOptions::OptionInfo> > option_info_list;
  option_info_list = filter->simple_options_->GetOptionInfoList();
  int32 i = 0;
  for (std::vector<std::pair<std::string,
      SimpleOptions::OptionInfo> >::iterator dx = option_info_list.begin();
      dx != option_info_list.end(); dx++) {
    std::pair<std::string, SimpleOptions::OptionInfo> result = (*dx);
    SimpleOptions::OptionInfo option_info = result.second;
    std::string name = result.first;
    switch (option_info.type) {
      case SimpleOptions::kBool:
        filter->simple_options_->GetOption(name, &tmp_bool);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_boolean(
                                                             name.c_str(),
                                                             option_info.doc.c_str(),
                                                             option_info.doc.c_str(),
                                                             tmp_bool,
                                                             (GParamFlags) G_PARAM_READWRITE));
        break;
      case SimpleOptions::kInt32:
        filter->simple_options_->GetOption(name, &tmp_int);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_int(
                                                         name.c_str(),
                                                         option_info.doc.c_str(),
                                                         option_info.doc.c_str(),
                                                         G_MININT,
                                                         G_MAXINT,
                                                         tmp_int,
                                                         (GParamFlags) G_PARAM_READWRITE));
        break;
      case SimpleOptions::kUint32:
        filter->simple_options_->GetOption(name, &tmp_uint);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_uint(
                                                          name.c_str(),
                                                          option_info.doc.c_str(),
                                                          option_info.doc.c_str(),
                                                          0,
                                                          G_MAXUINT,
                                                          tmp_uint,
                                                          (GParamFlags) G_PARAM_READWRITE));
        break;
      case SimpleOptions::kFloat:
        filter->simple_options_->GetOption(name, &tmp_float);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_float(
                                                           name.c_str(),
                                                           option_info.doc.c_str(),
                                                           option_info.doc.c_str(),
                                                           G_MINFLOAT,
                                                           G_MAXFLOAT,
                                                           tmp_float,
                                                           (GParamFlags) G_PARAM_READWRITE));
        break;
      case SimpleOptions::kDouble:
        filter->simple_options_->GetOption(name, &tmp_double);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_double(
                                                            name.c_str(),
                                                            option_info.doc.c_str(),
                                                            option_info.doc.c_str(),
                                                            G_MINDOUBLE,
                                                            G_MAXDOUBLE,
                                                            tmp_double,
                                                            (GParamFlags) G_PARAM_READWRITE));
        break;
      case SimpleOptions::kString:
        filter->simple_options_->GetOption(name, &tmp_string);
        g_object_class_install_property(
                                        G_OBJECT_CLASS(klass),
                                        PROP_LAST + i,
                                        g_param_spec_string(
                                                            name.c_str(),
                                                            option_info.doc.c_str(),
                                                            option_info.doc.c_str(),
                                                            tmp_string.c_str(),
                                                            (GParamFlags) G_PARAM_READWRITE));
        break;
    }
    i += 1;
  }
}

static bool
gst_online_gmm_decode_faster_allocate(GstOnlineGmmDecodeFaster * filter) {
  if (!filter->decoder_) {
    GST_INFO_OBJECT(filter,  "Loading Kaldi decoder");
    filter->lda_transform_ = new Matrix<BaseFloat>;
    if (strlen(filter->lda_mat_rspecifier_) > 0) {
      bool binary_in;
      Input ki(filter->lda_mat_rspecifier_, &binary_in);
      filter->lda_transform_->Read(ki.Stream(), binary_in);
    }
    filter->trans_model_ = new TransitionModel();
    filter->am_gmm_ = new AmDiagGmm();
    {
      bool binary;
      Input ki(filter->model_rspecifier_, &binary);
      filter->trans_model_->Read(ki.Stream(), binary);
      filter->am_gmm_->Read(ki.Stream(), binary);
    }
    filter->word_syms_ = NULL;
    if (!(filter->word_syms_ = fst::SymbolTable::ReadText(filter->word_syms_filename_))) {
      GST_ERROR_OBJECT(filter, "Could not read symbol table from file %s", filter->word_syms_filename_);
      return false;
    }

    filter->decode_fst_ = ReadDecodeGraph(filter->fst_rspecifier_);

    int32 window_size = filter->right_context_ + filter->left_context_ + 1;
    filter->decoder_opts_->batch_size = std::max(filter->decoder_opts_->batch_size, window_size);

    filter->out_fst_ = new fst::VectorFst<LatticeArc> ();

    filter->au_src_ = new GstBufferSource();

    filter->decoder_ = new OnlineFasterDecoder(*(filter->decode_fst_),
                                               *(filter->decoder_opts_),
                                               *(filter->silence_phones_),
                                               *(filter->trans_model_));

    GST_INFO_OBJECT(filter,  "Finished loading Kaldi decoder");
  }
  return true;
}

static void
gst_online_gmm_decode_faster_finalize(GObject * object) {
  GstOnlineGmmDecodeFaster *filter = GST_ONLINEGMMDECODEFASTER(object);

  g_free(filter->model_rspecifier_);
  g_free(filter->fst_rspecifier_);
  g_free(filter->word_syms_filename_);
  g_free(filter->lda_mat_rspecifier_);
  delete filter->silence_phones_;
  delete filter->decoder_opts_;
  delete filter->feature_reading_opts_;
  if (filter->decoder_) {
    delete filter->decoder_;
    filter->decoder_ = NULL;
  }
  if (filter->lda_transform_) {
    delete filter->lda_transform_;
    filter->lda_transform_ = NULL;
  }
  if (filter->am_gmm_) {
    delete filter->am_gmm_;
    filter->am_gmm_ = NULL;
  }
  if (filter->word_syms_) {
    delete filter->word_syms_;
    filter->word_syms_ = NULL;
  }
  if (filter->decode_fst_) {
    delete filter->decode_fst_;
    filter->decode_fst_ = NULL;
  }
  if (filter->out_fst_) {
    delete filter->out_fst_;
    filter->out_fst_ = NULL;
  }
  if (filter->au_src_) {
    delete filter->au_src_;
    filter->au_src_ = NULL;
  }
  if (filter->simple_options_) {
    delete filter->simple_options_;
    filter->simple_options_ = NULL;
  }

  G_OBJECT_CLASS(parent_class)->finalize(object);
}


static bool
gst_online_gmm_decode_faster_deallocate(GstOnlineGmmDecodeFaster * filter) {
  /* We won't deallocate the decoder once it's already allocated, since model loading could take a lot of time */
  GST_INFO_OBJECT(filter, "Refusing to unload decoder");
  return true;
}

static void
gst_online_gmm_decode_faster_set_property(GObject * object, guint prop_id,
                                          const GValue * value, GParamSpec * pspec) {
  GstOnlineGmmDecodeFaster *filter = GST_ONLINEGMMDECODEFASTER(object);

  if (prop_id == PROP_SILENT) {
    filter->silent_ = g_value_get_boolean(value);
    return;
  }
  // All other props cannot be changed after initialization
  if (filter->decoder_) {
    GST_WARNING_OBJECT(filter,  "Decoder already initialized, cannot change it's properties");
    return;
  }
  switch (prop_id) {
    case PROP_MODEL:
      g_free(filter->model_rspecifier_);
      filter->model_rspecifier_ = g_value_dup_string(value);
      break;
    case PROP_FST:
      g_free(filter->fst_rspecifier_);
      filter->fst_rspecifier_ = g_value_dup_string(value);
      break;
    case PROP_WORD_SYMS:
      g_free(filter->word_syms_filename_);
      filter->word_syms_filename_ = g_value_dup_string(value);
      break;
    case PROP_LDA_MAT:
      g_free(filter->lda_mat_rspecifier_);
      filter->lda_mat_rspecifier_ = g_value_dup_string(value);
      break;
    case PROP_SILENCE_PHONES:
      SplitStringToIntegers(g_value_get_string(value), ":", false, filter->silence_phones_);
      break;
    default:
      if (prop_id >= PROP_LAST) {
        const gchar* name = g_param_spec_get_name(pspec);
        SimpleOptions::OptionType option_type;
        if (filter->simple_options_->GetOptionType(std::string(name), &option_type)) {
          switch (option_type) {
            case SimpleOptions::kBool:
              filter->simple_options_->SetOption(name, g_value_get_boolean(value));
              break;
            case SimpleOptions::kInt32:
              filter->simple_options_->SetOption(name, g_value_get_int(value));
              break;
            case SimpleOptions::kUint32:
              filter->simple_options_->SetOption(name, g_value_get_uint(value));
              break;
            case SimpleOptions::kFloat:
              filter->simple_options_->SetOption(name, g_value_get_float(value));
              break;
            case SimpleOptions::kDouble:
              filter->simple_options_->SetOption(name, g_value_get_double(value));
              break;
            case SimpleOptions::kString:
              filter->simple_options_->SetOption(name, g_value_dup_string(value));
              break;
          }
          break;
        }
      }
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
  }
}

static void
gst_online_gmm_decode_faster_get_property(GObject * object, guint prop_id,
                                           GValue * value, GParamSpec * pspec) {
  bool tmp_bool;
  int32 tmp_int;
  uint32 tmp_uint;
  float tmp_float;
  double tmp_double;
  std::string tmp_string;

  GstOnlineGmmDecodeFaster *filter = GST_ONLINEGMMDECODEFASTER(object);
  std::ostringstream ss;

  switch (prop_id) {
    case PROP_SILENT:
      g_value_set_boolean(value, filter->silent_);
      break;
    case PROP_MODEL:
      g_value_set_string(value, filter->model_rspecifier_);
      break;
    case PROP_FST:
      g_value_set_string(value, filter->fst_rspecifier_);
      break;
    case PROP_WORD_SYMS:
      g_value_set_string(value, filter->word_syms_filename_);
      break;
    case PROP_LDA_MAT:
      g_value_set_string(value, filter->lda_mat_rspecifier_);
      break;
    case PROP_SILENCE_PHONES:
      for (size_t j = 0; j < filter->silence_phones_->size(); j++) {
        if (j > 0) {
          ss << ":";
        }
        ss <<  (*filter->silence_phones_)[j];
      }
      g_value_set_string(value, ss.str().c_str());
      break;
    default:
      if (prop_id >= PROP_LAST) {
        const gchar* name = g_param_spec_get_name(pspec);
        SimpleOptions::OptionType option_type;
        if (filter->simple_options_->GetOptionType(std::string(name), &option_type)) {
          switch (option_type) {
            case SimpleOptions::kBool:
              filter->simple_options_->GetOption(name, &tmp_bool);
              g_value_set_boolean(value, tmp_bool);
              break;
            case SimpleOptions::kInt32:
              filter->simple_options_->GetOption(name, &tmp_int);
              g_value_set_int(value, tmp_int);
              break;
            case SimpleOptions::kUint32:
              filter->simple_options_->GetOption(name, &tmp_uint);
              g_value_set_uint(value, tmp_uint);
              break;
            case SimpleOptions::kFloat:
              filter->simple_options_->GetOption(name, &tmp_float);
              g_value_set_float(value, tmp_float);
              break;
            case SimpleOptions::kDouble:
              filter->simple_options_->GetOption(name, &tmp_double);
              g_value_set_double(value, tmp_double);
              break;
            case SimpleOptions::kString:
              filter->simple_options_->GetOption(name, &tmp_string);
              g_value_set_string(value, tmp_string.c_str());
              break;
          }
          break;
        }
      }
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
      break;
  }
}


static GstStateChangeReturn
gst_online_gmm_decode_faster_change_state(GstElement *element, GstStateChange transition) {
  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
  GstOnlineGmmDecodeFaster *filter = GST_ONLINEGMMDECODEFASTER(element);

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      if (!gst_online_gmm_decode_faster_allocate(filter))
        return GST_STATE_CHANGE_FAILURE;
      break;
    default:
      break;
  }

  ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition);
  if (ret == GST_STATE_CHANGE_FAILURE)
    return ret;

  switch (transition) {
    case GST_STATE_CHANGE_READY_TO_NULL:
      gst_online_gmm_decode_faster_deallocate(filter);
      break;
    default:
      break;
  }

  return ret;
}

/*
 * Emit a single recognized word:
 *   * emit through the sink pad of the element
 *   * emit by the hy-word signal
 */
static void
gst_online_gmm_decode_faster_push_word(GstOnlineGmmDecodeFaster * filter, GstPad *pad, std::string word) {
  const gchar *hyp = word.c_str();
  guint hyp_len = strlen(hyp);
  GST_DEBUG_OBJECT(filter,  "WORD: %s", hyp);
  /* +1 for terminating NUL character */
  GstBuffer *buffer = gst_buffer_new_and_alloc(hyp_len + 2);
  gst_buffer_fill(buffer, 0, hyp, hyp_len);
  gst_buffer_memset(buffer, hyp_len, ' ', 1);
  gst_buffer_memset(buffer, hyp_len + 1, '\0', 1);
  gst_buffer_set_size(buffer, hyp_len + 1);

  gst_pad_push(pad, buffer);
  /* Emit a signal for applications. */
  g_signal_emit(filter, gst_online_gmm_decode_faster_signals[HYP_WORD_SIGNAL], 0, hyp);
}


static void
gst_online_gmm_decode_faster_push_words(GstOnlineGmmDecodeFaster * filter, GstPad *pad,
                                        const std::vector<int32>& words,
                                        const fst::SymbolTable *word_syms,
                                        bool line_break) {
  KALDI_ASSERT(word_syms != NULL);
  std::stringstream ss;
  for (size_t i = 0; i < words.size(); i++) {
    std::string word = word_syms->Find(words[i]);
    if (word == "") {
      GST_ERROR_OBJECT(filter, "Word-id %d  not in symbol table!",  words[i]);
    }
    gst_online_gmm_decode_faster_push_word(filter, pad, word);
  }

  if (line_break) {
    gst_online_gmm_decode_faster_push_word(filter, pad, "<#s>");
  }
}

static void
gst_online_gmm_decode_faster_loop(GstOnlineGmmDecodeFaster * filter) {
  // We are not properly registering/exposing MFCC and frame extraction options,
  // because there are parts of the online decoding code, where some of these
  // options are hardwired(ToDo: we should fix this at some point)
  MfccOptions mfcc_opts;
  mfcc_opts.use_energy = false;
  int32 frame_length = mfcc_opts.frame_opts.frame_length_ms = 25;
  int32 frame_shift = mfcc_opts.frame_opts.frame_shift_ms = 10;

  // Up to delta-delta derivative features are calculated (unless LDA is used)
  const int32 kDeltaOrder = 2;
  Mfcc mfcc(mfcc_opts);
  FeInput fe_input(filter->au_src_, &mfcc,
                   frame_length * (kSampleFreq / 1000),
                   frame_shift * (kSampleFreq / 1000));
  OnlineCmnInput cmn_input(&fe_input, filter->cmn_window_, filter->min_cmn_window_);

  OnlineFeatInputItf *feat_transform = 0;
  if (strlen(filter->lda_mat_rspecifier_) > 0) {
    feat_transform = new OnlineLdaInput(&cmn_input, *(filter->lda_transform_),
                                        filter->left_context_,
                                        filter->right_context_);
  } else {
    DeltaFeaturesOptions opts;
    opts.order = kDeltaOrder;
    // Note from Dan: keeping the next statement for back-compatibility,
    // but I don't think this is really the right way to set the window-size
    // in the delta computation: it should be a separate config.
    opts.window = filter->left_context_ / 2;
    feat_transform = new OnlineDeltaInput(opts, &cmn_input);
  }


  // feature_reading_opts contains timeout, batch size.
  OnlineFeatureMatrix feature_matrix(*(filter->feature_reading_opts_),
                                     feat_transform);


  OnlineDecodableDiagGmmScaled decodable(*(filter->am_gmm_), *(filter->trans_model_),
                                         filter->acoustic_scale_, &feature_matrix);

  GST_DEBUG_OBJECT(filter,  "starting decoding loop");

  bool partial_res = false;
  filter->decoder_->InitDecoding();
  while (1) {
    OnlineFasterDecoder::DecodeState dstate = filter->decoder_->Decode(&decodable);

    if (dstate & (filter->decoder_->kEndFeats | filter->decoder_->kEndUtt)) {
      std::vector<int32> word_ids;
      filter->decoder_->FinishTraceBack(filter->out_fst_);
      fst::GetLinearSymbolSequence(*(filter->out_fst_),
                                   static_cast<std::vector<int32> *>(0),
                                   &word_ids,
                                   static_cast<LatticeArc::Weight*>(0));
      gst_online_gmm_decode_faster_push_words(filter, filter->srcpad_, word_ids, filter->word_syms_, partial_res || word_ids.size());
      partial_res = false;
      if (dstate == filter->decoder_->kEndFeats)
        break;
    } else {
      std::vector<int32> word_ids;
      if (filter->decoder_->PartialTraceback(filter->out_fst_)) {
        fst::GetLinearSymbolSequence(*(filter->out_fst_),
                                     static_cast<std::vector<int32> *>(0),
                                     &word_ids,
                                     static_cast<LatticeArc::Weight*>(0));
        gst_online_gmm_decode_faster_push_words(filter, filter->srcpad_, word_ids, filter->word_syms_, false);
        if (!partial_res)
          partial_res = (word_ids.size() > 0);
      }
    }
  }
  GST_DEBUG_OBJECT(filter, "Finished decoding loop");
  GST_DEBUG_OBJECT(filter, "Pushing EOS event");
  gst_pad_push_event(filter->srcpad_, gst_event_new_eos());

  GST_DEBUG_OBJECT(filter, "Pausing decoding task");
  gst_pad_pause_task(filter->srcpad_);
  delete feat_transform;
  delete filter->au_src_;
  filter->au_src_ = new GstBufferSource();
}

/* GstElement vmethod implementations */
/* this function handles sink events */
static gboolean
gst_online_gmm_decode_faster_sink_event(GstPad * pad, GstObject * parent, GstEvent * event) {
  gboolean ret;
  GstOnlineGmmDecodeFaster *filter;

  filter = GST_ONLINEGMMDECODEFASTER(parent);
  GST_DEBUG_OBJECT(filter, "Handling %s event", GST_EVENT_TYPE_NAME(event));

  switch (GST_EVENT_TYPE(event)) {
    case GST_EVENT_SEGMENT:
    {
      GST_DEBUG_OBJECT(filter,  "Starting decoding task");
      gst_pad_start_task(filter->srcpad_,
                         (GstTaskFunction) gst_online_gmm_decode_faster_loop, filter, NULL);

      GST_DEBUG_OBJECT(filter,  "Started decoding task");
      ret = TRUE;
      break;
    }
    case GST_EVENT_CAPS:
    {
      ret = TRUE;
      break;
    }
    case GST_EVENT_EOS:
    {
      /* end-of-stream, we should close down all stream leftovers here */
      GST_DEBUG_OBJECT(filter, "EOS received");
      filter->au_src_->SetEnded(true);
      ret = TRUE;
      break;
    }
    default:
      ret = gst_pad_event_default(pad, parent, event);
      break;
  }
  return ret;
}

/* chain function
 * this function does the actual processing
 */
static GstFlowReturn gst_online_gmm_decode_faster_chain(GstPad * pad,
                                                        GstObject * parent,
                                                        GstBuffer * buf) {
  GstOnlineGmmDecodeFaster *filter;

  filter = GST_ONLINEGMMDECODEFASTER(parent);

  if (G_UNLIKELY(!filter->decoder_))
    goto not_negotiated;
  if (!filter->silent_) {
    filter->au_src_->PushBuffer(buf);
  }
  gst_buffer_unref(buf);
  return GST_FLOW_OK;

  /* special cases */
  not_negotiated: {
    GST_ELEMENT_ERROR(filter, CORE, NEGOTIATION, (NULL),
                      ("decoder wasn't allocated before chain function"));

    gst_buffer_unref(buf);
    return GST_FLOW_NOT_NEGOTIATED;
  }
}


/* entry point to initialize the plug-in
 * initialize the plug-in itself
 * register the element factories and other features
 */
static gboolean
onlinegmmdecodefaster_init(GstPlugin * onlinegmmdecodefaster) {
  /* debug category for fltering log messages
   */
  GST_DEBUG_CATEGORY_INIT(gst_online_gmm_decode_faster_debug, "onlinegmmdecodefaster",
                           0, "Automatic Speech Recognition");

  return gst_element_register(onlinegmmdecodefaster, "onlinegmmdecodefaster", GST_RANK_NONE,
                               GST_TYPE_ONLINEGMMDECODEFASTER);
}

/* PACKAGE: this is usually set by autotools depending on some _INIT macro
 * in configure.ac and then written into and defined in config.h, but we can
 * just set it ourselves here in case someone doesn't use autotools to
 * compile this code. GST_PLUGIN_DEFINE needs PACKAGE to be defined.
 */
#ifndef PACKAGE
#define PACKAGE "myfirstonlinegmmdecodefaster"
#endif

/* gstreamer looks for this structure to register onlinegmmdecodefasters
 *
 * exchange the string 'Template onlinegmmdecodefaster' with your onlinegmmdecodefaster description
 */
GST_PLUGIN_DEFINE(
    GST_VERSION_MAJOR,
    GST_VERSION_MINOR,
    onlinegmmdecodefaster,
    "Online speech recognizer based on the Kaldi toolkit",
    onlinegmmdecodefaster_init,
    VERSION,
    "LGPL",  // Changing it into Apache prevents the plugin from loading, see gst/gstplugin.c in GStreamer source
    "Kaldi",
    "http://kaldi.sourceforge.net/"
)
}