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
179
180
181
182
183
184
185
186
|
// This file is part of the 64k demo project.
// It implements the spectool for analyzing audio into spectrograms.
// Provides both 'analyze' and 'play' modes for spectral data.
#include "audio/audio.h"
#include "audio/dct.h"
#include "audio/synth.h"
#include "audio/window.h"
#include "platform.h"
#include <stdio.h>
#include <string.h>
#include "miniaudio.h"
#include <vector>
// Simple .spec file format:
// char[4] magic = "SPEC"
// int32_t version = 1
// int32_t dct_size
// int32_t num_frames
// float[num_frames * dct_size] data
struct SpecHeader {
char magic[4];
int32_t version;
int32_t dct_size;
int32_t num_frames;
};
int analyze_audio(const char *in_path, const char *out_path) {
printf("Analyzing %s -> %s\n", in_path, out_path);
ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 1, 32000);
ma_decoder decoder;
if (ma_decoder_init_file(in_path, &config, &decoder) != MA_SUCCESS) {
printf("Error: Failed to open or decode audio file: %s\n", in_path);
return 1;
}
std::vector<float> spec_data;
float pcm_chunk[DCT_SIZE];
float window[WINDOW_SIZE];
hamming_window_512(window);
ma_uint64 frames_read;
while (ma_decoder_read_pcm_frames(&decoder, pcm_chunk, DCT_SIZE,
&frames_read) == MA_SUCCESS &&
frames_read > 0) {
if (frames_read < DCT_SIZE) {
// Zero-pad the last chunk if it's smaller
memset(pcm_chunk + frames_read, 0,
(DCT_SIZE - frames_read) * sizeof(float));
}
// Apply window
for (int i = 0; i < DCT_SIZE; ++i) {
pcm_chunk[i] *= window[i];
}
// Apply FDCT
float dct_chunk[DCT_SIZE];
fdct_512(pcm_chunk, dct_chunk);
// Add to spectrogram data
spec_data.insert(spec_data.end(), dct_chunk, dct_chunk + DCT_SIZE);
}
ma_decoder_uninit(&decoder);
// Trim trailing zero frames
int last_frame = spec_data.size() / DCT_SIZE;
while (last_frame > 0) {
bool all_zeros = true;
for (int i = 0; i < DCT_SIZE; ++i) {
if (spec_data[(last_frame - 1) * DCT_SIZE + i] != 0.0f) {
all_zeros = false;
break;
}
}
if (all_zeros) {
--last_frame;
} else {
break;
}
}
spec_data.resize(last_frame * DCT_SIZE);
// Write to .spec file
FILE *f_out = fopen(out_path, "wb");
if (!f_out) {
printf("Error: Failed to open output file: %s\n", out_path);
return 1;
}
SpecHeader header;
memcpy(header.magic, "SPEC", 4);
header.version = 1;
header.dct_size = DCT_SIZE;
header.num_frames = spec_data.size() / DCT_SIZE;
fwrite(&header, sizeof(SpecHeader), 1, f_out);
fwrite(spec_data.data(), sizeof(float), spec_data.size(), f_out);
fclose(f_out);
printf("Analysis complete. Wrote %d spectral frames.\n", header.num_frames);
return 0;
}
int play_spec(const char *in_path) {
printf("Playing %s\n", in_path);
FILE *f_in = fopen(in_path, "rb");
if (!f_in) {
printf("Error: Failed to open input file: %s\n", in_path);
return 1;
}
SpecHeader header;
if (fread(&header, sizeof(SpecHeader), 1, f_in) != 1 ||
strncmp(header.magic, "SPEC", 4) != 0) {
printf("Error: Invalid spectrogram file format.\n");
fclose(f_in);
return 1;
}
std::vector<float> spec_data(header.num_frames * header.dct_size);
fread(spec_data.data(), sizeof(float), spec_data.size(), f_in);
fclose(f_in);
platform_init_window(false);
audio_init();
Spectrogram spec;
spec.spectral_data_a = spec_data.data();
spec.spectral_data_b =
spec_data.data(); // Point both to the same buffer for playback
spec.num_frames = header.num_frames;
int spec_id = synth_register_spectrogram(&spec);
synth_trigger_voice(spec_id, 0.7f, 0.0f);
printf("Playing... Press Ctrl+C to exit.\n");
while (synth_get_active_voice_count() > 0 && !platform_should_close()) {
platform_poll();
}
audio_shutdown();
platform_shutdown();
return 0;
}
void print_usage() {
printf("Usage: spectool <command> <input> [output]\n");
printf("Commands:\n");
printf(" analyze <input.wav|.mp3> <output.spec> Analyze an audio file and "
"save as a spectrogram.\n");
printf(
" play <input.spec> Play a spectrogram file.\n");
}
int main(int argc, char **argv) {
if (argc < 3) {
print_usage();
return 1;
}
const char *command = argv[1];
const char *input_path = argv[2];
if (strcmp(command, "analyze") == 0) {
if (argc < 4) {
printf("Error: 'analyze' command requires an output file.\n");
print_usage();
return 1;
}
return analyze_audio(input_path, argv[3]);
} else if (strcmp(command, "play") == 0) {
return play_spec(input_path);
} else {
printf("Error: Unknown command '%s'\n", command);
print_usage();
return 1;
}
return 0;
}
|
