cnst/cnix
1
0
Fork 0
Code Issues Pull Requests Activity
Files
ce5379ffc74e280ef55374d4d4536ff497b5db49
cnix/modules/home/services/quickshell/shell/assets/beat_detector.cpp
cnst ce5379ffc7 remove qs, fixes to waybar
2025-06-30 17:19:24 +02:00

569 lines
21 KiB
C++
Executable File
Raw Blame History

#include <algorithm>
#include <pipewire/pipewire.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/props.h>
#include <aubio/aubio.h>
#include <memory>
#include <iostream>
#include <fstream>
#include <csignal>
#include <atomic>
#include <vector>
#include <cstring>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <thread>
#include <cmath>
class EnhancedBeatDetector {
private:
static constexpr uint32_t SAMPLE_RATE = 44100;
static constexpr uint32_t CHANNELS = 1;
// PipeWire objects
pw_main_loop* main_loop_;
pw_context* context_;
pw_core* core_;
pw_stream* stream_;
// Aubio objects
std::unique_ptr<aubio_tempo_t, decltype(&del_aubio_tempo)> tempo_;
std::unique_ptr<fvec_t, decltype(&del_fvec)> input_buffer_;
std::unique_ptr<fvec_t, decltype(&del_fvec)> output_buffer_;
// Additional aubio objects for enhanced features
std::unique_ptr<aubio_onset_t, decltype(&del_aubio_onset)> onset_;
std::unique_ptr<aubio_pitch_t, decltype(&del_aubio_pitch)> pitch_;
std::unique_ptr<fvec_t, decltype(&del_fvec)> pitch_buffer_;
const uint32_t buf_size_;
const uint32_t fft_size_;
static std::atomic<bool> should_quit_;
static EnhancedBeatDetector* instance_;
// Enhanced features
std::ofstream log_file_;
bool enable_logging_;
bool enable_performance_stats_;
bool enable_pitch_detection_;
bool enable_visual_feedback_;
// Performance tracking
std::chrono::high_resolution_clock::time_point last_process_time_;
std::vector<double> process_times_;
uint64_t total_beats_;
uint64_t total_onsets_;
std::chrono::steady_clock::time_point start_time_;
// Beat analysis
std::vector<float> recent_bpms_;
static constexpr size_t BPM_HISTORY_SIZE = 10;
float last_bpm_;
std::chrono::steady_clock::time_point last_beat_time_;
// Useless Visual feedback
std::string generate_beat_visual(float bpm, bool is_beat) {
if (!enable_visual_feedback_) return "";
std::stringstream ss;
if (is_beat) {
// Useless Animated beat indicator based on BPM intensity
int intensity = static_cast<int>(std::min(bpm / 20.0f, 10.0f));
ss << "\r";
for (int i = 0; i < intensity; ++i) ss << "█";
for (int i = intensity; i < 10; ++i) ss << "░";
ss << " BPM: " << std::fixed << std::setprecision(1) << bpm;
ss << " | Avg: " << get_average_bpm();
}
return ss.str();
}
public:
explicit EnhancedBeatDetector(uint32_t buf_size = 512,
bool enable_logging = true,
bool enable_performance_stats = true,
bool enable_pitch_detection = false,
bool enable_visual_feedback = true)
: main_loop_(nullptr)
, context_(nullptr)
, core_(nullptr)
, stream_(nullptr)
, tempo_(nullptr, &del_aubio_tempo)
, input_buffer_(nullptr, &del_fvec)
, output_buffer_(nullptr, &del_fvec)
, onset_(nullptr, &del_aubio_onset)
, pitch_(nullptr, &del_aubio_pitch)
, pitch_buffer_(nullptr, &del_fvec)
, buf_size_(buf_size)
, fft_size_(buf_size * 2)
, enable_logging_(enable_logging)
, enable_performance_stats_(enable_performance_stats)
, enable_pitch_detection_(enable_pitch_detection)
, enable_visual_feedback_(enable_visual_feedback)
, total_beats_(0)
, total_onsets_(0)
, last_bpm_(0.0f)
{
instance_ = this;
recent_bpms_.reserve(BPM_HISTORY_SIZE);
if (enable_performance_stats_) {
process_times_.reserve(1000); // Reserve space for performance data
}
initialize();
}
~EnhancedBeatDetector() {
print_final_stats();
cleanup();
instance_ = nullptr;
}
// Delete copy constructor and assignment operator
EnhancedBeatDetector(const EnhancedBeatDetector&) = delete;
EnhancedBeatDetector& operator=(const EnhancedBeatDetector&) = delete;
bool initialize() {
start_time_ = std::chrono::steady_clock::now();
// Useless Initialize logging (actually useful)
if (enable_logging_) {
auto now = std::chrono::system_clock::now();
auto time_t = std::chrono::system_clock::to_time_t(now);
std::stringstream filename;
filename << "beat_log_" << std::put_time(std::localtime(&time_t), "%Y%m%d_%H%M%S") << ".txt";
log_file_.open(filename.str());
if (log_file_.is_open()) {
log_file_ << "# Beat Detection Log - " << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S") << "\n";
log_file_ << "# Timestamp,BPM,Onset,Pitch(Hz),ProcessTime(ms)\n";
std::cout << " Logging to: " << filename.str() << std::endl;
}
}
// Initialize PipeWire
pw_init(nullptr, nullptr);
main_loop_ = pw_main_loop_new(nullptr);
if (!main_loop_) {
std::cerr << " Failed to create main loop" << std::endl;
return false;
}
context_ = pw_context_new(pw_main_loop_get_loop(main_loop_), nullptr, 0);
if (!context_) {
std::cerr << " Failed to create context" << std::endl;
return false;
}
core_ = pw_context_connect(context_, nullptr, 0);
if (!core_) {
std::cerr << " Failed to connect to PipeWire" << std::endl;
return false;
}
// Initialize Aubio objects
tempo_.reset(new_aubio_tempo("default", fft_size_, buf_size_, SAMPLE_RATE));
if (!tempo_) {
std::cerr << " Failed to create aubio tempo detector" << std::endl;
return false;
}
input_buffer_.reset(new_fvec(buf_size_));
output_buffer_.reset(new_fvec(1));
if (!input_buffer_ || !output_buffer_) {
std::cerr << " Failed to create aubio buffers" << std::endl;
return false;
}
// Initialize onset detection
onset_.reset(new_aubio_onset("default", fft_size_, buf_size_, SAMPLE_RATE));
if (!onset_) {
std::cerr << " Failed to create aubio onset detector" << std::endl;
return false;
}
// Initialize pitch detection if enabled
if (enable_pitch_detection_) {
pitch_.reset(new_aubio_pitch("default", fft_size_, buf_size_, SAMPLE_RATE));
pitch_buffer_.reset(new_fvec(1));
if (!pitch_ || !pitch_buffer_) {
std::cerr << " Failed to create aubio pitch detector" << std::endl;
return false;
}
aubio_pitch_set_unit(pitch_.get(), "Hz");
}
return setup_stream();
}
void run() {
if (!main_loop_) return;
print_startup_info();
pw_main_loop_run(main_loop_);
}
void stop() {
should_quit_ = true;
if (main_loop_) {
pw_main_loop_quit(main_loop_);
}
}
static void signal_handler(int sig) {
if (instance_) {
std::cout << "\n Received signal " << sig << ", stopping gracefullllly..." << std::endl;
instance_->stop();
}
}
private:
void print_startup_info() {
std::cout << "\n󰝚 Beat Detector Started!" << std::endl;
std::cout << " Buffer size: " << buf_size_ << " samples" << std::endl;
std::cout << " Sample rate: " << SAMPLE_RATE << " Hz" << std::endl;
std::cout << " Features enabled:" << std::endl;
std::cout << "  Logging: " << (enable_logging_ ? "" : "") << std::endl;
std::cout << "  Performance stats: " << (enable_performance_stats_ ? "" : "") << std::endl;
std::cout << " 󰗅 Pitch detection: " << (enable_pitch_detection_ ? "" : "") << std::endl;
std::cout << "\n Listening for beats... Press Ctrl+C to stop.\n" << std::endl;
}
void print_final_stats() {
if (!enable_performance_stats_) return;
auto end_time = std::chrono::steady_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::seconds>(end_time - start_time_);
std::cout << "\n Final Statistics:" << std::endl;
std::cout << " 󱎫 Total runtime: " << duration.count() << " seconds" << std::endl;
std::cout << "  Total beats detected: " << total_beats_ << std::endl;
std::cout << "  Total onsets detected: " << total_onsets_ << std::endl;
if (!process_times_.empty()) {
double avg_time = 0;
for (double t : process_times_) avg_time += t;
avg_time /= process_times_.size();
auto max_time = *std::max_element(process_times_.begin(), process_times_.end());
auto min_time = *std::min_element(process_times_.begin(), process_times_.end());
std::cout << " ⚡ Average processing time: " << std::fixed << std::setprecision(3)
<< avg_time << " ms" << std::endl;
std::cout << " 📈 Max processing time: " << max_time << " ms" << std::endl;
std::cout << " 📉 Min processing time: " << min_time << " ms" << std::endl;
}
if (!recent_bpms_.empty()) {
std::cout << " 󰝚 Final average BPM: " << get_average_bpm() << std::endl;
}
}
float get_average_bpm() const {
if (recent_bpms_.empty()) return 0.0f;
float sum = 0;
for (float bpm : recent_bpms_) sum += bpm;
return sum / recent_bpms_.size();
}
bool setup_stream() {
// Stream events
static const pw_stream_events stream_events = {
.version = PW_VERSION_STREAM_EVENTS,
.destroy = nullptr,
.state_changed = on_state_changed,
.control_info = nullptr,
.io_changed = nullptr,
.param_changed = nullptr,
.add_buffer = nullptr,
.remove_buffer = nullptr,
.process = on_process,
.drained = nullptr,
.command = nullptr,
.trigger_done = nullptr,
};
stream_ = pw_stream_new_simple(
pw_main_loop_get_loop(main_loop_),
"enhanced-beat-detector",
pw_properties_new(
PW_KEY_MEDIA_TYPE, "Audio",
PW_KEY_MEDIA_CATEGORY, "Capture",
PW_KEY_MEDIA_ROLE, "Music",
nullptr
),
&stream_events,
this
);
if (!stream_) {
std::cerr << " Failed to create stream" << std::endl;
return false;
}
// Audio format parameters
uint8_t buffer[1024];
spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_audio_info_raw audio_info = {};
audio_info.format = SPA_AUDIO_FORMAT_F32_LE;
audio_info.channels = CHANNELS;
audio_info.rate = SAMPLE_RATE;
audio_info.flags = 0;
const spa_pod* params[1];
params[0] = spa_format_audio_raw_build(&pod_builder, SPA_PARAM_EnumFormat, &audio_info);
if (pw_stream_connect(stream_,
PW_DIRECTION_INPUT,
PW_ID_ANY,
static_cast<pw_stream_flags>(
PW_STREAM_FLAG_AUTOCONNECT |
PW_STREAM_FLAG_MAP_BUFFERS |
PW_STREAM_FLAG_RT_PROCESS),
params, 1) < 0) {
std::cerr << " Failed to connect stream" << std::endl;
return false;
}
return true;
}
static void on_state_changed(void* userdata, enum pw_stream_state /* old_state */,
enum pw_stream_state state, const char* error) {
auto* detector = static_cast<EnhancedBeatDetector*>(userdata);
const char* state_emoji = "󰑓 ";
switch (state) {
case PW_STREAM_STATE_CONNECTING: state_emoji = "󰄙 "; break;
case PW_STREAM_STATE_PAUSED: state_emoji = ""; break;
case PW_STREAM_STATE_STREAMING: state_emoji = "󰝚 "; break;
case PW_STREAM_STATE_ERROR: state_emoji = ""; break;
case PW_STREAM_STATE_UNCONNECTED: state_emoji = ""; break;
}
std::cout << state_emoji << " Stream state: " << pw_stream_state_as_string(state) << std::endl;
if (state == PW_STREAM_STATE_ERROR) {
std::cerr << " Stream error: " << (error ? error : "unknown") << std::endl;
detector->stop();
}
}
static void on_process(void* userdata) {
auto* detector = static_cast<EnhancedBeatDetector*>(userdata);
detector->process_audio();
}
void process_audio() {
if (should_quit_) return;
auto process_start = std::chrono::high_resolution_clock::now();
pw_buffer* buffer = pw_stream_dequeue_buffer(stream_);
if (!buffer) return;
spa_buffer* spa_buf = buffer->buffer;
if (!spa_buf->datas[0].data) {
pw_stream_queue_buffer(stream_, buffer);
return;
}
const float* audio_data = static_cast<const float*>(spa_buf->datas[0].data);
const uint32_t n_samples = spa_buf->datas[0].chunk->size / sizeof(float);
// Process in chunks
for (uint32_t offset = 0; offset + buf_size_ <= n_samples; offset += buf_size_) {
std::memcpy(input_buffer_->data, audio_data + offset, buf_size_ * sizeof(float));
// Beat detection
aubio_tempo_do(tempo_.get(), input_buffer_.get(), output_buffer_.get());
bool is_beat = output_buffer_->data[0] != 0.0f;
// Onset detection
aubio_onset_do(onset_.get(), input_buffer_.get(), output_buffer_.get());
bool is_onset = output_buffer_->data[0] != 0.0f;
float pitch_hz = 0.0f;
if (enable_pitch_detection_) {
aubio_pitch_do(pitch_.get(), input_buffer_.get(), pitch_buffer_.get());
pitch_hz = pitch_buffer_->data[0];
}
if (is_beat) {
total_beats_++;
last_bpm_ = aubio_tempo_get_bpm(tempo_.get());
last_beat_time_ = std::chrono::steady_clock::now();
// Update BPM history
recent_bpms_.push_back(last_bpm_);
if (recent_bpms_.size() > BPM_HISTORY_SIZE) {
recent_bpms_.erase(recent_bpms_.begin());
}
// Visual feedback
if (enable_visual_feedback_) {
std::cout << generate_beat_visual(last_bpm_, true) << std::flush;
} else {
std::cout << " BPM: " << std::fixed << std::setprecision(1) << last_bpm_ << std::endl;
}
}
if (is_onset) {
total_onsets_++;
}
// Logging
if (enable_logging_ && log_file_.is_open() && (is_beat || is_onset)) {
auto now = std::chrono::system_clock::now();
auto time_t = std::chrono::system_clock::to_time_t(now);
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
now.time_since_epoch()) % 1000;
log_file_ << std::put_time(std::localtime(&time_t), "%H:%M:%S")
<< "." << std::setfill('0') << std::setw(3) << ms.count() << ","
<< (is_beat ? last_bpm_ : 0) << ","
<< (is_onset ? 1 : 0) << ","
<< pitch_hz << ",";
}
}
pw_stream_queue_buffer(stream_, buffer);
// Performance tracking
if (enable_performance_stats_) {
auto process_end = std::chrono::high_resolution_clock::now();
auto process_time = std::chrono::duration<double, std::milli>(process_end - process_start).count();
if (log_file_.is_open() && (total_beats_ > 0 || total_onsets_ > 0)) {
log_file_ << std::fixed << std::setprecision(3) << process_time << "\n";
}
if (process_times_.size() < 1000) {
process_times_.push_back(process_time);
}
}
}
void cleanup() {
if (log_file_.is_open()) {
log_file_.close();
}
if (stream_) {
pw_stream_destroy(stream_);
stream_ = nullptr;
}
if (core_) {
pw_core_disconnect(core_);
core_ = nullptr;
}
if (context_) {
pw_context_destroy(context_);
context_ = nullptr;
}
if (main_loop_) {
pw_main_loop_destroy(main_loop_);
main_loop_ = nullptr;
}
tempo_.reset();
input_buffer_.reset();
output_buffer_.reset();
onset_.reset();
pitch_.reset();
pitch_buffer_.reset();
pw_deinit();
std::cout << "\n Cleanup complete - All resources freed!" << std::endl;
}
};
// Static member definitions
std::atomic<bool> EnhancedBeatDetector::should_quit_{false};
EnhancedBeatDetector* EnhancedBeatDetector::instance_{nullptr};
void print_usage() {
std::cout << " Beat Detector Usage:" << std::endl;
std::cout << " ./beat_detector [buffer_size] [options]" << std::endl;
std::cout << "\nOptions:" << std::endl;
std::cout << " --no-log Disable logging to file" << std::endl;
std::cout << " --no-stats Disable performance statistics" << std::endl;
std::cout << " --pitch Enable pitch detection" << std::endl;
std::cout << " --no-visual Disable visual feedback" << std::endl;
std::cout << " --help Show this help" << std::endl;
std::cout << "\nExamples:" << std::endl;
std::cout << " ./beat_detector # Default settings" << std::endl;
std::cout << " ./beat_detector 256 --pitch # Smaller buffer with pitch detection" << std::endl;
std::cout << " ./beat_detector 1024 --no-visual # Larger buffer, no visual feedback" << std::endl;
}
int main(int argc, char* argv[]) {
// Parse command line arguments
uint32_t buffer_size = 512;
bool enable_logging = true;
bool enable_performance_stats = true;
bool enable_pitch_detection = false;
bool enable_visual_feedback = true;
for (int i = 1; i < argc; ++i) {
std::string arg = argv[i];
if (arg == "--help" || arg == "-h") {
print_usage();
return 0;
} else if (arg == "--no-log") {
enable_logging = false;
} else if (arg == "--no-stats") {
enable_performance_stats = false;
} else if (arg == "--pitch") {
enable_pitch_detection = true;
} else if (arg == "--no-visual") {
enable_visual_feedback = false;
} else if (arg[0] != '-') {
// Assume it's a buffer size
try {
buffer_size = std::stoul(arg);
if (buffer_size < 64 || buffer_size > 8192) {
std::cerr << " Buffer size must be between 64 and 8192" << std::endl;
return 1;
}
} catch (...) {
std::cerr << " Invalid buffer size: " << arg << std::endl;
return 1;
}
} else {
std::cerr << " Unknown option: " << arg << std::endl;
print_usage();
return 1;
}
}
// Set up signal handling
std::signal(SIGINT, EnhancedBeatDetector::signal_handler);
std::signal(SIGTERM, EnhancedBeatDetector::signal_handler);
try {
EnhancedBeatDetector detector(buffer_size, enable_logging, enable_performance_stats,
enable_pitch_detection, enable_visual_feedback);
detector.run();
} catch (const std::exception& e) {
std::cerr << " Error: " << e.what() << std::endl;
return 1;
}
return 0;
}
/*
* Compilation command:
* g++ -std=c++17 -O3 -Wall -Wextra -I/usr/include/pipewire-0.3 -I/usr/include/spa-0.2 -I/usr/include/aubio \
* -o beat_detector beat_detector.cpp -lpipewire-0.3 -laubio -pthread
*/
Reference in New Issue View Git Blame Copy Permalink