Move AlignSample to separate file

1 files changed, 1 insertions, 175 deletions

diff --git a/main.cpp b/main.cpp
index 88edf6d..4477ef5 100644
--- a/main.cpp
+++ b/main.cpp
@@ -22,6 +22,7 @@
  */
 
 #include "OutputUHD.hpp"
+#include "AlignSample.hpp"
 #include "utils.hpp"
 #include <zmq.hpp>
 #include <thread>
@@ -39,9 +40,6 @@ void sig_int_handler(int) {
     running = false;
 }
 
-const size_t samps_per_buffer = 20480;
-const size_t samplerate = 2048000;
-
 size_t read_samples(FILE* fd, std::vector<complexf>& samples, size_t count)
 {
     if (samples.size() < count) {
@@ -58,178 +56,6 @@ size_t read_samples(FILE* fd, std::vector<complexf>& samples, size_t count)
     return num_read;
 }
 
-struct CorrelationResult {
-    CorrelationResult(size_t len) :
-        correlation(len),
-        rx_power(0),
-        tx_power(0),
-        rx_timestamp(0),
-        tx_timestamp(0) {}
-
-    std::vector<complexf> correlation;
-    double rx_power;
-    double tx_power;
-
-    double rx_timestamp;
-    double tx_timestamp;
-};
-
-class AlignSample {
-    public:
-        AlignSample() {
-            m_first_rx_sample_time = 0;
-            m_first_tx_sample_time = 0;
-            m_num_rx_samples_dropped = 0;
-            m_num_tx_samples_dropped = 0;
-        }
-
-        void push_tx_samples(complexf* samps, size_t len, double first_sample_time) {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            std::copy(samps, samps + len, std::back_inserter(m_txsamples));
-
-            if (m_first_tx_sample_time == 0) {
-                m_first_tx_sample_time = first_sample_time;
-            }
-        }
-
-        void push_rx_samples(complexf* samps, size_t len, double first_sample_time) {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            std::copy(samps, samps + len, std::back_inserter(m_rxsamples));
-
-            if (m_first_rx_sample_time == 0) {
-                m_first_rx_sample_time = first_sample_time;
-            }
-        }
-
-        bool ready(size_t min_samples) {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            return align() and m_rxsamples.size() > min_samples and m_txsamples.size() > min_samples;
-        }
-
-        void debug() {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            MDEBUG("Aligner\n");
-            MDEBUG("  RX: %f %zu\n", m_rx_sample_time(), m_rxsamples.size());
-            MDEBUG("  TX: %f %zu\n", m_tx_sample_time(), m_txsamples.size());
-        }
-
-        CorrelationResult crosscorrelate(size_t max_offset, size_t len) {
-            std::vector<complexf> rxsamps;
-            std::vector<complexf> txsamps;
-            double rx_ts = 0;
-            double tx_ts = 0;
-
-            // Do a quick copy, so as to free the mutex
-            {
-                std::lock_guard<std::mutex> lock(m_mutex);
-
-                if (!align() or
-                        m_rxsamples.size() < len or
-                        m_txsamples.size() < len + max_offset) {
-                    CorrelationResult result(0);
-                    return result;
-                }
-
-                std::copy(m_rxsamples.begin(), m_rxsamples.begin() + len, std::back_inserter(rxsamps));
-                std::copy(m_txsamples.begin(), m_txsamples.begin() + len + max_offset, std::back_inserter(txsamps));
-
-                m_rxsamples.erase(m_rxsamples.begin(), m_rxsamples.begin() + len);
-                m_txsamples.erase(m_txsamples.begin(), m_txsamples.begin() + len + max_offset);
-
-                rx_ts = m_rx_sample_time();
-                tx_ts = m_tx_sample_time();
-            }
-
-            CorrelationResult result(max_offset);
-            result.rx_timestamp = rx_ts;
-            result.tx_timestamp = tx_ts;
-
-            auto& xcorrs = result.correlation;
-
-            // Calculate power
-            for (auto sample : rxsamps) {
-                result.rx_power += std::norm(sample);
-            }
-            result.rx_power = std::sqrt(result.rx_power);
-
-            for (auto sample : txsamps) {
-                result.tx_power += std::norm(sample);
-            }
-            result.tx_power = std::sqrt(result.tx_power);
-
-            // Calculate correlation
-            for (size_t offset = 0; offset < max_offset; offset++) {
-                complexf xcorr(0, 0);
-
-                for (size_t i = 0; i < len; i++) {
-                    xcorr += rxsamps[i] * std::conj(txsamps[i+offset]);
-                }
-                xcorrs[offset] = xcorr;
-            }
-
-            return result;
-        }
-
-        void consume(size_t samples)
-        {
-            std::lock_guard<std::mutex> lock(m_mutex);
-            if (align() and m_rxsamples.size() > samples and m_txsamples.size() > samples) {
-                m_rxsamples.erase(m_rxsamples.begin(), m_rxsamples.begin() + samples);
-                m_num_rx_samples_dropped += samples;
-
-                m_txsamples.erase(m_txsamples.begin(), m_txsamples.begin() + samples);
-                m_num_tx_samples_dropped += samples;
-            }
-        }
-
-    private:
-        bool align() {
-            if (std::abs(m_rx_sample_time() - m_tx_sample_time()) < 1e-6) {
-                return true;
-            }
-            else if (m_rx_sample_time() < m_tx_sample_time()) {
-                size_t rx_samples_to_skip = (m_tx_sample_time() - m_rx_sample_time()) * samplerate;
-
-                if (rx_samples_to_skip > m_rxsamples.size()) {
-                    return false;
-                }
-
-                m_rxsamples.erase(m_rxsamples.begin(), m_rxsamples.begin() + rx_samples_to_skip);
-                m_num_rx_samples_dropped += rx_samples_to_skip;
-                return true;
-            }
-            else if (m_rx_sample_time() > m_tx_sample_time()) {
-                size_t tx_samples_to_skip = (m_rx_sample_time() - m_tx_sample_time()) * samplerate;
-
-                if (tx_samples_to_skip > m_txsamples.size()) {
-                    return false;
-                }
-
-                m_txsamples.erase(m_txsamples.begin(), m_txsamples.begin() + tx_samples_to_skip);
-                m_num_tx_samples_dropped += tx_samples_to_skip;
-                return true;
-            }
-            return false;
-        }
-
-        double m_rx_sample_time() {
-            return m_first_rx_sample_time + (double)m_num_rx_samples_dropped / samplerate;
-        }
-
-        double m_tx_sample_time() {
-            return m_first_tx_sample_time + (double)m_num_tx_samples_dropped / samplerate;
-        }
-
-        std::mutex m_mutex;
-        double m_first_rx_sample_time;
-        size_t m_num_rx_samples_dropped;
-        std::deque<complexf> m_rxsamples;
-
-        double m_first_tx_sample_time;
-        size_t m_num_tx_samples_dropped;
-        std::deque<complexf> m_txsamples;
-};
-
 AlignSample aligner;
 
 size_t do_receive(OutputUHD* output_uhd)