// online2/online-endpoint.cc
  
  // Copyright    2014  Johns Hopkins University (author: Daniel Povey)
  
  // 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.
  
  #include "online2/online-endpoint.h"
  #include "decoder/lattice-faster-online-decoder.h"
  #include "decoder/grammar-fst.h"
  
  namespace kaldi {
  
  static bool RuleActivated(const OnlineEndpointRule &rule,
                            const std::string &rule_name,
                            BaseFloat trailing_silence,
                            BaseFloat relative_cost,
                            BaseFloat utterance_length) {
    bool contains_nonsilence = (utterance_length > trailing_silence);
  
    bool ans = (contains_nonsilence || !rule.must_contain_nonsilence) &&
        trailing_silence >= rule.min_trailing_silence &&
        relative_cost <= rule.max_relative_cost &&
        utterance_length >= rule.min_utterance_length;
    if (ans) {
      KALDI_VLOG(2) << "Endpointing rule " << rule_name << " activated: "
                    << (contains_nonsilence ? "true" : "false" ) << ','
                    << trailing_silence << ',' << relative_cost << ','
                    << utterance_length;
    }
    return ans;
  }
  
  bool EndpointDetected(const OnlineEndpointConfig &config,
                        int32 num_frames_decoded,
                        int32 trailing_silence_frames,
                        BaseFloat frame_shift_in_seconds,
                        BaseFloat final_relative_cost) {
    KALDI_ASSERT(num_frames_decoded >= trailing_silence_frames);
  
    BaseFloat utterance_length = num_frames_decoded * frame_shift_in_seconds,
        trailing_silence = trailing_silence_frames * frame_shift_in_seconds;
  
    if (RuleActivated(config.rule1, "rule1",
                      trailing_silence, final_relative_cost, utterance_length))
      return true;
    if (RuleActivated(config.rule2, "rule2",
                      trailing_silence, final_relative_cost, utterance_length))
      return true;
    if (RuleActivated(config.rule3, "rule3",
                      trailing_silence, final_relative_cost, utterance_length))
      return true;
    if (RuleActivated(config.rule4, "rule4",
                      trailing_silence, final_relative_cost, utterance_length))
      return true;
    if (RuleActivated(config.rule5, "rule5",
                      trailing_silence, final_relative_cost, utterance_length))
      return true;
    return false;
  }
  
  template <typename FST>
  int32 TrailingSilenceLength(const TransitionModel &tmodel,
                              const std::string &silence_phones_str,
                              const LatticeFasterOnlineDecoderTpl<FST> &decoder) {
    std::vector<int32> silence_phones;
    if (!SplitStringToIntegers(silence_phones_str, ":", false, &silence_phones))
      KALDI_ERR << "Bad --silence-phones option in endpointing config: "
                << silence_phones_str;
    std::sort(silence_phones.begin(), silence_phones.end());
    KALDI_ASSERT(IsSortedAndUniq(silence_phones) &&
                 "Duplicates in --silence-phones option in endpointing config");
    KALDI_ASSERT(!silence_phones.empty() &&
                 "Endpointing requires nonempty --endpoint.silence-phones option");
    ConstIntegerSet<int32> silence_set(silence_phones);
  
    bool use_final_probs = false;
    typename LatticeFasterOnlineDecoderTpl<FST>::BestPathIterator iter =
        decoder.BestPathEnd(use_final_probs, NULL);
    int32 num_silence_frames = 0;
    while (!iter.Done()) {  // we're going backwards in time from the most
                            // recently decoded frame...
      LatticeArc arc;
      iter = decoder.TraceBackBestPath(iter, &arc);
      if (arc.ilabel != 0) {
        int32 phone = tmodel.TransitionIdToPhone(arc.ilabel);
        if (silence_set.count(phone) != 0) {
          num_silence_frames++;
        } else {
          break; // stop counting as soon as we hit non-silence.
        }
      }
    }
    return num_silence_frames;
  }
  
  template <typename FST>
  bool EndpointDetected(
      const OnlineEndpointConfig &config,
      const TransitionModel &tmodel,
      BaseFloat frame_shift_in_seconds,
      const LatticeFasterOnlineDecoderTpl<FST> &decoder) {
    if (decoder.NumFramesDecoded() == 0) return false;
  
    BaseFloat final_relative_cost = decoder.FinalRelativeCost();
  
    int32 num_frames_decoded = decoder.NumFramesDecoded(),
        trailing_silence_frames = TrailingSilenceLength(tmodel,
                                                        config.silence_phones,
                                                        decoder);
  
    return EndpointDetected(config, num_frames_decoded, trailing_silence_frames,
                            frame_shift_in_seconds, final_relative_cost);
  }
  
  
  // Instantiate EndpointDetected for the types we need.
  // It will require TrailingSilenceLength so we don't have to instantiate that.
  template
  bool EndpointDetected<fst::Fst<fst::StdArc> >(
      const OnlineEndpointConfig &config,
      const TransitionModel &tmodel,
      BaseFloat frame_shift_in_seconds,
      const LatticeFasterOnlineDecoderTpl<fst::Fst<fst::StdArc> > &decoder);
  
  
  template
  bool EndpointDetected<fst::GrammarFst>(
      const OnlineEndpointConfig &config,
      const TransitionModel &tmodel,
      BaseFloat frame_shift_in_seconds,
      const LatticeFasterOnlineDecoderTpl<fst::GrammarFst> &decoder);
  
  
  }  // namespace kaldi