// online2/online-ivector-feature.cc
  
  // Copyright 2014  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-ivector-feature.h"
  
  namespace kaldi {
  
  OnlineIvectorExtractionInfo::OnlineIvectorExtractionInfo(
      const OnlineIvectorExtractionConfig &config) {
    Init(config);
  }
  
  void OnlineIvectorExtractionInfo::Init(
      const OnlineIvectorExtractionConfig &config) {
    ivector_period = config.ivector_period;
    num_gselect = config.num_gselect;
    min_post = config.min_post;
    posterior_scale = config.posterior_scale;
    max_count = config.max_count;
    num_cg_iters = config.num_cg_iters;
    use_most_recent_ivector = config.use_most_recent_ivector;
    greedy_ivector_extractor = config.greedy_ivector_extractor;
    if (greedy_ivector_extractor && !use_most_recent_ivector) {
      KALDI_WARN << "--greedy-ivector-extractor=true implies "
                 << "--use-most-recent-ivector=true";
      use_most_recent_ivector = true;
    }
    max_remembered_frames = config.max_remembered_frames;
  
    std::string note = "(note: this may be needed "
        "in the file supplied to --ivector-extractor-config)";
    if (config.lda_mat_rxfilename == "")
      KALDI_ERR << "--lda-matrix option must be set " << note;
    ReadKaldiObject(config.lda_mat_rxfilename, &lda_mat);
    if (config.global_cmvn_stats_rxfilename == "")
      KALDI_ERR << "--global-cmvn-stats option must be set " << note;
    ReadKaldiObject(config.global_cmvn_stats_rxfilename, &global_cmvn_stats);
    if (config.cmvn_config_rxfilename == "")
      KALDI_ERR << "--cmvn-config option must be set " << note;
    ReadConfigFromFile(config.cmvn_config_rxfilename, &cmvn_opts);
    if (config.splice_config_rxfilename == "")
      KALDI_ERR << "--splice-config option must be set " << note;
    ReadConfigFromFile(config.splice_config_rxfilename, &splice_opts);
    if (config.diag_ubm_rxfilename == "")
      KALDI_ERR << "--diag-ubm option must be set " << note;
    ReadKaldiObject(config.diag_ubm_rxfilename, &diag_ubm);
    if (config.ivector_extractor_rxfilename == "")
      KALDI_ERR << "--ivector-extractor option must be set " << note;
    ReadKaldiObject(config.ivector_extractor_rxfilename, &extractor);
    this->Check();
  }
  
  
  void OnlineIvectorExtractionInfo::Check() const {
    KALDI_ASSERT(global_cmvn_stats.NumRows() == 2);
    int32 base_feat_dim = global_cmvn_stats.NumCols() - 1,
        num_splice = splice_opts.left_context + 1 + splice_opts.right_context,
        spliced_input_dim = base_feat_dim * num_splice;
  
    KALDI_ASSERT(lda_mat.NumCols() == spliced_input_dim ||
                 lda_mat.NumCols() == spliced_input_dim + 1);
    KALDI_ASSERT(lda_mat.NumRows() == diag_ubm.Dim());
    KALDI_ASSERT(diag_ubm.Dim() == extractor.FeatDim());
    KALDI_ASSERT(ivector_period > 0);
    KALDI_ASSERT(num_gselect > 0);
    KALDI_ASSERT(min_post < 0.5);
    // posterior scale more than one does not really make sense.
    KALDI_ASSERT(posterior_scale > 0.0 && posterior_scale <= 1.0);
    KALDI_ASSERT(max_remembered_frames >= 0);
  }
  
  // The class constructed in this way should never be used.
  OnlineIvectorExtractionInfo::OnlineIvectorExtractionInfo():
      ivector_period(0), num_gselect(0), min_post(0.0), posterior_scale(0.0),
      use_most_recent_ivector(true), greedy_ivector_extractor(false),
      max_remembered_frames(0) { }
  
  OnlineIvectorExtractorAdaptationState::OnlineIvectorExtractorAdaptationState(
      const OnlineIvectorExtractorAdaptationState &other):
      cmvn_state(other.cmvn_state), ivector_stats(other.ivector_stats) { }
  
  
  void OnlineIvectorExtractorAdaptationState::LimitFrames(
      BaseFloat max_remembered_frames, BaseFloat posterior_scale) {
    KALDI_ASSERT(max_remembered_frames >= 0);
    KALDI_ASSERT(cmvn_state.frozen_state.NumRows() == 0);
    if (cmvn_state.speaker_cmvn_stats.NumRows() != 0) {
      int32 feat_dim = cmvn_state.speaker_cmvn_stats.NumCols() - 1;
      BaseFloat count = cmvn_state.speaker_cmvn_stats(0, feat_dim);
      if (count > max_remembered_frames)
        cmvn_state.speaker_cmvn_stats.Scale(max_remembered_frames / count);
    }
    // the stats for the iVector have been scaled by info_.posterior_scale,
    // so we need to take this in account when setting the target count.
    BaseFloat max_remembered_frames_scaled =
        max_remembered_frames * posterior_scale;
    if (ivector_stats.Count() > max_remembered_frames_scaled) {
      ivector_stats.Scale(max_remembered_frames_scaled /
                          ivector_stats.Count());
    }
  }
  
  void OnlineIvectorExtractorAdaptationState::Write(std::ostream &os, bool binary) const {
    WriteToken(os, binary, "<OnlineIvectorExtractorAdaptationState>");  // magic string.
    WriteToken(os, binary, "<CmvnState>");
    cmvn_state.Write(os, binary);
    WriteToken(os, binary, "<IvectorStats>");
    ivector_stats.Write(os, binary);
    WriteToken(os, binary, "</OnlineIvectorExtractorAdaptationState>");
  }
  
  void OnlineIvectorExtractorAdaptationState::Read(std::istream &is, bool binary) {
    ExpectToken(is, binary, "<OnlineIvectorExtractorAdaptationState>");  // magic string.
    ExpectToken(is, binary, "<CmvnState>");
    cmvn_state.Read(is, binary);
    ExpectToken(is, binary, "<IvectorStats>");
    ivector_stats.Read(is, binary);
    ExpectToken(is, binary, "</OnlineIvectorExtractorAdaptationState>");
  }
  
  int32 OnlineIvectorFeature::Dim() const {
    return info_.extractor.IvectorDim();
  }
  
  bool OnlineIvectorFeature::IsLastFrame(int32 frame) const {
    // Note: it might be more logical to return, say, lda_->IsLastFrame()
    // since this is the feature the iVector extractor directly consumes,
    // but it will give the same answer as base_->IsLastFrame() anyway.
    // [note: the splicing component pads at begin and end so it always
    // returns the same number of frames as its input.]
    return base_->IsLastFrame(frame);
  }
  
  int32 OnlineIvectorFeature::NumFramesReady() const {
    KALDI_ASSERT(lda_ != NULL);
    return lda_->NumFramesReady();
  }
  
  BaseFloat OnlineIvectorFeature::FrameShiftInSeconds() const {
    return lda_->FrameShiftInSeconds();
  }
  
  void OnlineIvectorFeature::UpdateFrameWeights(
      const std::vector<std::pair<int32, BaseFloat> > &delta_weights) {
    // add the elements to delta_weights_, which is a priority queue.  The top
    // element of the priority queue is the lowest numbered frame (we ensured this
    // by making the comparison object std::greater instead of std::less).  Adding
    // elements from top (lower-numbered frames) to bottom (higher-numbered
    // frames) should be most efficient, assuming it's a heap internally.  So we
    // go forward not backward in delta_weights while adding.
    for (size_t i = 0; i < delta_weights.size(); i++) {
      delta_weights_.push(delta_weights[i]);
      int32 frame = delta_weights[i].first;
      KALDI_ASSERT(frame >= 0);
      if (frame > most_recent_frame_with_weight_)
        most_recent_frame_with_weight_ = frame;
    }
    delta_weights_provided_ = true;
  }
  
  
  BaseFloat OnlineIvectorFeature::GetMinPost(BaseFloat weight) const {
    BaseFloat min_post = info_.min_post;
    BaseFloat abs_weight = fabs(weight);
    // If we return 0.99, it will have the same effect as just picking the
    // most probable Gaussian on that frame.
    if (abs_weight == 0.0)
      return 0.99;   // I don't anticipate reaching here.
    min_post /= abs_weight;
    if (min_post > 0.99)
      min_post = 0.99;
    return min_post;
  }
  
  void OnlineIvectorFeature::UpdateStatsForFrames(
      const std::vector<std::pair<int32, BaseFloat> > &frame_weights_in) {
  
    std::vector<std::pair<int32, BaseFloat> > frame_weights(frame_weights_in);
    // Remove duplicates of frames.
    MergePairVectorSumming(&frame_weights);
  
    if (frame_weights.empty())
      return;
  
    int32 num_frames = static_cast<int32>(frame_weights.size());
    int32 feat_dim = lda_normalized_->Dim();
    Matrix<BaseFloat> feats(num_frames, feat_dim, kUndefined),
        log_likes;
  
    std::vector<int32> frames;
    frames.reserve(frame_weights.size());
    for (int32 i = 0; i < num_frames; i++)
      frames.push_back(frame_weights[i].first);
    lda_normalized_->GetFrames(frames, &feats);
  
    info_.diag_ubm.LogLikelihoods(feats, &log_likes);
  
    // "posteriors" stores, for each frame index in the range of frames, the
    // pruned posteriors for the Gaussians in the UBM.
    std::vector<std::vector<std::pair<int32, BaseFloat> > > posteriors(num_frames);
    for (int32 i = 0; i < num_frames; i++) {
      std::vector<std::pair<int32, BaseFloat> > &posterior = posteriors[i];
      BaseFloat weight = frame_weights[i].second;
      if (weight != 0.0) {
        tot_ubm_loglike_ += weight *
            VectorToPosteriorEntry(log_likes.Row(i), info_.num_gselect,
                                   GetMinPost(weight), &posterior);
        for (size_t j = 0; j < posterior.size(); j++)
          posterior[j].second *= info_.posterior_scale * weight;
      }
    }
    lda_->GetFrames(frames, &feats);  // get features without CMN.
    ivector_stats_.AccStats(info_.extractor, feats, posteriors);
  }
  
  
  void OnlineIvectorFeature::UpdateStatsUntilFrame(int32 frame) {
    KALDI_ASSERT(frame >= 0 && frame < this->NumFramesReady() &&
                 !delta_weights_provided_);
    updated_with_no_delta_weights_ = true;
  
    int32 ivector_period = info_.ivector_period;
    int32 num_cg_iters = info_.num_cg_iters;
  
    std::vector<std::pair<int32, BaseFloat> > frame_weights;
  
    for (; num_frames_stats_ <= frame; num_frames_stats_++) {
      int32 t = num_frames_stats_;
      BaseFloat frame_weight = 1.0;
      frame_weights.push_back(std::pair<int32, BaseFloat>(t, frame_weight));
      if ((!info_.use_most_recent_ivector && t % ivector_period == 0) ||
          (info_.use_most_recent_ivector && t == frame)) {
        // The call below to UpdateStatsForFrames() is equivalent to doing, for
        // all valid indexes i:
        //  UpdateStatsForFrame(cur_start_frame + i, frame_weights[i])
        UpdateStatsForFrames(frame_weights);
        frame_weights.clear();
        ivector_stats_.GetIvector(num_cg_iters, &current_ivector_);
        if (!info_.use_most_recent_ivector) {  // need to cache iVectors.
          int32 ivec_index = t / ivector_period;
          KALDI_ASSERT(ivec_index == static_cast<int32>(ivectors_history_.size()));
          ivectors_history_.push_back(new Vector<BaseFloat>(current_ivector_));
        }
      }
    }
    if (!frame_weights.empty())
      UpdateStatsForFrames(frame_weights);
  }
  
  void OnlineIvectorFeature::UpdateStatsUntilFrameWeighted(int32 frame) {
    KALDI_ASSERT(frame >= 0 && frame < this->NumFramesReady() &&
                 delta_weights_provided_ &&
                 ! updated_with_no_delta_weights_ &&
                 frame <= most_recent_frame_with_weight_);
    bool debug_weights = false;
  
    int32 ivector_period = info_.ivector_period;
    int32 num_cg_iters = info_.num_cg_iters;
  
    std::vector<std::pair<int32, BaseFloat> > frame_weights;
    frame_weights.reserve(delta_weights_.size());
  
    for (; num_frames_stats_ <= frame; num_frames_stats_++) {
      int32 t = num_frames_stats_;
      // Instead of just updating frame t, we update all frames that need updating
      // with index <= t, in case old frames were reclassified as silence/nonsilence.
      while (!delta_weights_.empty() &&
             delta_weights_.top().first <= t) {
        int32 frame = delta_weights_.top().first;
        BaseFloat weight = delta_weights_.top().second;
        frame_weights.push_back(delta_weights_.top());
        delta_weights_.pop();
        if (debug_weights) {
          if (current_frame_weight_debug_.size() <= frame)
            current_frame_weight_debug_.resize(frame + 1, 0.0);
          current_frame_weight_debug_[frame] += weight;
        }
      }
      if ((!info_.use_most_recent_ivector && t % ivector_period == 0) ||
          (info_.use_most_recent_ivector && t == frame)) {
        UpdateStatsForFrames(frame_weights);
        frame_weights.clear();
        ivector_stats_.GetIvector(num_cg_iters, &current_ivector_);
        if (!info_.use_most_recent_ivector) {  // need to cache iVectors.
          int32 ivec_index = t / ivector_period;
          KALDI_ASSERT(ivec_index == static_cast<int32>(ivectors_history_.size()));
          ivectors_history_.push_back(new Vector<BaseFloat>(current_ivector_));
        }
      }
    }
    if (!frame_weights.empty())
      UpdateStatsForFrames(frame_weights);
  }
  
  
  void OnlineIvectorFeature::GetFrame(int32 frame,
                                      VectorBase<BaseFloat> *feat) {
    int32 frame_to_update_until = (info_.greedy_ivector_extractor ?
                                   lda_->NumFramesReady() - 1 : frame);
    if (!delta_weights_provided_)  // No silence weighting.
      UpdateStatsUntilFrame(frame_to_update_until);
    else
      UpdateStatsUntilFrameWeighted(frame_to_update_until);
  
    KALDI_ASSERT(feat->Dim() == this->Dim());
  
    if (info_.use_most_recent_ivector) {
      KALDI_VLOG(5) << "due to --use-most-recent-ivector=true, using iVector "
                    << "from frame " << num_frames_stats_ << " for frame "
                    << frame;
      // use the most recent iVector we have, even if 'frame' is significantly in
      // the past.
      feat->CopyFromVec(current_ivector_);
      // Subtract the prior-mean from the first dimension of the output feature so
      // it's approximately zero-mean.
      (*feat)(0) -= info_.extractor.PriorOffset();
    } else {
      int32 i = frame / info_.ivector_period;  // rounds down.
      // if the following fails, UpdateStatsUntilFrame would have a bug.
      KALDI_ASSERT(static_cast<size_t>(i) <  ivectors_history_.size());
      feat->CopyFromVec(*(ivectors_history_[i]));
      (*feat)(0) -= info_.extractor.PriorOffset();
    }
  }
  
  void OnlineIvectorFeature::PrintDiagnostics() const {
    if (num_frames_stats_ == 0) {
      KALDI_VLOG(3) << "Processed no data.";
    } else {
      KALDI_VLOG(3) << "UBM log-likelihood was "
                    << (tot_ubm_loglike_ / NumFrames())
                    << " per frame, over " << NumFrames()
                    << " frames.";
  
      Vector<BaseFloat> temp_ivector(current_ivector_);
      temp_ivector(0) -= info_.extractor.PriorOffset();
  
      KALDI_VLOG(2) << "By the end of the utterance, objf change/frame "
                    << "from estimating iVector (vs. default) was "
                    << ivector_stats_.ObjfChange(current_ivector_)
                    << " and iVector length was "
                    << temp_ivector.Norm(2.0);
    }
  }
  
  OnlineIvectorFeature::~OnlineIvectorFeature() {
    PrintDiagnostics();
    // Delete objects owned here.
    for (size_t i = 0; i < to_delete_.size(); i++)
      delete to_delete_[i];
    for (size_t i = 0; i < ivectors_history_.size(); i++)
      delete ivectors_history_[i];
  }
  
  void OnlineIvectorFeature::GetAdaptationState(
      OnlineIvectorExtractorAdaptationState *adaptation_state) const {
    // Note: the following call will work even if cmvn_->NumFramesReady() == 0; in
    // that case it will return the unmodified adaptation state that cmvn_ was
    // initialized with.
    cmvn_->GetState(cmvn_->NumFramesReady() - 1,
                    &(adaptation_state->cmvn_state));
    adaptation_state->ivector_stats = ivector_stats_;
    adaptation_state->LimitFrames(info_.max_remembered_frames,
                                  info_.posterior_scale);
  }
  
  
  OnlineIvectorFeature::OnlineIvectorFeature(
      const OnlineIvectorExtractionInfo &info,
      OnlineFeatureInterface *base_feature):
      info_(info),
      base_(base_feature),
      ivector_stats_(info_.extractor.IvectorDim(),
                     info_.extractor.PriorOffset(),
                     info_.max_count),
      num_frames_stats_(0), delta_weights_provided_(false),
      updated_with_no_delta_weights_(false),
      most_recent_frame_with_weight_(-1), tot_ubm_loglike_(0.0) {
    info.Check();
    KALDI_ASSERT(base_feature != NULL);
    OnlineFeatureInterface *splice_feature = new OnlineSpliceFrames(info_.splice_opts, base_feature);
    to_delete_.push_back(splice_feature);
    OnlineFeatureInterface *lda_feature = new OnlineTransform(info.lda_mat, splice_feature);
    to_delete_.push_back(lda_feature);
    OnlineFeatureInterface *lda_cache_feature = new OnlineCacheFeature(lda_feature);
    lda_ = lda_cache_feature;
    to_delete_.push_back(lda_cache_feature);
  
  
    OnlineCmvnState naive_cmvn_state(info.global_cmvn_stats);
    // Note: when you call this constructor the CMVN state knows nothing
    // about the speaker.  If you want to inform this class about more specific
    // adaptation state, call this->SetAdaptationState(), most likely derived
    // from a call to GetAdaptationState() from a previous object of this type.
    cmvn_ = new OnlineCmvn(info.cmvn_opts, naive_cmvn_state, base_feature);
    to_delete_.push_back(cmvn_);
  
    OnlineFeatureInterface *splice_normalized =
        new OnlineSpliceFrames(info_.splice_opts, cmvn_),
        *lda_normalized =
        new OnlineTransform(info.lda_mat, splice_normalized),
        *cache_normalized = new OnlineCacheFeature(lda_normalized);
    lda_normalized_ = cache_normalized;
  
    to_delete_.push_back(splice_normalized);
    to_delete_.push_back(lda_normalized);
    to_delete_.push_back(cache_normalized);
  
    // Set the iVector to its default value, [ prior_offset, 0, 0, ... ].
    current_ivector_.Resize(info_.extractor.IvectorDim());
    current_ivector_(0) = info_.extractor.PriorOffset();
  }
  
  void OnlineIvectorFeature::SetAdaptationState(
      const OnlineIvectorExtractorAdaptationState &adaptation_state) {
    KALDI_ASSERT(num_frames_stats_ == 0 &&
                 "SetAdaptationState called after frames were processed.");
    KALDI_ASSERT(ivector_stats_.IvectorDim() ==
                 adaptation_state.ivector_stats.IvectorDim());
    ivector_stats_ = adaptation_state.ivector_stats;
    cmvn_->SetState(adaptation_state.cmvn_state);
  }
  
  BaseFloat OnlineIvectorFeature::UbmLogLikePerFrame() const {
    if (NumFrames() == 0) return 0;
    else return tot_ubm_loglike_ / NumFrames();
  }
  
  BaseFloat OnlineIvectorFeature::ObjfImprPerFrame() const {
    return ivector_stats_.ObjfChange(current_ivector_);
  }
  
  
  OnlineSilenceWeighting::OnlineSilenceWeighting(
      const TransitionModel &trans_model,
      const OnlineSilenceWeightingConfig &config,
      int32 frame_subsampling_factor):
      trans_model_(trans_model), config_(config),
      frame_subsampling_factor_(frame_subsampling_factor),
      num_frames_output_and_correct_(0) {
    KALDI_ASSERT(frame_subsampling_factor_ >= 1);
    std::vector<int32> silence_phones;
    SplitStringToIntegers(config.silence_phones_str, ":,", false,
                          &silence_phones);
    for (size_t i = 0; i < silence_phones.size(); i++)
      silence_phones_.insert(silence_phones[i]);
  }
  
  
  template <typename FST>
  void OnlineSilenceWeighting::ComputeCurrentTraceback(
      const LatticeFasterOnlineDecoderTpl<FST> &decoder) {
    int32 num_frames_decoded = decoder.NumFramesDecoded(),
        num_frames_prev = frame_info_.size();
    // note, num_frames_prev is not the number of frames previously decoded,
    // it's the generally-larger number of frames that we were requested to
    // provide weights for.
    if (num_frames_prev < num_frames_decoded)
      frame_info_.resize(num_frames_decoded);
    if (num_frames_prev > num_frames_decoded &&
        frame_info_[num_frames_decoded].transition_id != -1)
      KALDI_ERR << "Number of frames decoded decreased";  // Likely bug
  
    if (num_frames_decoded == 0)
      return;
    int32 frame = num_frames_decoded - 1;
    bool use_final_probs = false;
    typename LatticeFasterOnlineDecoderTpl<FST>::BestPathIterator iter =
        decoder.BestPathEnd(use_final_probs, NULL);
    while (frame >= 0) {
      LatticeArc arc;
      arc.ilabel = 0;
      while (arc.ilabel == 0)  // the while loop skips over input-epsilons
        iter = decoder.TraceBackBestPath(iter, &arc);
      // note, the iter.frame values are slightly unintuitively defined,
      // they are one less than you might expect.
      KALDI_ASSERT(iter.frame == frame - 1);
  
      if (frame_info_[frame].token == iter.tok) {
        // we know that the traceback from this point back will be identical, so
        // no point tracing back further.  Note: we are comparing memory addresses
        // of tokens of the decoder; this guarantees it's the same exact token
        // because tokens, once allocated on a frame, are only deleted, never
        // reallocated for that frame.
        break;
      }
  
      if (num_frames_output_and_correct_ > frame)
        num_frames_output_and_correct_ = frame;
  
      frame_info_[frame].token = iter.tok;
      frame_info_[frame].transition_id = arc.ilabel;
      frame--;
      // leave frame_info_.current_weight at zero for now (as set in the
      // constructor), reflecting that we haven't already output a weight for that
      // frame.
    }
  }
  
  // Instantiate the template OnlineSilenceWeighting::ComputeCurrentTraceback().
  template
  void OnlineSilenceWeighting::ComputeCurrentTraceback<fst::Fst<fst::StdArc> >(
      const LatticeFasterOnlineDecoderTpl<fst::Fst<fst::StdArc> > &decoder);
  template
  void OnlineSilenceWeighting::ComputeCurrentTraceback<fst::GrammarFst>(
      const LatticeFasterOnlineDecoderTpl<fst::GrammarFst> &decoder);
  
  int32 OnlineSilenceWeighting::GetBeginFrame() {
    int32 max_duration = config_.max_state_duration;
    if (max_duration <= 0 || num_frames_output_and_correct_ == 0)
      return num_frames_output_and_correct_;
  
    // t_last_untouched is the index of the last frame that is not newly touched
    // by ComputeCurrentTraceback.  We are interested in whether it is part of a
    // run of length greater than max_duration, since this would force it
    // to be treated as silence (note: typically a non-silence phone that's very
    // long is really silence, for example this can happen with the word "mm").
  
    int32 t_last_untouched = num_frames_output_and_correct_ - 1,
        t_end = frame_info_.size();
    int32 transition_id = frame_info_[t_last_untouched].transition_id;
    // no point searching longer than max_duration; when the length of the run is
    // at least that much, a longer length makes no difference.
    int32 lower_search_bound = std::max(0, t_last_untouched - max_duration),
        upper_search_bound = std::min(t_last_untouched + max_duration, t_end - 1),
        t_lower, t_upper;
  
    // t_lower will be the first index in the run of equal transition-ids.
    for (t_lower = t_last_untouched;
         t_lower > lower_search_bound &&
             frame_info_[t_lower - 1].transition_id == transition_id; t_lower--);
  
    // t_lower will be the last index in the run of equal transition-ids.
    for (t_upper = t_last_untouched;
         t_upper < upper_search_bound &&
             frame_info_[t_upper + 1].transition_id == transition_id; t_upper++);
  
    int32 run_length = t_upper - t_lower + 1;
    if (run_length <= max_duration) {
      // we wouldn't treat this run as being silence, as it's within
      // the duration limit.  So we return the default value
      // num_frames_output_and_correct_ as our lower bound for processing.
      return num_frames_output_and_correct_;
    }
    int32 old_run_length = t_last_untouched - t_lower + 1;
    if (old_run_length > max_duration) {
      // The run-length before we got this new data was already longer than the
      // max-duration, so would already have been treated as silence.  therefore
      // we don't have to encompass it all- we just include a long enough length
      // in the region we are going to process, that the run-length in that region
      // is longer than max_duration.
      int32 ans = t_upper - max_duration;
      KALDI_ASSERT(ans >= t_lower);
      return ans;
    } else {
      return t_lower;
    }
  }
  
  void OnlineSilenceWeighting::GetDeltaWeights(
      int32 num_frames_ready_in,
      std::vector<std::pair<int32, BaseFloat> > *delta_weights) {
    // num_frames_ready_in is at the feature frame-rate, most of the code
    // in this function is at the decoder frame-rate.
    // round up, so we are sure to get weights for at least the frame
    // 'num_frames_ready_in - 1', and maybe one or two frames afterward.
    int32 fs = frame_subsampling_factor_,
    num_frames_ready = (num_frames_ready_in + fs - 1) / fs;
  
    const int32 max_state_duration = config_.max_state_duration;
    const BaseFloat silence_weight = config_.silence_weight;
  
    delta_weights->clear();
  
    if (frame_info_.size() < static_cast<size_t>(num_frames_ready))
      frame_info_.resize(num_frames_ready);
  
    // we may have to make begin_frame earlier than num_frames_output_and_correct_
    // so that max_state_duration is properly enforced.   GetBeginFrame() handles
    // this logic.
    int32 begin_frame = GetBeginFrame(),
        frames_out = static_cast<int32>(frame_info_.size()) - begin_frame;
    // frames_out is the number of frames we will output.
    KALDI_ASSERT(frames_out >= 0);
    std::vector<BaseFloat> frame_weight(frames_out, 1.0);
    // we will set frame_weight to the value silence_weight for silence frames and
    // for transition-ids that repeat with duration > max_state_duration.  Frames
    // newer than the most recent traceback will get a weight equal to the weight
    // for the most recent frame in the traceback; or the silence weight, if there
    // is no traceback at all available yet.
  
    // First treat some special cases.
    if (frames_out == 0)  // Nothing to output.
      return;
    if (frame_info_[begin_frame].transition_id == -1) {
      // We do not have any traceback at all within the frames we are to output...
      // find the most recent weight that we output and apply the same weight to
      // all the new output; or output the silence weight, if nothing was output.
      BaseFloat weight = (begin_frame == 0 ? silence_weight :
                          frame_info_[begin_frame - 1].current_weight);
      for (int32 offset = 0; offset < frames_out; offset++)
        frame_weight[offset] = weight;
    } else {
      int32 current_run_start_offset = 0;
      for (int32 offset = 0; offset < frames_out; offset++) {
        int32 frame = begin_frame + offset;
        int32 transition_id = frame_info_[frame].transition_id;
        if (transition_id == -1) {
          // this frame does not yet have a decoder traceback, so just
          // duplicate the silence/non-silence status of the most recent
          // frame we have a traceback for (probably a reasonable guess).
          frame_weight[offset] = frame_weight[offset - 1];
        } else {
          int32 phone = trans_model_.TransitionIdToPhone(transition_id);
          bool is_silence = (silence_phones_.count(phone) != 0);
          if (is_silence)
            frame_weight[offset] = silence_weight;
          // now deal with max-duration issues.
          if (max_state_duration > 0 &&
              (offset + 1 == frames_out ||
               transition_id != frame_info_[frame + 1].transition_id)) {
            // If this is the last frame of a run...
            int32 run_length = offset - current_run_start_offset + 1;
            if (run_length >= max_state_duration) {
              // treat runs of the same transition-id longer than the max, as
              // silence, even if they were not silence.
              for (int32 offset2 = current_run_start_offset;
                   offset2 <= offset; offset2++)
                frame_weight[offset2] = silence_weight;
            }
            if (offset + 1 < frames_out)
              current_run_start_offset = offset + 1;
          }
        }
      }
    }
    // Now commit the stats...
    for (int32 offset = 0; offset < frames_out; offset++) {
      int32 frame = begin_frame + offset;
      BaseFloat old_weight = frame_info_[frame].current_weight,
          new_weight = frame_weight[offset],
          weight_diff = new_weight - old_weight;
      frame_info_[frame].current_weight = new_weight;
      KALDI_VLOG(6) << "Weight for frame " << frame << " changing from "
                    << old_weight << " to " << new_weight;
      // Even if the delta-weight is zero for the last frame, we provide it,
      // because the identity of the most recent frame with a weight is used in
      // some debugging/checking code.
      if (weight_diff != 0.0 || offset + 1 == frames_out) {
        for(int32 i = 0; i < frame_subsampling_factor_; i++) {
  	int32 input_frame = (frame * frame_subsampling_factor_) + i;
  	delta_weights->push_back(std::make_pair(input_frame, weight_diff));
        }
      }
    }
  }
  
  }  // namespace kaldi