path: root/kon/konaudio.c

/* SPDX-License-Identifier: MIT */
/*
 * konaudio.c
 *
 * Copyright (c) 2026 KonAki
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */


#include "konaudio.h"

#include <stdlib.h>
#include <string.h>

#include "miniaudio.h"

typedef struct kon_voiceSlot {
	const kon_sound_t *sound;
	double position;
	double step;
	float volume;
	float pan;
	int loop;
	int active;
	uint32_t generation;
} kon_voiceSlot_t;

struct kon_audio {
	kon_voiceSlot_t voices[KON_AUDIO_VOICES];
	float master;
	uint32_t rate;
	int hasDevice;
	ma_mutex lock;
	ma_device device;
};

static void kon_audioCallback_(ma_device *device, void *out, const void *in, ma_uint32 frames)
{
	kon_audio_t *audio = device->pUserData;

	(void)in;
	kon_audioMix(audio, out, frames);
}

static kon_audio_t *kon_audioNew_(uint32_t sampleRate)
{
	kon_audio_t *audio = calloc(1, sizeof(kon_audio_t));

	if (!audio) return NULL;
	if (ma_mutex_init(&audio->lock) != MA_SUCCESS) {
		free(audio);
		return NULL;
	}
	audio->master = 1.0f;
	audio->rate = sampleRate ? sampleRate : 48000;
	return audio;
}

kon_audio_t *kon_audioCreateOffline(uint32_t sampleRate)
{
	return kon_audioNew_(sampleRate);
}

kon_audio_t *kon_audioCreate(uint32_t sampleRate)
{
	kon_audio_t *audio = kon_audioNew_(sampleRate);
	ma_device_config config;

	if (!audio) return NULL;

	config = ma_device_config_init(ma_device_type_playback);
	config.playback.format = ma_format_f32;
	config.playback.channels = 2;
	config.sampleRate = audio->rate;
	config.dataCallback = kon_audioCallback_;
	config.pUserData = audio;

	if (ma_device_init(NULL, &config, &audio->device) != MA_SUCCESS) {
		ma_mutex_uninit(&audio->lock);
		free(audio);
		return NULL;
	}
	audio->rate = audio->device.sampleRate;
	audio->hasDevice = 1;

	if (ma_device_start(&audio->device) != MA_SUCCESS) {
		kon_audioDestroy(audio);
		return NULL;
	}
	return audio;
}

void kon_audioDestroy(kon_audio_t *audio)
{
	if (!audio) return;
	if (audio->hasDevice) ma_device_uninit(&audio->device);
	ma_mutex_uninit(&audio->lock);
	free(audio);
}

uint32_t kon_audioRate(const kon_audio_t *audio)
{
	return audio->rate;
}

kon_voice_t kon_audioPlay(kon_audio_t *audio, const kon_sound_t *sound, float volume, float pan, int loop)
{
	kon_voice_t handle = 0;
	int i;

	if (!audio || !sound || !sound->frames || sound->frameCount == 0 || sound->channels == 0 || sound->sampleRate == 0) return 0;

	if (pan < -1.0f) pan = -1.0f;
	if (pan > 1.0f) pan = 1.0f;

	ma_mutex_lock(&audio->lock);
	for (i = 0; i < KON_AUDIO_VOICES; i++) {
		kon_voiceSlot_t *v = &audio->voices[i];

		if (v->active) continue;
		v->generation++;
		if (v->generation == 0) v->generation = 1;
		v->sound = sound;
		v->position = 0.0;
		v->step = (double)sound->sampleRate / (double)audio->rate;
		v->volume = volume;
		v->pan = pan;
		v->loop = loop;
		v->active = 1;
		handle = (v->generation << 8) | (uint32_t)(i + 1);
		break;
	}
	ma_mutex_unlock(&audio->lock);
	return handle;
}

static kon_voiceSlot_t *kon_audioFind_(kon_audio_t *audio, kon_voice_t handle)
{
	uint32_t index = handle & 0xFF;
	kon_voiceSlot_t *v;

	if (index == 0 || index > KON_AUDIO_VOICES) return NULL;
	v = &audio->voices[index - 1];
	if (!v->active || v->generation != (handle >> 8)) return NULL;
	return v;
}

void kon_audioStop(kon_audio_t *audio, kon_voice_t voice)
{
	kon_voiceSlot_t *v;

	ma_mutex_lock(&audio->lock);
	v = kon_audioFind_(audio, voice);
	if (v) v->active = 0;
	ma_mutex_unlock(&audio->lock);
}

void kon_audioStopSound(kon_audio_t *audio, const kon_sound_t *sound)
{
	int i;

	ma_mutex_lock(&audio->lock);
	for (i = 0; i < KON_AUDIO_VOICES; i++) {
		if (audio->voices[i].active && audio->voices[i].sound == sound) audio->voices[i].active = 0;
	}
	ma_mutex_unlock(&audio->lock);
}

void kon_audioStopAll(kon_audio_t *audio)
{
	int i;

	ma_mutex_lock(&audio->lock);
	for (i = 0; i < KON_AUDIO_VOICES; i++) audio->voices[i].active = 0;
	ma_mutex_unlock(&audio->lock);
}

int kon_audioIsPlaying(kon_audio_t *audio, kon_voice_t voice)
{
	int playing;

	ma_mutex_lock(&audio->lock);
	playing = kon_audioFind_(audio, voice) != NULL;
	ma_mutex_unlock(&audio->lock);
	return playing;
}

int kon_audioVoiceCount(kon_audio_t *audio)
{
	int i, count = 0;

	ma_mutex_lock(&audio->lock);
	for (i = 0; i < KON_AUDIO_VOICES; i++) count += audio->voices[i].active;
	ma_mutex_unlock(&audio->lock);
	return count;
}

void kon_audioSetVolume(kon_audio_t *audio, float volume)
{
	if (volume < 0.0f) volume = 0.0f;
	ma_mutex_lock(&audio->lock);
	audio->master = volume;
	ma_mutex_unlock(&audio->lock);
}

void kon_audioMix(kon_audio_t *audio, float *out, uint32_t frames)
{
	uint32_t f;
	int i;

	memset(out, 0, (size_t)frames * 2 * sizeof(float));

	ma_mutex_lock(&audio->lock);
	for (i = 0; i < KON_AUDIO_VOICES; i++) {
		kon_voiceSlot_t *v = &audio->voices[i];
		const kon_sound_t *s = v->sound;
		float gainL, gainR;

		if (!v->active) continue;

		gainL = v->volume * (v->pan > 0.0f ? 1.0f - v->pan : 1.0f);
		gainR = v->volume * (v->pan < 0.0f ? 1.0f + v->pan : 1.0f);

		for (f = 0; f < frames; f++) {
			uint64_t a = (uint64_t)v->position, b;
			float t, l0, r0, l1, r1;
			const int16_t *p;

			if (a >= s->frameCount) {
				if (!v->loop) {
					v->active = 0;
					break;
				}
				v->position -= (double)s->frameCount;
				a = (uint64_t)v->position;
			}
			b = a + 1;
			if (b >= s->frameCount) b = v->loop ? 0 : a;
			t = (float)(v->position - (double)a);

			p = s->frames + a * s->channels;
			l0 = p[0] / 32768.0f;
			r0 = (s->channels > 1 ? p[1] : p[0]) / 32768.0f;
			p = s->frames + b * s->channels;
			l1 = p[0] / 32768.0f;
			r1 = (s->channels > 1 ? p[1] : p[0]) / 32768.0f;

			out[f * 2] += (l0 + (l1 - l0) * t) * gainL;
			out[f * 2 + 1] += (r0 + (r1 - r0) * t) * gainR;
			v->position += v->step;
		}
	}

	for (f = 0; f < frames * 2; f++) {
		float x = out[f] * audio->master;

		out[f] = x > 1.0f ? 1.0f : (x < -1.0f ? -1.0f : x);
	}
	ma_mutex_unlock(&audio->lock);
}