prosperon/source/engine/sound.c

385 lines
8.5 KiB
C
Raw Normal View History

2022-01-19 16:43:21 -06:00
#include "sound.h"
2022-02-06 10:14:57 -06:00
#include "resources.h"
2022-06-28 18:51:21 -05:00
#include <stdlib.h>
2022-06-30 10:31:23 -05:00
#include "log.h"
2022-07-03 00:43:42 -05:00
#include "string.h"
2022-07-04 12:47:21 -05:00
#include "math.h"
#include "limits.h"
#include "time.h"
2022-06-23 02:34:51 -05:00
2022-07-05 15:12:48 -05:00
#include "SDL2/SDL.h"
2022-07-04 14:19:52 -05:00
#include "dsp.h"
2022-07-05 15:12:48 -05:00
#define TSF_IMPLEMENTATION
#include "tsf.h"
2022-07-03 00:43:42 -05:00
#define DR_WAV_IMPLEMENTATION
#include "dr_wav.h"
#define DR_MP3_IMPLEMENTATION
#include "dr_mp3.h"
#include "portaudio.h"
2022-07-03 11:28:44 -05:00
#include "circbuf.h"
2022-06-23 02:34:51 -05:00
2022-01-19 16:43:21 -06:00
const char *audioDriver;
2022-06-23 02:34:51 -05:00
struct sound *mus_cur;
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
#define BUSFRAMES 15000
2022-07-03 00:43:42 -05:00
2022-07-03 11:28:44 -05:00
struct circbuf vidbuf;
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
drmp3 mp3;
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
struct wav mwav;
struct sound wavsound;
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
int vidplaying = 0;
2022-07-03 11:28:44 -05:00
2022-07-05 15:12:48 -05:00
struct wav change_samplerate(struct wav w, int rate)
{
SDL_AudioCVT cvt;
printf("Convert from %i to %i.\n", w.samplerate, rate);
SDL_BuildAudioCVT(&cvt, AUDIO_S16, w.ch, w.samplerate, AUDIO_S16, w.ch, rate);
cvt.len = w.frames * w.ch * sizeof(short);
cvt.buf = malloc(cvt.len * cvt.len_mult);
memcpy(cvt.buf, w.data, cvt.len*cvt.len_mult);
SDL_ConvertAudio(&cvt);
w.samplerate = rate;
free(w.data);
w.data = cvt.buf;
printf("cvt len: %i\n", cvt.len_cvt);
w.frames = cvt.len_cvt / (w.ch * sizeof(short));
/*
float change = (float)rate/w.samplerate;
int oldsamples = w.frames * w.ch;
w.samplerate = rate;
w.frames *= change;
short *old = (short*)w.data;
short *new = calloc(w.frames * w.ch, sizeof(short));
int samples = w.frames*w.ch;
short s1;
short s2;
for (int i = 0; i < w.frames; i++) {
for (int j = 0; j < w.ch; j++) {
int v1 = ((float)(i*w.ch+j)/samples) * oldsamples;
int v2 = ((float)(i*w.ch+j+w.ch)/samples) * oldsamples;
printf("Val is %i and %i.\n", v1, v2);
s1 = old[v1];
s2 = old[v2];
new[i*w.ch+j] = (s1 + s2) >> 1; // Average of the two with bitshift ops
}
}
printf("Old samples: %i\nNew samples: %i\nFrames:%i\n", oldsamples, samples, w.frames);
w.data = new;
free(old);
*/
}
2022-07-03 00:43:42 -05:00
static int patestCallback(const void *inputBuffer, void *outputBuffer, unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
/* Cast data passed through stream to our structure. */
2022-07-03 11:28:44 -05:00
short *out = (short*)outputBuffer;
2022-07-04 12:47:21 -05:00
2022-07-03 19:24:53 -05:00
/*
2022-07-03 00:43:42 -05:00
int f = 0;
2022-07-03 11:28:44 -05:00
static int interp = 0;
2022-07-03 00:43:42 -05:00
for (int i = 0; i < framesPerBuffer; i++) {
2022-07-03 19:24:53 -05:00
*(out++) = *(short*)(mwav.data++);
*(out++) = *(short*)(mwav.data++);
}
*/
2022-07-04 12:47:21 -05:00
2022-07-03 19:24:53 -05:00
if (wavsound.play) {
2022-07-04 12:47:21 -05:00
//clock_t start = clock();
//wavsound.data->gain = -6;
float mult = powf(10.f, (float)wavsound.data->gain/20.f);
short *s = (short*)wavsound.data->data;
2022-07-03 19:24:53 -05:00
for (int i = 0; i < framesPerBuffer; i++) {
2022-07-04 12:47:21 -05:00
out[i*2] = s[wavsound.frame++] * mult;
if (wavsound.frame == wavsound.data->frames) wavsound.frame = 0;
out[i*2+1] = s[wavsound.frame++] * mult;
if (wavsound.frame == wavsound.data->frames) wavsound.frame = 0;
2022-07-03 19:24:53 -05:00
}
2022-07-04 12:47:21 -05:00
/*
static int end = 0;
end = wavsound.data->frames - wavsound.frame;
if (end >= framesPerBuffer) {
memcpy(out, &s[wavsound.frame*2], framesPerBuffer * 2 * sizeof(short));
wavsound.frame += framesPerBuffer;
} else {
memcpy(out, &s[wavsound.frame*2], end * 2 * sizeof(short));
wavsound.frame = framesPerBuffer - end;
memcpy(out+(end*2), s, wavsound.frame *2*sizeof(short));
}
*/
//printf("Time took is %f.\n", (double)(clock() - start)/CLOCKS_PER_SEC);
2022-07-03 19:24:53 -05:00
}
2022-07-04 12:47:21 -05:00
2022-07-03 19:24:53 -05:00
if (!vidplaying) return 0;
for (int i = 0; i < framesPerBuffer; i++) {
//short a[2] = {0, 0};
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
//a[0] += *(short*)cbuf_shift(&vidbuf) * 5;
//a[1] += *(short*)cbuf_shift(&vidbuf) * 5;
2022-07-03 00:43:42 -05:00
2022-07-04 12:47:21 -05:00
out[i*2] += cbuf_shift(&vidbuf) * 5;
out[i*2+1] += cbuf_shift(&vidbuf) * 5;
2022-07-03 00:43:42 -05:00
}
return 0;
}
void check_pa_err(PaError e)
2022-06-23 02:34:51 -05:00
{
2022-07-03 00:43:42 -05:00
if (e != paNoError) {
YughError("PA Error: %s", Pa_GetErrorText(e));
exit(1);
}
2022-06-23 02:34:51 -05:00
}
2022-01-19 16:43:21 -06:00
2022-07-03 00:43:42 -05:00
static PaStream *stream_def;
2022-07-04 12:47:21 -05:00
void normalize_gain(struct wav *w, double lv)
{
short tarmax = pow(10, lv/20.f) * SHRT_MAX;
short max = 0;
short *s = w->data;
for (int i = 0; i < w->frames; i++) {
for (int j = 0; j < w->ch; j++) {
max = (abs(s[i*w->ch + j]) > max) ? abs(s[i*w->ch + j]) : max;
}
}
2022-07-03 00:43:42 -05:00
2022-07-04 12:47:21 -05:00
w->gain = log10((float)tarmax/max) * 20;
}
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
void sound_init()
{
vidbuf = circbuf_init(sizeof(short), 262144);
2022-07-03 00:43:42 -05:00
2022-07-03 19:24:53 -05:00
mwav.data = drwav_open_file_and_read_pcm_frames_s16("sounds/alert.wav", &mwav.ch, &mwav.samplerate, &mwav.frames, NULL);
2022-07-03 00:43:42 -05:00
2022-07-04 12:47:21 -05:00
mwav.gain = 0;
2022-07-03 19:24:53 -05:00
printf("Loaded wav: ch %i, sr %i, fr %i.\n", mwav.ch, mwav.samplerate, mwav.frames);
2022-07-03 00:43:42 -05:00
2022-07-05 15:12:48 -05:00
change_samplerate(mwav, 48000);
2022-07-04 14:19:52 -05:00
2022-07-05 15:12:48 -05:00
//mwav = gen_square(1, 150, 48000, 2);
2022-07-04 12:47:21 -05:00
wavsound.data = &mwav;
2022-07-03 19:24:53 -05:00
wavsound.loop = 1;
wavsound.play = 1;
2022-07-03 00:43:42 -05:00
2022-07-04 12:47:21 -05:00
normalize_gain(&mwav, -3);
2022-07-03 19:24:53 -05:00
/*
2022-07-03 00:43:42 -05:00
if (!drmp3_init_file(&mp3, "sounds/circus.mp3", NULL)) {
YughError("Could not open mp3.",0);
}
printf("CIrcus mp3 channels: %ui, samplerate: %ui\n", mp3.channels, mp3.sampleRate);
2022-07-03 19:24:53 -05:00
*/
2022-07-03 00:43:42 -05:00
PaError err = Pa_Initialize();
check_pa_err(err);
int numDevices = Pa_GetDeviceCount();
const PaDeviceInfo *deviceInfo;
for (int i = 0; i < numDevices; i++) {
deviceInfo = Pa_GetDeviceInfo(i);
2022-07-03 19:24:53 -05:00
// printf("Device %i: channels %i, sample rate %f, name %s\n", i, deviceInfo->maxOutputChannels, deviceInfo->defaultSampleRate, deviceInfo->name);
2022-07-03 00:43:42 -05:00
}
PaStreamParameters outparams;
2022-07-03 11:28:44 -05:00
/*
2022-07-03 00:43:42 -05:00
outparams.channelCount = 2;
2022-07-03 11:28:44 -05:00
outparams.device = 19;
outparams.sampleFormat = paInt16;
2022-07-03 00:43:42 -05:00
outparams.suggestedLatency = Pa_GetDeviceInfo(outparams.device)->defaultLowOutputLatency;
outparams.hostApiSpecificStreamInfo = NULL;
2022-07-03 11:28:44 -05:00
*/
2022-07-03 00:43:42 -05:00
2022-07-03 11:28:44 -05:00
//err = Pa_OpenStream(&stream_def, NULL, &outparams, 48000, 4096, paNoFlag, patestCallback, &data);
2022-07-04 12:47:21 -05:00
err = Pa_OpenDefaultStream(&stream_def, 0, 2, paInt16, 48000, 2048, patestCallback, NULL);
2022-07-03 00:43:42 -05:00
check_pa_err(err);
2022-07-02 03:40:50 -05:00
2022-07-03 00:43:42 -05:00
err = Pa_StartStream(stream_def);
check_pa_err(err);
2022-07-02 03:40:50 -05:00
2022-06-23 02:34:51 -05:00
2022-01-19 16:43:21 -06:00
}
void audio_open(const char *device)
{
2022-06-22 20:39:18 -05:00
//Mix_OpenAudioDevice(44100, MIX_DEFAULT_FORMAT, 2, 2048, device, 0);
2022-01-19 16:43:21 -06:00
}
void audio_close()
{
2022-06-22 20:39:18 -05:00
//Mix_CloseAudio();
2022-01-19 16:43:21 -06:00
}
struct sound *make_sound(const char *wav)
{
2022-07-03 00:43:42 -05:00
2022-01-19 16:43:21 -06:00
struct sound *new = calloc(1, sizeof(struct sound));
2022-07-03 00:43:42 -05:00
/* ma_result res = ma_sound_init_from_file(&engine, wav, 0, NULL, NULL, &new->sound);
2022-06-23 02:34:51 -05:00
if (res != MA_SUCCESS) {
printf("HONO!!!!");
}
2022-07-03 00:43:42 -05:00
*/
2022-01-19 16:43:21 -06:00
return new;
}
2022-06-23 02:34:51 -05:00
struct sound *make_music(const char *ogg)
2022-01-19 16:43:21 -06:00
{
2022-07-03 00:43:42 -05:00
2022-06-23 02:34:51 -05:00
struct sound *sound = calloc(1, sizeof(struct sound));
2022-07-03 00:43:42 -05:00
// ma_result res = ma_sound_init_from_file(&engine, ogg, 0, NULL, &mus_grp, &sound->sound);
2022-01-19 16:43:21 -06:00
return sound;
}
void play_sound(struct sound *sound)
{
2022-06-23 02:34:51 -05:00
//ma_sound_set_volume(&sound->sound, (float)sound->volume/127);
2022-07-03 00:43:42 -05:00
// ma_sound_start(&sound->sound);
// sound->state = MUS_PLAY;
2022-01-19 16:43:21 -06:00
}
void play_music(struct sound *music)
{
2022-07-03 00:43:42 -05:00
//ma_sound_start(&music->sound);
//music->state = MUS_PLAY;
// mus_cur = music;
2022-01-19 16:43:21 -06:00
}
void music_set(struct sound *music)
{
}
void music_volume(unsigned char vol)
{
2022-07-03 00:43:42 -05:00
// ma_sound_group_set_volume(&mus_grp, (float)vol/127);
2022-01-19 16:43:21 -06:00
}
int music_playing()
{
2022-07-03 00:43:42 -05:00
//return ma_sound_is_playing(&mus_cur->sound);
return 0;
2022-01-19 16:43:21 -06:00
}
int music_paused()
{
2022-07-03 00:43:42 -05:00
// return mus_cur->state == MUS_PAUSE;
return 0;
2022-01-19 16:43:21 -06:00
}
void music_resume()
{
2022-07-03 00:43:42 -05:00
// ma_sound_start(&mus_cur->sound);
2022-01-19 16:43:21 -06:00
}
void music_pause()
{
2022-07-03 00:43:42 -05:00
//ma_sound_stop(&mus_cur->sound);
//mus_cur->state = MUS_PAUSE;
2022-01-19 16:43:21 -06:00
}
void music_stop()
{
2022-07-03 00:43:42 -05:00
// ma_sound_stop(&mus_cur->sound);
// mus_cur->state = MUS_STOP;
// ma_sound_seek_to_pcm_frame(&mus_cur->sound, 0);
2022-01-19 16:43:21 -06:00
}
void audio_init()
{
2022-06-22 20:39:18 -05:00
//audioDriver = SDL_GetAudioDeviceName(0,0);
2022-02-06 10:14:57 -06:00
}
void play_raw(int device, void *data, int size)
{
2022-07-03 19:24:53 -05:00
2022-07-03 00:43:42 -05:00
float *d = data;
2022-07-03 19:24:53 -05:00
short t;
2022-07-03 11:28:44 -05:00
for (int i = 0; i < size; i++) {
2022-07-03 19:24:53 -05:00
t = (short)(d[i]*32767);
cbuf_push(&vidbuf, t);
2022-07-03 11:28:44 -05:00
}
2022-07-03 19:24:53 -05:00
vidplaying = 1;
2022-07-03 11:28:44 -05:00
/*
for (int i = 0; i < size; i++) {
short temp = (short)(d[i] * 32767);
cbuf_append(&vidbuf, &temp, 1);
2022-07-03 00:43:42 -05:00
}
2022-07-03 11:28:44 -05:00
*/
2022-02-06 10:14:57 -06:00
}
void close_audio_device(int device)
{
2022-06-22 20:39:18 -05:00
//SDL_CloseAudioDevice(device);
2022-02-06 10:14:57 -06:00
}
void clear_raw(int device)
{
2022-06-22 20:39:18 -05:00
//SDL_ClearQueuedAudio(device);
2022-02-06 10:14:57 -06:00
}
int open_device(const char *adriver)
{
2022-06-23 02:34:51 -05:00
2022-06-22 20:39:18 -05:00
/*
2022-02-06 10:14:57 -06:00
SDL_AudioSpec audio_spec;
SDL_memset(&audio_spec, 0, sizeof(audio_spec));
audio_spec.freq = 48000;
audio_spec.format = AUDIO_F32;
audio_spec.channels = 2;
audio_spec.samples = 4096;
int dev = (int) SDL_OpenAudioDevice(adriver, 0, &audio_spec, NULL, 0);
SDL_PauseAudioDevice(dev, 0);
2022-06-22 20:39:18 -05:00
2022-02-06 10:14:57 -06:00
return dev;
2022-06-22 20:39:18 -05:00
*/
return 0;
2022-02-06 10:14:57 -06:00
}