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-23 02:34:51 -05:00
|
|
|
|
|
|
|
ma_engine engine;
|
|
|
|
|
2022-01-19 16:43:21 -06:00
|
|
|
const char *audioDriver;
|
|
|
|
|
2022-06-23 02:34:51 -05:00
|
|
|
struct sound *mus_cur;
|
|
|
|
ma_sound_group mus_grp;
|
|
|
|
|
|
|
|
void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
|
|
|
|
{
|
|
|
|
// In playback mode copy data to pOutput. In capture mode read data from pInput. In full-duplex mode, both
|
|
|
|
// pOutput and pInput will be valid and you can move data from pInput into pOutput. Never process more than
|
|
|
|
// frameCount frames.
|
|
|
|
}
|
2022-01-19 16:43:21 -06:00
|
|
|
|
|
|
|
void sound_init()
|
|
|
|
{
|
2022-06-22 20:39:18 -05:00
|
|
|
/*
|
2022-06-23 02:34:51 -05:00
|
|
|
ma_device_config cnf = ma_device_config_init(ma_device_type_playback);
|
|
|
|
cnf.playback.format = ma_format_f32;
|
|
|
|
cnf.playback.channels = 0;
|
|
|
|
cnf.sampleRate = 0;
|
|
|
|
cnf.dataCallback = data_callback;
|
|
|
|
|
|
|
|
ma_device device;
|
|
|
|
ma_device_init(NULL, &cnf, &device);
|
|
|
|
|
|
|
|
ma_device_start(&device);
|
|
|
|
|
2022-06-22 20:39:18 -05:00
|
|
|
*/
|
2022-01-19 16:43:21 -06:00
|
|
|
|
2022-06-23 02:34:51 -05:00
|
|
|
ma_result result = ma_engine_init(NULL, &engine);
|
|
|
|
if (result != MA_SUCCESS) {
|
|
|
|
printf("UHOH!!!");
|
|
|
|
}
|
|
|
|
|
|
|
|
ma_sound_group_init(&engine, 0, NULL, &mus_grp);
|
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)
|
|
|
|
{
|
|
|
|
struct sound *new = calloc(1, sizeof(struct sound));
|
2022-06-23 02:34:51 -05:00
|
|
|
ma_result res = ma_sound_init_from_file(&engine, wav, 0, NULL, NULL, &new->sound);
|
|
|
|
|
|
|
|
if (res != MA_SUCCESS) {
|
|
|
|
printf("HONO!!!!");
|
|
|
|
}
|
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-06-23 02:34:51 -05:00
|
|
|
struct sound *sound = calloc(1, sizeof(struct sound));
|
|
|
|
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);
|
|
|
|
ma_sound_start(&sound->sound);
|
|
|
|
sound->state = MUS_PLAY;
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void play_music(struct sound *music)
|
|
|
|
{
|
2022-06-23 02:34:51 -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-06-23 02:34:51 -05:00
|
|
|
ma_sound_group_set_volume(&mus_grp, (float)vol/127);
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int music_playing()
|
|
|
|
{
|
2022-06-23 02:34:51 -05:00
|
|
|
return ma_sound_is_playing(&mus_cur->sound);
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int music_paused()
|
|
|
|
{
|
2022-06-23 02:34:51 -05:00
|
|
|
return mus_cur->state == MUS_PAUSE;
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void music_resume()
|
|
|
|
{
|
2022-06-23 02:34:51 -05:00
|
|
|
ma_sound_start(&mus_cur->sound);
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void music_pause()
|
|
|
|
{
|
2022-06-23 02:34:51 -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-06-23 02:34:51 -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-06-22 20:39:18 -05:00
|
|
|
//SDL_QueueAudio(device, data, size);
|
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
|
|
|
}
|