blob: 7c0f490cd94255acdd8028e3fdd372db6a893326 (
plain)
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
|
// This file is part of the 64k demo project.
// It manages the low-level audio device and high-level audio state.
// Now uses backend abstraction for testability.
#include "audio.h"
#include "audio_backend.h"
#include "miniaudio_backend.h"
#include "ring_buffer.h"
#include "synth.h"
#include "util/asset_manager.h"
#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"
#include <stdio.h>
// Global ring buffer for audio streaming
static AudioRingBuffer g_ring_buffer;
// Global backend pointer for audio abstraction
static AudioBackend* g_audio_backend = nullptr;
static MiniaudioBackend g_default_backend;
static bool g_using_default_backend = false;
#if !defined(STRIP_ALL)
// Allow tests to inject a custom backend
void audio_set_backend(AudioBackend* backend) {
g_audio_backend = backend;
}
// Get current backend (for tests)
AudioBackend* audio_get_backend() {
return g_audio_backend;
}
#endif /* !defined(STRIP_ALL) */
int register_spec_asset(AssetId id) {
size_t size;
const uint8_t* data = GetAsset(id, &size);
if (!data || size < sizeof(SpecHeader))
return -1;
const SpecHeader* header = (const SpecHeader*)data;
const float* spectral_data = (const float*)(data + sizeof(SpecHeader));
Spectrogram spec;
spec.spectral_data_a = spectral_data;
spec.spectral_data_b = spectral_data; // No double-buffer for static assets
spec.num_frames = header->num_frames;
return synth_register_spectrogram(&spec);
}
void audio_init() {
synth_init();
// Use default backend if none set
if (g_audio_backend == nullptr) {
g_audio_backend = &g_default_backend;
g_using_default_backend = true;
}
g_audio_backend->init();
}
void audio_start() {
if (g_audio_backend == nullptr) {
printf("Cannot start: audio not initialized.\n");
return;
}
g_audio_backend->start();
}
void audio_render_ahead(float music_time, float dt) {
// Calculate how much audio is currently buffered
const int buffered_samples = g_ring_buffer.available_read();
const float buffered_time =
(float)buffered_samples / (RING_BUFFER_SAMPLE_RATE * RING_BUFFER_CHANNELS);
// Target: maintain look-ahead buffer
const float target_lookahead =
(float)RING_BUFFER_LOOKAHEAD_MS / 1000.0f;
// Only render if we're below target
if (buffered_time < target_lookahead * 0.5f) { // Refill when half empty
// Calculate how many frames to render
const float time_to_render = target_lookahead - buffered_time;
const int frames_to_render =
(int)(time_to_render * RING_BUFFER_SAMPLE_RATE);
if (frames_to_render > 0) {
// Allocate temporary buffer (stereo)
const int samples_to_render = frames_to_render * RING_BUFFER_CHANNELS;
float* temp_buffer = new float[samples_to_render];
// Render audio from synth
synth_render(temp_buffer, frames_to_render);
// Write to ring buffer
const int written = g_ring_buffer.write(temp_buffer, samples_to_render);
// Notify backend of frames rendered (for testing/tracking)
if (g_audio_backend != nullptr) {
g_audio_backend->on_frames_rendered(written / RING_BUFFER_CHANNELS);
}
delete[] temp_buffer;
}
}
}
float audio_get_playback_time() {
const int64_t total_samples = g_ring_buffer.get_total_read();
return (float)total_samples /
(RING_BUFFER_SAMPLE_RATE * RING_BUFFER_CHANNELS);
}
// Expose ring buffer for backends
AudioRingBuffer* audio_get_ring_buffer() {
return &g_ring_buffer;
}
#if !defined(STRIP_ALL)
void audio_render_silent(float duration_sec) {
const int sample_rate = 32000;
const int chunk_size = 512;
int total_frames = (int)(duration_sec * sample_rate);
float buffer[chunk_size * 2]; // Stereo
while (total_frames > 0) {
int frames_to_render =
(total_frames > chunk_size) ? chunk_size : total_frames;
synth_render(buffer, frames_to_render);
total_frames -= frames_to_render;
// Notify backend of frames rendered (for mock tracking)
if (g_audio_backend != nullptr) {
g_audio_backend->on_frames_rendered(frames_to_render);
}
}
}
#endif /* !defined(STRIP_ALL) */
void audio_update() {
}
void audio_shutdown() {
if (g_audio_backend != nullptr) {
g_audio_backend->shutdown();
}
synth_shutdown();
// Clear backend pointer if using default
if (g_using_default_backend) {
g_audio_backend = nullptr;
g_using_default_backend = false;
}
}
|
