waybar/src/modules/jack.cpp

116 lines
3.3 KiB
C++
Raw Normal View History

#include "modules/jack.hpp"
2022-07-20 04:30:42 +02:00
namespace waybar::modules {
JACK::JACK(const std::string &id, const Json::Value &config)
: ALabel(config, "jack", id, "{load}%", 1) {
2022-07-20 03:49:56 +02:00
xruns_ = 0;
state_ = "disconnected";
client_ = NULL;
2022-07-20 03:49:56 +02:00
state_ = JACKState();
thread_ = [this] {
dp.emit();
thread_.sleep_for(interval_);
};
}
2022-07-20 04:30:42 +02:00
std::string JACK::JACKState() {
2022-07-20 03:49:56 +02:00
if (state_.compare("xrun") == 0) return "xrun";
if (state_.compare("connected") == 0) return "connected";
client_ = jack_client_open("waybar", JackNoStartServer, NULL);
if (client_) {
pthread_t jack_thread = jack_client_thread_id(client_);
2022-07-20 03:49:56 +02:00
if (config_["realtime"].isBool() && !config_["realtime"].asBool())
jack_drop_real_time_scheduling(jack_thread);
2022-02-12 07:51:11 +01:00
bufsize_ = jack_get_buffer_size(client_);
samplerate_ = jack_get_sample_rate(client_);
jack_set_buffer_size_callback(client_, bufSizeCallback, this);
jack_set_xrun_callback(client_, xrunCallback, this);
jack_on_shutdown(client_, shutdownCallback, this);
2022-07-20 03:49:56 +02:00
if (!jack_activate(client_)) return "connected";
}
return "disconnected";
}
2022-07-20 04:30:42 +02:00
auto JACK::update() -> void {
std::string format;
float latency = 1000 * (float)bufsize_ / (float)samplerate_;
auto state = JACKState();
float load;
2022-07-20 03:49:56 +02:00
if (label_.get_style_context()->has_class("xrun")) {
label_.get_style_context()->remove_class("xrun");
state = "connected";
}
2022-07-20 03:49:56 +02:00
if (state.compare("disconnected") != 0)
load = jack_cpu_load(client_);
else {
load = 0;
bufsize_ = 0;
samplerate_ = 0;
latency = 0;
}
2022-07-20 03:49:56 +02:00
if (label_.get_style_context()->has_class(state_))
label_.get_style_context()->remove_class(state_);
if (config_["format-" + state].isString()) {
format = config_["format-" + state].asString();
} else if (config_["format"].isString()) {
format = config_["format"].asString();
2022-07-20 03:49:56 +02:00
} else
format = "DSP {load}%";
2022-07-20 03:53:32 +02:00
if (!label_.get_style_context()->has_class(state)) label_.get_style_context()->add_class(state);
state_ = state;
label_.set_markup(fmt::format(format, fmt::arg("load", std::round(load)),
2022-07-20 03:49:56 +02:00
fmt::arg("bufsize", bufsize_), fmt::arg("samplerate", samplerate_),
fmt::arg("latency", fmt::format("{:.2f}", latency)),
fmt::arg("xruns", xruns_)));
if (tooltipEnabled()) {
std::string tooltip_format = "{bufsize}/{samplerate} {latency}ms";
2022-07-20 03:49:56 +02:00
if (config_["tooltip-format"].isString()) tooltip_format = config_["tooltip-format"].asString();
2022-07-20 03:53:32 +02:00
label_.set_tooltip_text(fmt::format(
tooltip_format, fmt::arg("load", std::round(load)), fmt::arg("bufsize", bufsize_),
fmt::arg("samplerate", samplerate_), fmt::arg("latency", fmt::format("{:.2f}", latency)),
fmt::arg("xruns", xruns_)));
}
// Call parent update
ALabel::update();
}
2022-02-12 07:52:51 +01:00
2022-07-20 04:30:42 +02:00
int JACK::bufSize(unsigned int size) {
2022-02-18 08:13:43 +01:00
bufsize_ = size;
2022-02-12 07:52:51 +01:00
return size;
}
2022-07-20 04:30:42 +02:00
int JACK::xrun() {
2022-02-18 08:13:43 +01:00
xruns_ += 1;
state_ = "xrun";
2022-02-12 07:52:51 +01:00
return 0;
}
2022-07-20 04:30:42 +02:00
void JACK::shutdown() {
2022-02-18 08:13:43 +01:00
client_ = NULL;
state_ = "disconnected";
xruns_ = 0;
}
2022-07-20 04:30:42 +02:00
} // namespace waybar::modules
2022-02-18 08:13:43 +01:00
int bufSizeCallback(unsigned int size, void *obj) {
2022-07-20 03:49:56 +02:00
return static_cast<waybar::modules::JACK *>(obj)->bufSize(size);
2022-02-18 08:13:43 +01:00
}
2022-07-20 03:49:56 +02:00
int xrunCallback(void *obj) { return static_cast<waybar::modules::JACK *>(obj)->xrun(); }
2022-02-18 08:13:43 +01:00
2022-07-20 03:49:56 +02:00
void shutdownCallback(void *obj) { return static_cast<waybar::modules::JACK *>(obj)->shutdown(); }