1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <time.h>
#include <sys/types.h>
#define BREATHING_INTERVAL 90 // in milliseconds
#define STRESS_THRESHOLD 8.0 // System load threshold for stress mode
#define SHM_NAME "/breathing_color_shm" // Shared memory name
#define SOUND_FILE_STRESS "/usr/local/share/sounds/AresEnraged.wav" // Sound for stress mode
#define SOUND_FILE_NORMAL "/usr/local/share/sounds/ThanatosVent.wav" // Sound for normal mode
#define DEFAULT_COLORS 3
#define STRESS_COLORS 4
const double default_colors[DEFAULT_COLORS][3] = {
{1.0, 0.91, 0.4}, //Y
{0.95, 0.44, 0.28}, //O
{0.24, 0.85, 0.38} //G
};
const double stress_colors[STRESS_COLORS][3] = {
{0.96, 0.0, 0.0}, //Bright
{0.55, 0.0, 0.0}, //Dark
{0.64, 0.0, 0.0}, //Muted
{0.35, 0.0, 0.0}, //Deep
};
// Convert Linear RGB to sRGB
double linear_to_srgb(double value) {
if (value <= 0.0031308)
return value * 12.92;
else
return 1.055 * pow(value, 1.0 / 2.4) - 0.055;
}
// Function to interpolate between two colors in linear RGB space
void interpolate_color(const double *color1, const double *color2, double t, char *output) {
unsigned int r1, g1, b1, r2, g2, b2;
double lr1, lg1, lb1, lr2, lg2, lb2, lr, lg, lb;
lr1 = color1[0];
lg1 = color1[1];
lb1 = color1[2];
lr2 = color2[0];
lg2 = color2[1];
lb2 = color2[2];
// Interpolate in linear RGB space
lr = lr1 + t * (lr2 - lr1);
lg = lg1 + t * (lg2 - lg1);
lb = lb1 + t * (lb2 - lb1);
// Convert back to sRGB
r1 = round(linear_to_srgb(lr) * 255);
g1 = round(linear_to_srgb(lg) * 255);
b1 = round(linear_to_srgb(lb) * 255);
// Output the interpolated color as hex
snprintf(output, 8, "#%02x%02x%02x", r1, g1, b1);
}
// Function to read system load
double get_system_load() {
double load;
FILE *f = fopen("/proc/loadavg", "r");
if (f) {
fscanf(f, "%lf", &load);
fclose(f);
} else {
perror("Failed to read /proc/loadavg");
load = 0.0;
}
return load;
}
// Function to play the sound (non-blocking)
void play_sound_background(const char *sound_file) {
if (fork() == 0) { // Child process
// Use paplay or any other sound player to play the sound
char command[100];
snprintf(command, sizeof(command), "paplay %s", sound_file);
system(command);
// If execlp fails, exit the child process
perror("execlp failed");
exit(1);
}
}
// Function to update breathing color
void update_breathing_color(char *shm_ptr, double *last_load, int *in_stress_mode) {
static int color_index = 0;
static double t = 0.0;
char new_color[8];
double current_load = get_system_load();
int new_stress_mode = current_load > STRESS_THRESHOLD;
// Trigger sound on load crossing (up or down)
if (new_stress_mode != *in_stress_mode) {
if (new_stress_mode) {
play_sound_background(SOUND_FILE_STRESS); // Play stress sound
} else {
play_sound_background(SOUND_FILE_NORMAL); // Play normal sound
}
*in_stress_mode = new_stress_mode;
}
// Determine the current color set (default or stress)
const double (*current_colors)[3];
int num_colors;
if (new_stress_mode) {
current_colors = stress_colors;
num_colors = STRESS_COLORS;
} else {
current_colors = default_colors;
num_colors = DEFAULT_COLORS;
}
// Interpolate between the current and next color in the palette
interpolate_color(
current_colors[color_index],
current_colors[(color_index + 1) % num_colors],
t,
new_color
);
// Store the new color to shared memory (for example purposes)
snprintf(shm_ptr, 8, "%s", new_color);
// Update interpolation factor and color index
t += 0.02; // Adjust speed of interpolation here
if (t >= 1.0) {
t = 0.0;
color_index = (color_index + 1) % num_colors;
}
}
int main() {
struct timespec last_breathing_update = {0}, now;
double last_load = 0.0;
int in_stress_mode = 0;
char *shm_ptr;
// Initialize shared memory for color
int shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
ftruncate(shm_fd, 8); // Set size of shared memory
shm_ptr = mmap(NULL, 8, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
// Initialize breathing colors
clock_gettime(CLOCK_MONOTONIC, &last_breathing_update);
while (1) {
clock_gettime(CLOCK_MONOTONIC, &now);
// Update breathing colors
double elapsed_breathing = (now.tv_sec - last_breathing_update.tv_sec) * 1000.0 +
(now.tv_nsec - last_breathing_update.tv_nsec) / 1.0e6;
if (elapsed_breathing >= BREATHING_INTERVAL) {
update_breathing_color(shm_ptr, &last_load, &in_stress_mode);
last_breathing_update = now;
}
usleep(100000); // Sleep for 0.1 seconds to reduce CPU usage
}
// Clean up shared memory
munmap(shm_ptr, 8);
shm_unlink(SHM_NAME);
return 0;
}
|
