?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix build on GCC 4.9
[lsnes.git] / src / core / audioapi.cpp
blobc68eeb70021571112a8cf85e22934ace59e2a067
1 #include "core/advdumper.hpp"
2 #include "core/audioapi.hpp"
3 #include "core/dispatch.hpp"
4 #include "core/framerate.hpp"
5 #include "core/instance.hpp"
6 #include "library/minmax.hpp"
7 #include "library/threads.hpp"
8
9 #include <cstring>
10 #include <cmath>
11 #include <iostream>
12 #include <unistd.h>
13 #include <sys/time.h>
14
15 #define MUSIC_BUFFERS 8
16 #define MAX_VOICE_ADJUST 200
17
18 audioapi_instance::dummy_cb_proc::dummy_cb_proc(audioapi_instance& _parent)
19 : parent(_parent)
20 {
21 }
22
23 int audioapi_instance::dummy_cb_proc::operator()()
24 {
25 int16_t buf[16384];
26 uint64_t last_ts = framerate_regulator::get_utime();
27 while(!parent.dummy_cb_quit) {
28 uint64_t cur_ts = framerate_regulator::get_utime();
29 uint64_t dt = cur_ts - last_ts;
30 last_ts = cur_ts;
31 unsigned samples = dt / 25;
32 if(samples > 16384)
33 samples = 16384; //Don't get crazy.
34 if(parent.dummy_cb_active_play)
35 parent.get_mixed(buf, samples, false);
36 if(parent.dummy_cb_active_record)
37 parent.put_voice(NULL, samples);
38 usleep(10000);
39 }
40 return 0;
41 }
42
43 namespace
44 {
45 bool paniced = false;
46
47 // | -1 1 -1 1 | 1 0 0 0 |
48 // | 0 0 0 1 | 0 1 0 0 |
49 // | 1 1 1 1 | 0 0 1 0 |
50 // | 8 4 2 1 | 0 0 0 1 |
51
52
53 // | 6 0 0 0 |-1 4 -3 1 | |-1 3 -3 1|
54 // | 0 6 0 0 | 3 -6 3 0 | 1/6 | 3 -6 3 0|
55 // | 0 0 6 0 |-2 -4 6 -1 | |-2 -3 6 -1|
56 // | 0 0 0 6 | 0 6 0 0 | | 0 6 0 0|
57
58
59
60 void cubicitr_solve(double v1, double v2, double v3, double v4, double& A, double& B, double& C, double& D)
61 {
62 A = (-v1 + 3 * v2 - 3 * v3 + v4) / 6;
63 B = (v1 - 2 * v2 + v3) / 2;
64 C = (-2 * v1 - 3 * v2 + 6 * v3 - v4) / 6;
65 D = v2;
66 }
67 }
68
69 audioapi_instance::resampler::resampler()
70 {
71 position = 0;
72 vAl = vBl = vCl = vDl = 0;
73 vAr = vBr = vCr = vDr = 0;
74 }
75
76 void audioapi_instance::resampler::resample(float*& in, size_t& insize, float*& out, size_t& outsize, double ratio,
77 bool stereo)
78 {
79 double iratio = 1 / ratio;
80 while(outsize) {
81 double newpos = position + iratio;
82 while(newpos >= 1) {
83 //Gotta load a new sample.
84 if(!insize)
85 goto exit;
86 vAl = vBl; vBl = vCl; vCl = vDl; vDl = in[0];
87 vAr = vBr; vBr = vCr; vCr = vDr; vDr = in[stereo ? 1 : 0];
88 --insize;
89 in += (stereo ? 2 : 1);
90 newpos = newpos - 1;
91 }
92 position = newpos;
93 double A, B, C, D;
94 cubicitr_solve(vAl, vBl, vCl, vDl, A, B, C, D);
95 *(out++) = ((A * position + B) * position + C) * position + D;
96 if(stereo) {
97 cubicitr_solve(vAr, vBr, vCr, vDr, A, B, C, D);
98 *(out++) = ((A * position + B) * position + C) * position + D;
99 }
100 --outsize;
101 }
102 exit:
103 ;
104 }
105
106 audioapi_instance::audioapi_instance()
107 : dummyproc(*this)
108 {
109 music_ptr = 0;
110 last_complete_music_seen = MUSIC_BUFFERS + 1;
111 last_complete_music = MUSIC_BUFFERS;
112 voicep_get = 0;
113 voicep_put = 0;
114 voicer_get = 0;
115 voicer_put = 0;
116 voice_rate_play = 40000;
117 orig_voice_rate_play = 40000;
118 voice_rate_rec = 40000;
119 dummy_cb_active_record = false;
120 dummy_cb_active_play = false;
121 dummy_cb_quit = false;
122 _music_volume = 1;
123 _voicep_volume = 32767.0;
124 _voicer_volume = 1.0/32768;
125 last_adjust = false;
126 }
127
128 audioapi_instance::~audioapi_instance()
129 {
130 quit();
131 }
132
133 std::pair<unsigned, unsigned> audioapi_instance::voice_rate()
134 {
135 return std::make_pair(voice_rate_rec, voice_rate_play);
136 }
137
138 unsigned audioapi_instance::orig_voice_rate()
139 {
140 return orig_voice_rate_play;
141 }
142
143 void audioapi_instance::voice_rate(unsigned rate_rec, unsigned rate_play)
144 {
145 if(rate_rec)
146 voice_rate_rec = rate_rec;
147 else
148 voice_rate_rec = 40000;
149 dummy_cb_active_record = !rate_rec;
150 if(rate_play)
151 orig_voice_rate_play = voice_rate_play = rate_play;
152 else
153 orig_voice_rate_play = voice_rate_play = 40000;
154 dummy_cb_active_play = !rate_play;
155 }
156
157 unsigned audioapi_instance::voice_p_status()
158 {
159 unsigned p = voicep_put;
160 unsigned g = voicep_get;
161 if(g > p)
162 return g - p - 1;
163 else
164 return voicep_bufsize - (p - g) - 1;
165 }
166
167 unsigned audioapi_instance::voice_p_status2()
168 {
169 unsigned p = voicep_put;
170 unsigned g = voicep_get;
171 if(g > p)
172 return voicep_bufsize - (g - p);
173 else
174 return (p - g);
175 }
176
177 unsigned audioapi_instance::voice_r_status()
178 {
179 unsigned p = voicer_put;
180 unsigned g = voicer_get;
181 if(g > p)
182 return voicer_bufsize - (g - p);
183 else
184 return (p - g);
185 }
186
187 void audioapi_instance::play_voice(float* samples, size_t count)
188 {
189 unsigned ptr = voicep_put;
190 for(size_t i = 0; i < count; i++) {
191 voicep_buffer[ptr++] = samples[i];
192 if(ptr == voicep_bufsize)
193 ptr = 0;
194 }
195 voicep_put = ptr;
196 }
197
198 void audioapi_instance::record_voice(float* samples, size_t count)
199 {
200 unsigned ptr = voicer_get;
201 for(size_t i = 0; i < count; i++) {
202 samples[i] = voicer_buffer[ptr++];
203 if(ptr == voicer_bufsize)
204 ptr = 0;
205 }
206 voicer_get = ptr;
207 }
208
209 void audioapi_instance::submit_buffer(int16_t* samples, size_t count, bool stereo, double rate)
210 {
211 if(stereo)
212 for(unsigned i = 0; i < count; i++)
213 CORE().mdumper->on_sample(samples[2 * i + 0], samples[2 * i + 1]);
214 else
215 for(unsigned i = 0; i < count; i++)
216 CORE().mdumper->on_sample(samples[i], samples[i]);
217 //Limit buffers to avoid overrunning.
218 if(count > music_bufsize / (stereo ? 2 : 1))
219 count = music_bufsize / (stereo ? 2 : 1);
220 unsigned bidx = last_complete_music;
221 bidx = (bidx > (MUSIC_BUFFERS - 2)) ? 0 : bidx + 1;
222 memcpy(music_buffer + bidx * music_bufsize, samples, count * (stereo ? 2 : 1) * sizeof(int16_t));
223 music_stereo[bidx] = stereo;
224 music_rate[bidx] = rate;
225 music_size[bidx] = count;
226 last_complete_music = bidx;
227 }
228
229 struct audioapi_instance::buffer audioapi_instance::get_music(size_t played)
230 {
231 unsigned midx = last_complete_music_seen;
232 unsigned midx2 = last_complete_music;
233 if(midx2 >= MUSIC_BUFFERS) {
234 //Special case: No buffer.
235 struct buffer out;
236 out.samples = NULL;
237 out.pointer = 0;
238 //The rest are arbitrary.
239 out.total = 64;
240 out.stereo = false;
241 out.rate = 48000;
242 return out;
243 }
244 //Handle ACK. If the current buffer is too old, we want to ignore the ACK.
245 if(midx >= MUSIC_BUFFERS) {
246 //Load initial buffer.
247 midx = last_complete_music_seen = 0;
248 music_ptr = 0;
249 } else {
250 music_ptr += played;
251 //Otherwise, check if current buffer is not next on the line to be overwritten.
252 if((midx2 + 1) % MUSIC_BUFFERS == midx) {
253 //It is, bump buffer by one.
254 if(!last_adjust && voice_rate_play > orig_voice_rate_play - MAX_VOICE_ADJUST)
255 voice_rate_play--;
256 last_adjust = true;
257 midx = last_complete_music_seen = (midx + 1) % MUSIC_BUFFERS;
258 music_ptr = 0;
259 } else if(music_ptr >= music_size[midx] && midx != midx2) {
260 //It isn't, but current buffer is finished.
261 midx = last_complete_music_seen = (midx + 1) % MUSIC_BUFFERS;
262 music_ptr = 0;
263 last_adjust = false;
264 } else if(music_ptr >= music_size[midx] && midx == midx2) {
265 if(!last_adjust && voice_rate_play < orig_voice_rate_play + MAX_VOICE_ADJUST)
266 voice_rate_play++;
267 last_adjust = true;
268 //Current buffer is finished, but there is no new buffer.
269 //Send silence.
270 } else {
271 last_adjust = false;
272 //Can continue.
273 }
274 }
275 //Fill the structure.
276 struct buffer out;
277 if(music_ptr < music_size[midx]) {
278 out.samples = music_buffer + midx * music_bufsize;
279 out.pointer = music_ptr;
280 out.total = music_size[midx];
281 out.stereo = music_stereo[midx];
282 out.rate = music_rate[midx];
283 } else {
284 //Run out of buffers to play.
285 out.samples = NULL;
286 out.pointer = 0;
287 out.total = 64; //Arbitrary.
288 out.stereo = music_stereo[midx];
289 out.rate = music_rate[midx];
290 if(out.rate < 100)
291 out.rate = 48000; //Apparently there are buffers with zero rate.
292 }
293 return out;
294 }
295
296 void audioapi_instance::get_voice(float* samples, size_t count)
297 {
298 unsigned g = voicep_get;
299 unsigned p = voicep_put;
300 if(samples) {
301 for(size_t i = 0; i < count; i++) {
302 if(g != p)
303 samples[i] = _voicep_volume * voicep_buffer[g++];
304 else
305 samples[i] = 0.0;
306 if(g == voicep_bufsize)
307 g = 0;
308 }
309 } else {
310 for(size_t i = 0; i < count; i++) {
311 if(g != p)
312 g++;
313 if(g == voicep_bufsize)
314 g = 0;
315 }
316 }
317 voicep_get = g;
318 }
319
320 void audioapi_instance::put_voice(float* samples, size_t count)
321 {
322 unsigned ptr = voicer_put;
323 vu_vin(samples, count, false, voice_rate_rec, _voicer_volume);
324 for(size_t i = 0; i < count; i++) {
325 voicer_buffer[ptr++] = samples ? _voicer_volume * samples[i] : 0.0;
326 if(ptr == voicer_bufsize)
327 ptr = 0;
328 }
329 voicer_put = ptr;
330 }
331
332 void audioapi_instance::init()
333 {
334 voicep_get = 0;
335 voicep_put = 0;
336 voicer_get = 0;
337 voicer_put = 0;
338 last_complete_music = 3;
339 last_complete_music_seen = 4;
340 dummy_cb_active_play = true;
341 dummy_cb_active_record = true;
342 dummy_cb_quit = false;
343 dummythread = new threads::thread(dummyproc);
344 }
345
346 void audioapi_instance::quit()
347 {
348 dummy_cb_quit = true;
349 if(dummythread) {
350 dummythread->join();
351 dummythread = NULL;
352 }
353 }
354
355 void audioapi_instance::music_volume(float volume)
356 {
357 _music_volume = volume;
358 }
359
360 float audioapi_instance::music_volume()
361 {
362 return _music_volume;
363 }
364
365 void audioapi_instance::voicep_volume(float volume)
366 {
367 _voicep_volume = volume * 32767;
368 }
369
370 float audioapi_instance::voicep_volume()
371 {
372 return _voicep_volume / 32767;
373 }
374
375 void audioapi_instance::voicer_volume(float volume)
376 {
377 _voicer_volume = volume / 32768;
378 }
379
380 float audioapi_instance::voicer_volume()
381 {
382 return _voicer_volume * 32768;
383 }
384
385 void audioapi_instance::get_mixed(int16_t* samples, size_t count, bool stereo)
386 {
387 const size_t intbuf_size = 256;
388 float intbuf[intbuf_size];
389 float intbuf2[intbuf_size];
390 while(count > 0) {
391 buffer b = get_music(0);
392 float* in = intbuf;
393 float* out = intbuf2;
394 size_t outdata_used;
395 if(b.stereo) {
396 size_t indata = min(b.total - b.pointer, intbuf_size / 2);
397 size_t outdata = min(intbuf_size / 2, count);
398 size_t indata_used = indata;
399 outdata_used = outdata;
400 if(b.samples)
401 for(size_t i = 0; i < 2 * indata; i++)
402 intbuf[i] = _music_volume * b.samples[i + 2 * b.pointer];
403 else
404 for(size_t i = 0; i < 2 * indata; i++)
405 intbuf[i] = 0;
406 music_resampler.resample(in, indata, out, outdata, (double)voice_rate_play / b.rate, true);
407 indata_used -= indata;
408 outdata_used -= outdata;
409 get_music(indata_used);
410 get_voice(intbuf, outdata_used);
411
412 vu_mleft(intbuf2, outdata_used, true, voice_rate_play, 1 / 32768.0);
413 vu_mright(intbuf2 + 1, outdata_used, true, voice_rate_play, 1 / 32768.0);
414 vu_vout(intbuf, outdata_used, false, voice_rate_play, 1 / 32768.0);
415
416 for(size_t i = 0; i < outdata_used * (stereo ? 2 : 1); i++)
417 intbuf2[i] = max(min(intbuf2[i] + intbuf[i / 2], 32766.0f), -32767.0f);
418 if(stereo)
419 for(size_t i = 0; i < outdata_used * 2; i++)
420 samples[i] = intbuf2[i];
421 else
422 for(size_t i = 0; i < outdata_used; i++)
423 samples[i] = (intbuf2[2 * i + 0] + intbuf2[2 * i + 1]) / 2;
424 } else {
425 size_t indata = min(b.total - b.pointer, intbuf_size);
426 size_t outdata = min(intbuf_size, count);
427 size_t indata_used = indata;
428 outdata_used = outdata;
429 if(b.samples)
430 for(size_t i = 0; i < indata; i++)
431 intbuf[i] = _music_volume * b.samples[i + b.pointer];
432 else
433 for(size_t i = 0; i < indata; i++)
434 intbuf[i] = 0;
435 music_resampler.resample(in, indata, out, outdata, (double)voice_rate_play / b.rate, false);
436 indata_used -= indata;
437 outdata_used -= outdata;
438 get_music(indata_used);
439 get_voice(intbuf, outdata_used);
440
441 vu_mleft(intbuf2, outdata_used, false, voice_rate_play, 1 / 32768.0);
442 vu_mright(intbuf2, outdata_used, false, voice_rate_play, 1 / 32768.0);
443 vu_vout(intbuf, outdata_used, false, voice_rate_play, 1 / 32768.0);
444
445 for(size_t i = 0; i < outdata_used; i++)
446 intbuf2[i] = max(min(intbuf2[i] + intbuf[i], 32766.0f), -32767.0f);
447 if(stereo)
448 for(size_t i = 0; i < outdata_used; i++) {
449 samples[2 * i + 0] = intbuf2[i];
450 samples[2 * i + 1] = intbuf2[i];
451 }
452 else
453 for(size_t i = 0; i < outdata_used; i++)
454 samples[i] = intbuf2[i];
455 }
456 samples += (stereo ? 2 : 1) * outdata_used;
457 count -= outdata_used;
458 }
459 }
460
461 audioapi_instance::vumeter::vumeter()
462 {
463 accumulator = 0;
464 samples = 0;
465 vu = -999.0;
466 }
467
468 void audioapi_instance::vumeter::operator()(float* asamples, size_t count, bool stereo, double rate, double scale)
469 {
470 size_t limit = rate / 25;
471 //If we already at or exceed limit, cut immediately.
472 if(samples >= limit)
473 update_vu();
474 if(asamples) {
475 double sscale = scale * scale;
476 size_t j = 0;
477 if(stereo)
478 for(size_t i = 0; i < count; i++) {
479 accumulator += sscale * asamples[j] * asamples[j];
480 j += 2;
481 samples++;
482 if(samples >= limit)
483 update_vu();
484 }
485 else
486 for(size_t i = 0; i < count; i++) {
487 accumulator += sscale * asamples[i] * asamples[i];
488 samples++;
489 if(samples >= limit)
490 update_vu();
491 }
492 } else
493 for(size_t i = 0; i < count; i++) {
494 samples++;
495 if(samples >= limit)
496 update_vu();
497 }
498 }
499
500 void audioapi_instance::vumeter::update_vu()
501 {
502 if(paniced)
503 return;
504 if(!samples) {
505 vu = -999.0;
506 accumulator = 0;
507 } else {
508 double a = accumulator;
509 if(a < 1e-120)
510 a = 1e-120; //Don't take log of zero.
511 vu = 10 / log(10) * (log(a) - log(samples));
512 if(vu < -999.0)
513 vu = -999.0;
514 accumulator = 0;
515 samples = 0;
516 }
517 CORE().dispatch->vu_change();
518 }
519
520 void audioapi_panicing() throw()
521 {
522 paniced = true;
523 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core