]> git.sesse.net Git - nageru/blob - nageru/benchmark_audio_mixer.cpp
Remove the QCustomPlot dependency.
[nageru] / nageru / benchmark_audio_mixer.cpp
1 // Rather simplistic benchmark of AudioMixer. Sets up a simple mapping
2 // with the default settings, feeds some white noise to the inputs and
3 // runs a while. Useful for e.g. profiling.
4
5 #include <assert.h>
6 #include <bmusb/bmusb.h>
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <algorithm>
10 #include <chrono>
11 #include <cmath>
12 #include <ratio>
13 #include <vector>
14
15 #include "audio_mixer.h"
16 #include "decibel.h"
17 #include "defs.h"
18 #include "input_mapping.h"
19 #include "resampling_queue.h"
20 #include "shared/timebase.h"
21
22 #define NUM_BENCHMARK_CARDS 4
23 #define NUM_WARMUP_FRAMES 100
24 #define NUM_BENCHMARK_FRAMES 1000
25 #define NUM_TEST_FRAMES 10
26 #define NUM_CHANNELS 8
27 #define NUM_SAMPLES 1024
28
29 using namespace std;
30 using namespace std::chrono;
31
32 // 16-bit samples, white noise at full volume.
33 uint8_t samples16[(NUM_SAMPLES * NUM_CHANNELS + 1024) * sizeof(uint16_t)];
34
35 // 24-bit samples, white noise at low volume (-48 dB).
36 uint8_t samples24[(NUM_SAMPLES * NUM_CHANNELS + 1024) * 3];
37
38 static uint32_t seed = 1234;
39
40 // We use our own instead of rand() to get deterministic behavior.
41 // Quality doesn't really matter much.
42 uint32_t lcgrand()
43 {
44         seed = seed * 1103515245u + 12345u;
45         return seed;
46 }
47
48 void reset_lcgrand()
49 {
50         seed = 1234;
51 }
52
53 void callback(float level_lufs, float peak_db,
54               std::vector<AudioMixer::BusLevel> bus_levels,
55               float global_level_lufs, float range_low_lufs, float range_high_lufs,
56               float final_makeup_gain_db,
57               float correlation)
58 {
59         // Empty.
60 }
61
62 vector<float> process_frame(unsigned frame_num, AudioMixer *mixer)
63 {
64         duration<int64_t, ratio<NUM_SAMPLES, OUTPUT_FREQUENCY>> frame_duration(frame_num);
65         steady_clock::time_point ts = steady_clock::time_point(duration_cast<steady_clock::duration>(frame_duration));
66
67         // Feed the inputs.
68         for (unsigned card_index = 0; card_index < NUM_BENCHMARK_CARDS; ++card_index) {
69                 bmusb::AudioFormat audio_format;
70                 audio_format.bits_per_sample = card_index == 3 ? 24 : 16;
71                 audio_format.num_channels = NUM_CHANNELS;
72                 
73                 unsigned num_samples = NUM_SAMPLES + (lcgrand() % 9) - 5;
74                 bool ok = mixer->add_audio(DeviceSpec{InputSourceType::CAPTURE_CARD, card_index},
75                         card_index == 3 ? samples24 : samples16, num_samples, audio_format,
76                         ts);
77                 assert(ok);
78         }
79
80         return mixer->get_output(ts, NUM_SAMPLES, ResamplingQueue::ADJUST_RATE);
81 }
82
83 void init_mapping(AudioMixer *mixer)
84 {
85         InputMapping mapping;
86
87         InputMapping::Bus bus1;
88         bus1.device = DeviceSpec{InputSourceType::CAPTURE_CARD, 0};
89         bus1.source_channel[0] = 0;
90         bus1.source_channel[1] = 1;
91         mapping.buses.push_back(bus1);
92
93         InputMapping::Bus bus2;
94         bus2.device = DeviceSpec{InputSourceType::CAPTURE_CARD, 3};
95         bus2.source_channel[0] = 6;
96         bus2.source_channel[1] = 4;
97         mapping.buses.push_back(bus2);
98
99         mixer->set_input_mapping(mapping);
100 }
101
102 void do_test(const char *filename)
103 {
104         AudioMixer mixer;
105         mixer.set_audio_level_callback(callback);
106         init_mapping(&mixer);
107
108         reset_lcgrand();
109
110         vector<float> output;
111         for (unsigned i = 0; i < NUM_TEST_FRAMES; ++i) {
112                 vector<float> frame_output = process_frame(i, &mixer);
113                 output.insert(output.end(), frame_output.begin(), frame_output.end());
114         }
115
116         FILE *fp = fopen(filename, "rb");
117         if (fp == nullptr) {
118                 fprintf(stderr, "%s not found, writing new reference.\n", filename);
119                 fp = fopen(filename, "wb");
120                 fwrite(&output[0], output.size() * sizeof(float), 1, fp);
121                 fclose(fp);
122                 return;
123         }
124
125         vector<float> ref;
126         ref.resize(output.size());
127         fread(&ref[0], output.size() * sizeof(float), 1, fp);
128         fclose(fp);
129
130         float max_err = 0.0f, sum_sq_err = 0.0f;
131         for (unsigned i = 0; i < output.size(); ++i) {
132                 float err = output[i] - ref[i];
133                 max_err = max(max_err, fabs(err));
134                 sum_sq_err += err * err;
135         }
136
137         printf("Largest error: %.6f (%+.1f dB)\n", max_err, to_db(max_err));
138         printf("RMS error:     %+.1f dB\n", to_db(sqrt(sum_sq_err) / output.size()));
139 }
140
141 void do_benchmark()
142 {
143         AudioMixer mixer;
144         mixer.set_audio_level_callback(callback);
145         init_mapping(&mixer);
146
147         size_t out_samples = 0;
148
149         reset_lcgrand();
150
151         steady_clock::time_point start, end;
152         for (unsigned i = 0; i < NUM_WARMUP_FRAMES + NUM_BENCHMARK_FRAMES; ++i) {
153                 if (i == NUM_WARMUP_FRAMES) {
154                         start = steady_clock::now();
155                 }
156                 vector<float> output = process_frame(i, &mixer);
157                 if (i >= NUM_WARMUP_FRAMES) {
158                         out_samples += output.size();
159                 }
160         }
161         end = steady_clock::now();
162
163         double elapsed = duration<double>(end - start).count();
164         double simulated = double(out_samples) / (OUTPUT_FREQUENCY * 2);
165         printf("%zu samples produced in %.1f ms (%.1f%% CPU, %.1fx realtime).\n",
166                 out_samples, elapsed * 1e3, 100.0 * elapsed / simulated, simulated / elapsed);
167 }
168
169 int main(int argc, char **argv)
170 {
171         for (unsigned i = 0; i < NUM_SAMPLES * NUM_CHANNELS + 1024; ++i) {
172                 samples16[i * 2] = lcgrand() & 0xff;
173                 samples16[i * 2 + 1] = lcgrand() & 0xff;
174
175                 samples24[i * 3] = lcgrand() & 0xff;
176                 samples24[i * 3 + 1] = lcgrand() & 0xff;
177                 samples24[i * 3 + 2] = 0;
178         }
179
180         if (argc == 2) {
181                 do_test(argv[1]);
182         }
183         do_benchmark();
184 }
185