Method prepareCorrectionIndices

source/zlp/controller.cpp:298–344

    }

    void Controller::prepareCorrectionIndices() {
        correction_on_total_.clear();
        for (size_t lr = 0; lr < 5; ++lr) {
            correction_on_indices_[lr].clear();
            for (const size_t& i : not_off_indices_[lr]) {
                if (c_filter_status_[i] == FilterStatus::kOn && !c_dynamic_on_[i]) {
                    correction_on_total_.emplace_back(i);
                    correction_on_indices_[lr].emplace_back(i);
                }
            }
        }
        if (correction_on_indices_[3].empty() && correction_on_indices_[4].empty()) {
            for (const size_t& i : correction_on_indices_[0]) {
                correction_on_indices_[1].emplace_back(i);
                correction_on_indices_[2].emplace_back(i);
            }
        } else {
            for (const size_t& i : correction_on_indices_[0]) {
                correction_on_indices_[3].emplace_back(i);
                correction_on_indices_[4].emplace_back(i);
            }
        }
        is_lr_on_ = !not_off_indices_[1].empty() || !not_off_indices_[2].empty() || !correction_on_indices_[1].empty()
            || !correction_on_indices_[2].empty();
        is_ms_on_ = !not_off_indices_[3].empty() || !not_off_indices_[4].empty() || !correction_on_indices_[3].empty()
            || !correction_on_indices_[4].empty();
        // get the latency for one correction
        int unit_latency = 0;
        if (c_filter_structure_ == kMatched) {
            unit_latency = match_corrections_[0].getLatency();
        } else if (c_filter_structure_ == kMixed) {
            unit_latency = mixed_corrections_[0].getLatency();
        } else if (c_filter_structure_ == kZero) {
            unit_latency = zero_corrections_[0].getLatency();
        }
        // calculate total latency and update
        int new_latency = 0;
        if (is_lr_on_) {
            new_latency += unit_latency;
        } else if (is_ms_on_) {
            new_latency += unit_latency;
        }
        if (correction_latency_.exchange(new_latency, std::memory_order::relaxed) != new_latency) {
            triggerAsyncUpdate();
        }
        std::fill(to_update_correction_.begin(), to_update_correction_.end(), true);
    }

    void Controller::prepareCorrection() {
        for (const auto& idx : correction_on_total_) {