You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
6.4 KiB
204 lines
6.4 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#ifndef MODEMDVB_SAMPLETHREAD_H |
|
#define MODEMDVB_SAMPLETHREAD_H |
|
|
|
#include <cassert> |
|
#include <complex> |
|
#include <condition_variable> |
|
#include <deque> |
|
#include <exception> |
|
#include <functional> |
|
#include <mutex> |
|
#include <thread> |
|
#include <vector> |
|
|
|
// Internal to modemdvb: runs a function on blocks of samples, in the order given, in a thread of its own, so the |
|
// caller can get on with something else. The caller waits if too many samples are queued. Destroying it waits for the |
|
// block being processed, but drops those queued: drain() first to have them processed |
|
class SampleThread |
|
{ |
|
public: |
|
typedef std::complex<float> Cf; |
|
typedef std::function<void(const Cf *samples, int nbSamples)> Process; |
|
|
|
explicit SampleThread(Process process, size_t maxQueued = 1 << 20) : |
|
m_process(process), |
|
m_maxQueued(maxQueued), |
|
m_queued(0), |
|
m_busy(false), |
|
m_stop(false) |
|
{ |
|
m_thread = std::thread(&SampleThread::run, this); |
|
} |
|
|
|
~SampleThread() |
|
{ |
|
{ |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_stop = true; |
|
} |
|
|
|
m_available.notify_all(); |
|
m_space.notify_all(); |
|
m_thread.join(); |
|
} |
|
|
|
void push(const Cf *samples, int nbSamples) |
|
{ |
|
if (nbSamples <= 0) { |
|
return; |
|
} |
|
|
|
std::vector<Cf> block; |
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
|
|
if (!m_free.empty()) |
|
{ |
|
block = std::move(m_free.back()); |
|
m_free.pop_back(); |
|
} |
|
|
|
lock.unlock(); |
|
block.assign(samples, samples + nbSamples); |
|
lock.lock(); |
|
m_space.wait(lock, [this]() { return m_stop || (m_queued < m_maxQueued); }); |
|
m_queued += nbSamples; |
|
m_queue.push_back(std::move(block)); |
|
lock.unlock(); |
|
m_available.notify_one(); |
|
} |
|
|
|
//! The same, without copying: block's samples are taken, and it's given a buffer to reuse, of any size (not |
|
//! cleared, so resizing it to about the size it was doesn't have to fill it) |
|
void push(std::vector<Cf>& block) |
|
{ |
|
if (block.empty()) { |
|
return; |
|
} |
|
|
|
std::vector<Cf> queued; |
|
queued.swap(block); |
|
const size_t nbSamples = queued.size(); |
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
|
|
if (!m_free.empty()) |
|
{ |
|
block.swap(m_free.back()); |
|
m_free.pop_back(); |
|
} |
|
|
|
m_space.wait(lock, [this]() { return m_stop || (m_queued < m_maxQueued); }); |
|
m_queued += nbSamples; |
|
m_queue.push_back(std::move(queued)); |
|
lock.unlock(); |
|
m_available.notify_one(); |
|
} |
|
|
|
//! Wait until everything queued has been processed. Not from the function (it would wait for itself) |
|
void drain() |
|
{ |
|
const bool own = std::this_thread::get_id() == m_thread.get_id(); |
|
assert(!own); |
|
|
|
if (own) { |
|
return; |
|
} |
|
|
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
m_idle.wait(lock, [this]() { return m_queue.empty() && !m_busy; }); |
|
} |
|
|
|
//! Discard what is queued, and wait for what is being processed. The function isn't called again until more |
|
//! samples are pushed, so the caller can then change what it uses. From the function, only discards (what's being |
|
//! processed is the caller's) |
|
void discard() |
|
{ |
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
|
|
while (!m_queue.empty()) |
|
{ |
|
m_free.push_back(std::move(m_queue.front())); |
|
m_queue.pop_front(); |
|
} |
|
|
|
m_queued = 0; |
|
m_space.notify_all(); |
|
|
|
if (std::this_thread::get_id() != m_thread.get_id()) { |
|
m_idle.wait(lock, [this]() { return !m_busy; }); |
|
} |
|
} |
|
|
|
private: |
|
void run() |
|
{ |
|
while (true) |
|
{ |
|
std::vector<Cf> block; |
|
|
|
{ |
|
std::unique_lock<std::mutex> lock(m_mutex); |
|
m_available.wait(lock, [this]() { return m_stop || !m_queue.empty(); }); |
|
|
|
if (m_stop) { |
|
return; |
|
} |
|
|
|
block = std::move(m_queue.front()); |
|
m_queue.pop_front(); |
|
m_queued -= block.size(); |
|
m_busy = true; |
|
} |
|
|
|
m_space.notify_one(); |
|
|
|
// An exception (out of memory) loses the block, rather than ending the process at the thread's end |
|
try { |
|
m_process(block.data(), (int) block.size()); |
|
} catch (...) { |
|
} |
|
|
|
{ |
|
std::lock_guard<std::mutex> lock(m_mutex); |
|
m_busy = false; |
|
|
|
if (m_free.size() < 16) { |
|
m_free.push_back(std::move(block)); |
|
} |
|
} |
|
|
|
m_idle.notify_all(); |
|
} |
|
} |
|
|
|
Process m_process; |
|
size_t m_maxQueued; //!< Samples |
|
size_t m_queued; |
|
bool m_busy; |
|
bool m_stop; |
|
std::thread m_thread; |
|
std::mutex m_mutex; |
|
std::condition_variable m_available; |
|
std::condition_variable m_space; |
|
std::condition_variable m_idle; |
|
std::deque<std::vector<Cf>> m_queue; |
|
std::vector<std::vector<Cf>> m_free; |
|
}; |
|
|
|
#endif // MODEMDVB_SAMPLETHREAD_H
|
|
|