Nanako/Alicho
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构音频环形缓冲区，优化成员变量初始化，简化函数返回类型

Browse Source
This commit is contained in:
daiqingshuang
2025-09-03 16:36:37 +08:00
parent 31b9f459ba
commit c3f1664156
1 changed files with 52 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/backend/src/misc/src/audio_ring_buffer.h
View File

@@ -44,10 +44,10 @@ private:
std::atomic<size_t> processed_read_pos{ 0 };
std::atomic<size_t> audio_write_pos{ 0 };
std::atomic<size_t> audio_read_pos{ 0 };
size_t queue_capacity;
size_t audio_buffer_size;
size_t block_size;
char initialized; // 初始化标志
size_t queue_capacity{};
size_t audio_buffer_size{};
size_t block_size{};
char initialized{}; // 初始化标志
shared_control_block() = default;
@@ -77,10 +77,9 @@ private:
// 共享内存中的数据结构
shared_control_block* control_;
queue_entry* pending_queue_;
queue_entry* processed_queue_;
T* audio_buffer_;
queue_entry* pending_queue_;
queue_entry* processed_queue_;
T* audio_buffer_;
public:
// 构造函数1：创建新的共享内存段
audio_ring_buffer(const char* segment_name,
@@ -100,7 +99,7 @@ public:
}
// 构造函数2：连接到现有共享内存段
audio_ring_buffer(const char* segment_name) : segment_(nullptr),
explicit audio_ring_buffer(const char* segment_name) : segment_(nullptr),
owns_segment_(true) {
segment_ = new bip::managed_shared_memory(bip::open_only, segment_name);
@@ -116,7 +115,7 @@ public:
}
// 构造函数4：连接到外部managed_shared_memory中的现有结构
audio_ring_buffer(bip::managed_shared_memory& external_segment) : segment_(&external_segment),
explicit audio_ring_buffer(bip::managed_shared_memory& external_segment) : segment_(&external_segment),
owns_segment_(false) {
connect_to_existing_structures();
}
@@ -157,11 +156,11 @@ public:
audio_ring_buffer& operator=(const audio_ring_buffer&) = delete;
// 获取可用的音频块用于写入
audio_block acquire_pending_block(size_t required_size) {
size_t write_pos = control_->audio_write_pos.load(std::memory_order_acquire);
size_t read_pos = control_->audio_read_pos.load(std::memory_order_acquire);
auto acquire_pending_block(size_t required_size) {
auto write_pos = control_->audio_write_pos.load(std::memory_order_acquire);
auto read_pos = control_->audio_read_pos.load(std::memory_order_acquire);
size_t available = calculate_available_space(write_pos, read_pos);
auto available = calculate_available_space(write_pos, read_pos);
if (available < required_size) { return audio_block(); }
// 处理环绕
@@ -176,26 +175,26 @@ public:
return audio_block(audio_buffer_ + write_pos, required_size);
}
bool commit_pending_block(const audio_block& block, uint64_t timestamp = 0) {
size_t queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
size_t queue_read = control_->pending_read_pos.load(std::memory_order_acquire);
auto commit_pending_block(const audio_block& block, uint64_t timestamp = 0) {
auto queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
auto queue_read = control_->pending_read_pos.load(std::memory_order_acquire);
if (is_queue_full(queue_write, queue_read)) { return false; }
size_t audio_offset = block.data - audio_buffer_;
auto audio_offset = block.data - audio_buffer_;
pending_queue_[queue_write] = queue_entry(audio_offset, block.size, timestamp);
control_->audio_write_pos.store(audio_offset + block.size, std::memory_order_release);
size_t next_write = (queue_write + 1) % control_->queue_capacity;
auto next_write = (queue_write + 1) % control_->queue_capacity;
control_->pending_write_pos.store(next_write, std::memory_order_release);
return true;
}
audio_block get_pending_block() {
size_t queue_read = control_->pending_read_pos.load(std::memory_order_acquire);
size_t queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
auto get_pending_block() {
auto queue_read = control_->pending_read_pos.load(std::memory_order_acquire);
auto queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
if (queue_read == queue_write) { return audio_block(); }
@@ -203,21 +202,21 @@ public:
return audio_block(audio_buffer_ + entry.audio_offset, entry.size, entry.timestamp);
}
bool complete_pending_block() {
size_t pending_read = control_->pending_read_pos.load(std::memory_order_acquire);
size_t pending_write = control_->pending_write_pos.load(std::memory_order_acquire);
auto complete_pending_block() {
auto pending_read = control_->pending_read_pos.load(std::memory_order_acquire);
auto pending_write = control_->pending_write_pos.load(std::memory_order_acquire);
if (pending_read == pending_write) { return false; }
size_t processed_write = control_->processed_write_pos.load(std::memory_order_acquire);
size_t processed_read = control_->processed_read_pos.load(std::memory_order_acquire);
auto processed_write = control_->processed_write_pos.load(std::memory_order_acquire);
auto processed_read = control_->processed_read_pos.load(std::memory_order_acquire);
if (is_queue_full(processed_write, processed_read)) { return false; }
processed_queue_[processed_write] = pending_queue_[pending_read];
size_t next_pending_read = (pending_read + 1) % control_->queue_capacity;
size_t next_processed_write = (processed_write + 1) % control_->queue_capacity;
auto next_pending_read = (pending_read + 1) % control_->queue_capacity;
auto next_processed_write = (processed_write + 1) % control_->queue_capacity;
control_->pending_read_pos.store(next_pending_read, std::memory_order_release);
control_->processed_write_pos.store(next_processed_write, std::memory_order_release);
@@ -225,9 +224,9 @@ public:
return true;
}
audio_block get_processed_block() {
size_t queue_read = control_->processed_read_pos.load(std::memory_order_acquire);
size_t queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
auto get_processed_block() {
auto queue_read = control_->processed_read_pos.load(std::memory_order_acquire);
auto queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
if (queue_read == queue_write) { return audio_block(); }
@@ -235,39 +234,39 @@ public:
return audio_block(audio_buffer_ + entry.audio_offset, entry.size, entry.timestamp);
}
bool release_processed_block() {
size_t queue_read = control_->processed_read_pos.load(std::memory_order_acquire);
size_t queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
auto release_processed_block() {
auto queue_read = control_->processed_read_pos.load(std::memory_order_acquire);
auto queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
if (queue_read == queue_write) { return false; }
const queue_entry& entry = processed_queue_[queue_read];
size_t expected_read_pos = entry.audio_offset + entry.size;
auto expected_read_pos = entry.audio_offset + entry.size;
control_->audio_read_pos.store(expected_read_pos, std::memory_order_release);
size_t next_read = (queue_read + 1) % control_->queue_capacity;
auto next_read = (queue_read + 1) % control_->queue_capacity;
control_->processed_read_pos.store(next_read, std::memory_order_release);
return true;
}
// 状态查询方法
size_t pending_count() const {
size_t write = control_->pending_write_pos.load(std::memory_order_acquire);
size_t read = control_->pending_read_pos.load(std::memory_order_acquire);
[[nodiscard]] auto pending_count() const {
auto write = control_->pending_write_pos.load(std::memory_order_acquire);
auto read = control_->pending_read_pos.load(std::memory_order_acquire);
return (write >= read) ? (write - read) : (control_->queue_capacity - read + write);
}
size_t processed_count() const {
size_t write = control_->processed_write_pos.load(std::memory_order_acquire);
size_t read = control_->processed_read_pos.load(std::memory_order_acquire);
[[nodiscard]] auto processed_count() const {
auto write = control_->processed_write_pos.load(std::memory_order_acquire);
auto read = control_->processed_read_pos.load(std::memory_order_acquire);
return (write >= read) ? (write - read) : (control_->queue_capacity - read + write);
}
size_t available_audio_space() const {
size_t write = control_->audio_write_pos.load(std::memory_order_acquire);
size_t read = control_->audio_read_pos.load(std::memory_order_acquire);
[[nodiscard]] auto available_audio_space() const {
auto write = control_->audio_write_pos.load(std::memory_order_acquire);
auto read = control_->audio_read_pos.load(std::memory_order_acquire);
return calculate_available_space(write, read);
}
@@ -281,13 +280,12 @@ public:
}
// Boost特有的功能
bip::managed_shared_memory& get_segment() { return *segment_; }
const bip::managed_shared_memory& get_segment() const { return *segment_; }
[[nodiscard]] auto& get_segment() { return *segment_; }
[[nodiscard]] const auto& get_segment() const { return *segment_; }
// 获取共享内存使用统计
size_t get_free_memory() const { return segment_->get_free_memory(); }
size_t get_size() const { return segment_->get_size(); }
[[nodiscard]] auto get_free_memory() const { return segment_->get_free_memory(); }
[[nodiscard]] auto get_size() const { return segment_->get_size(); }
private:
void initialize_shared_structures(size_t queue_capacity, size_t audio_buffer_capacity) {
// 在共享内存中构造控制块
@@ -330,12 +328,12 @@ private:
audio_buffer_ = audio_result.first;
}
size_t calculate_available_space(size_t write_pos, size_t read_pos) const {
[[nodiscard]] auto calculate_available_space(size_t write_pos, size_t read_pos) const {
if (write_pos >= read_pos) { return control_->audio_buffer_size - write_pos + read_pos - 1; }
else { return read_pos - write_pos - 1; }
return read_pos - write_pos - 1;
}
bool is_queue_full(size_t write_pos, size_t read_pos) const {
[[nodiscard]] auto is_queue_full(size_t write_pos, size_t read_pos) const {
return ((write_pos + 1) % control_->queue_capacity) == read_pos;
}
};