SDL_libretro_audio.h

Go to the documentation of this file.

 
#if defined(SDL_LIBRETRO_IMPLEMENTATION) && !defined(SDL_LIBRETRO_AUDIO_IMPL_ONCE)
#define SDL_LIBRETRO_AUDIO_IMPL_ONCE
 
#ifndef SDL_LIBRETRO_AUDIO_DEFAULT_LATENCY_MS
#define SDL_LIBRETRO_AUDIO_DEFAULT_LATENCY_MS 100
#endif
 
#ifndef SDL_LIBRETRO_AUDIO_DEFAULT_SAMPLE_RATE
#define SDL_LIBRETRO_AUDIO_DEFAULT_SAMPLE_RATE 48000
#endif
 
#ifndef SDL_LIBRETRO_AUDIO_DRC_MAX_DELTA
#define SDL_LIBRETRO_AUDIO_DRC_MAX_DELTA 0.005
#endif
 
static void SDL_Libretro_QueueAudio(SDL_Libretro* lr, const void* samples, int bytes) {
    if (!lr->core.audioStream || bytes <= 0) return;
 
    // DRC steers the queue toward half of audioQueueThresholdBytes, so the
    // hard cap sits at double the threshold and only catches transient spikes
    // DRC can't absorb. When it trips, keep whatever still fits and drop just
    // the overflow: cutting a whole batch mid-waveform is an audible pop.
    int cap = lr->core.audioQueueThresholdBytes * 2;
    if (cap > 0) {
        int queued = SDL_GetAudioStreamQueued(lr->core.audioStream);
        if (queued >= 0 && bytes > cap - queued) {
            int room = cap - queued;
            if (room < 0) room = 0;
            room -= room % (int)(sizeof(int16_t) * 2); // Keep whole frames.
 
            // Dropping is expected back-pressure when ramping up, so this can be debug noise.
            if (lr->core.audioDropWarnCount < 10) {
                SDL_LogDebug(SDL_LOG_CATEGORY_AUDIO, "[SDL_Libretro] Audio queue full with %d bytes queued, dropping %d bytes", queued, bytes - room);
                lr->core.audioDropWarnCount++;
            }
 
            bytes = room;
            if (bytes <= 0) return;
        }
    }
 
    SDL_PutAudioStreamData(lr->core.audioStream, samples, bytes);
}
 
static void SDL_Libretro_QueueAudioReversed(SDL_Libretro* lr, const int16_t* data, size_t frames) {
    int16_t revBuf[512 * 2];
    size_t remaining = frames;
    while (remaining > 0) {
        size_t chunk = remaining > 512 ? 512 : remaining;
        for (size_t i = 0; i < chunk; i++) {
            size_t src = remaining - 1 - i; // Walk backwards from the end.
            revBuf[i * 2] = data[src * 2];
            revBuf[i * 2 + 1] = data[src * 2 + 1];
        }
        SDL_Libretro_QueueAudio(lr, revBuf, (int)(chunk * sizeof(int16_t) * 2));
        remaining -= chunk;
    }
}
 
static void SDL_Libretro_UpdateDRC(SDL_Libretro* lr, float speed) {
    if (!lr || !lr->core.audioStream) return;
 
    // There is no need to update DRC when the speed is <= 0, so leave
    // the current ratio untouched while stopped.
    if (speed <= 0.0f) return;
 
    // When DRC is off, unwind any leftover nudge so the ratio tracks the
    // plain speed instead of freezing at the last adjustment.
    if (!lr->core.drcEnabled) {
        if (lr->core.drcAdjustment != 1.0f) {
            lr->core.drcAdjustment = 1.0f;
            lr->core.drcDriftAvg = 0.0;
            SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, speed);
        }
        return;
    }
 
    // Without a valid fill target, there's nothing to tweak.
    if (lr->core.audioQueueThresholdBytes <= 0) {
        SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, speed);
        return;
    }
 
    int queued = SDL_GetAudioStreamQueued(lr->core.audioStream);
    if (queued < 0) return; // Ignore SDL errors.
 
    // Hold the queue near 50% fill at every speed. Consumption already tracks `speed` (ratio = speed * adj), so slow-mo and fast-forward stay balanced and the small nudge corrects residual clock drift either way. Gating this to normal speed let the queue drift and underrun (audible in slow motion, where audio bursts are spaced farther apart).
    double drift = (double)queued / (double)lr->core.audioQueueThresholdBytes - 0.5; // > + full, - empty
    lr->core.drcDriftAvg += 0.0625 * (drift - lr->core.drcDriftAvg);
    double adj = 1.0 + SDL_LIBRETRO_AUDIO_DRC_MAX_DELTA * (2.0 * lr->core.drcDriftAvg);
    adj = SDL_clamp(adj, 1.0 - SDL_LIBRETRO_AUDIO_DRC_MAX_DELTA, 1.0 + SDL_LIBRETRO_AUDIO_DRC_MAX_DELTA);
 
    lr->core.drcAdjustment = (float)adj;
    SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, speed * (float)adj);
}
 
static unsigned SDL_Libretro_UpdateAudioThreshold(SDL_Libretro* lr) {
    unsigned latencyMs = SDL_Libretro_GetAudioLatency(lr);
    if (lr->core.minimumAudioLatencyMs > latencyMs) latencyMs = lr->core.minimumAudioLatencyMs;
 
    int threshold = (int)(SDL_Libretro_GetSampleRate(lr) * latencyMs / 1000.0 * (double)(sizeof(int16_t) * 2));
 
    // Keep at least a few audio batches of headroom so back-pressure + DRC can function; a tiny latency (or a low sample rate, where each batch spans more time) would otherwise size the queue below a single batch and drop almost everything.
    int minThreshold = 4 * (SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE * (int)(sizeof(int16_t) * 2));
    lr->core.audioQueueThresholdBytes = threshold > minThreshold ? threshold : minThreshold;
    return latencyMs;
}
 
static void SDL_Libretro_ReportAudioBufferStatus(SDL_Libretro* lr) {
    if (!lr || !lr->core.audio_buffer_status.callback) return;
 
    bool active = (lr->core.audioStream != NULL);
 
    unsigned occupancy = 0;
 
    bool underrunLikely = false;
 
    if (active && lr->core.audioQueueThresholdBytes > 0) {
        int queued = SDL_GetAudioStreamQueued(lr->core.audioStream);
        if (queued < 0) queued = 0;
 
        double pct = (double)queued * 100.0 / (double)lr->core.audioQueueThresholdBytes;
        occupancy = (unsigned)(pct > 100.0 ? 100.0 : pct);
 
        // One frame drains sampleRate/fps stereo int16 samples; if fewer than that are queued, the next frame risks starving the device.
        double fps = lr->core.fps > 0.0 ? lr->core.fps : 60.0;
        int frameBytes = (int)(SDL_Libretro_GetSampleRate(lr) / fps * (double)(sizeof(int16_t) * 2));
        underrunLikely = (queued < frameBytes);
    }
 
    lr->core.audio_buffer_status.callback(active, occupancy, underrunLikely);
}
 
static bool SDL_Libretro_InitAudio(SDL_Libretro* lr) {
    if (!SDL_Libretro_IsCoreReady(lr)) {
        SDL_SetError("[SDL_Libretro] No core loaded");
        return false;
    }
 
    SDL_Libretro_CloseAudio(lr);
 
    SDL_Libretro_UpdateAudioThreshold(lr);
    double sampleRate = SDL_Libretro_GetSampleRate(lr);
 
    SDL_AudioSpec spec;
    // Truncating a fractional core rate (e.g. the SNES's 32040.5 Hz) is fine:
    // DRC absorbs sub-Hz drift, so don't bother rounding here.
    spec.freq = (int)sampleRate;
    // Match the S16 interleaved-stereo format cores deliver; SDL converts to
    // the device format internally, so samples are pushed straight through.
    spec.format = SDL_AUDIO_S16;
    spec.channels = 2;
 
    lr->core.audioStream = SDL_OpenAudioDeviceStream(
        SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
        &spec,
        NULL,
        (void*)lr);
 
    if (!lr->core.audioStream) {
        SDL_SetError("[SDL_Libretro] Failed to open audio device: %s", SDL_GetError());
        return false;
    }
 
    // Fresh drop-warning budget for this stream (InitAudio may run again on reopen).
    lr->core.audioDropWarnCount = 0;
    lr->core.audioReinitPending = false;
 
    // Dynamic Rate Control
    lr->core.drcAdjustment = 1.0f;
    lr->core.drcEnabled = true;
    lr->core.drcDriftAvg = 0.0;
 
    // A reinit can land while paused (speed 0) or rewinding (speed < 0), and
    // SDL rejects frequency ratios outside [0.01, 100] — failing here would
    // tear the stream back down and leave audio dead. Seed a valid ratio;
    // SetSpeed/UpdateDRC apply the real one as soon as playback moves.
    float ratio = SDL_fabsf(lr->core.speed) * lr->core.drcAdjustment;
    if (ratio < 0.01f) ratio = 1.0f;
    if (!SDL_SetAudioStreamFrequencyRatio(lr->core.audioStream, ratio)) {
        SDL_SetError("[SDL_Libretro] Failed to set audio frequency: %s", SDL_GetError());
        SDL_DestroyAudioStream(lr->core.audioStream);
        lr->core.audioStream = NULL;
        return false;
    }
 
    // Volume
    SDL_SetAudioStreamGain(lr->core.audioStream, lr->volume);
    SDL_ResumeAudioStreamDevice(lr->core.audioStream);
 
    // Audio Callback
    if (lr->core.audio_callback.set_state) {
        lr->core.audio_callback.set_state(true);
    }
 
    SDL_Log("[SDL_Libretro] Audio initialized [%d Channels @ %d Hz]", spec.channels, spec.freq);
 
    return true;
}
 
static void SDL_Libretro_CloseAudio(SDL_Libretro* lr) {
    if (!lr) return;
 
    // Audio Callback
    if (lr->core.audio_callback.set_state) {
        lr->core.audio_callback.set_state(false);
    }
 
    if (lr->core.audioStream) {
        SDL_DestroyAudioStream(lr->core.audioStream);
        lr->core.audioStream = NULL;
    }
}
 
void SDL_Libretro_SetAudioLatency(SDL_Libretro* lr, unsigned latencyMs) {
    if (!lr) return;
    lr->audioLatencyMs = latencyMs;
 
    // When the Audio Latency changes, make sure to update the threshold too.
    if (lr->core.audioStream) {
        SDL_Libretro_UpdateAudioThreshold(lr);
    }
}
 
unsigned SDL_Libretro_GetAudioLatency(const SDL_Libretro* lr) {
    if (!lr) return 0;
    return lr->audioLatencyMs ? lr->audioLatencyMs : SDL_LIBRETRO_AUDIO_DEFAULT_LATENCY_MS;
}
 
double SDL_Libretro_GetSampleRate(const SDL_Libretro* lr) {
    return (lr && lr->core.sampleRate > 0.0) ? lr->core.sampleRate : SDL_LIBRETRO_AUDIO_DEFAULT_SAMPLE_RATE;
}
 
static void SDL_Libretro_AudioSample(int16_t left, int16_t right) {
    SDL_Libretro* lr = SDL_Libretro_active;
    if (!lr) return;
 
    if (lr->core.singleSampleCount >= SDL_LIBRETRO_AUDIO_SINGLE_SAMPLE_BUFFER_SIZE) {
        SDL_Libretro_FlushSingleSamples(lr);
    }
 
    size_t idx = lr->core.singleSampleCount * 2;
    lr->core.singleSampleBuffer[idx] = left;
    lr->core.singleSampleBuffer[idx + 1] = right;
    lr->core.singleSampleCount++;
}
 
static size_t SDL_Libretro_AudioSampleBatch(const int16_t* data, size_t frames) {
    SDL_Libretro* lr = SDL_Libretro_active;
    if (!lr || !lr->core.audioStream || frames == 0) return frames;
 
    if (lr->core.singleSampleCount > 0) {
        SDL_Libretro_FlushSingleSamples(lr);
    }
 
    // While rewinding, emit this frame's audio reversed for a clean rewind sound.
    if (lr->rewindActive) {
        SDL_Libretro_QueueAudioReversed(lr, data, frames);
        return frames;
    }
 
    SDL_Libretro_QueueAudio(lr, data, (int)(frames * sizeof(int16_t) * 2));
    return frames;
}
 
static void SDL_Libretro_FlushSingleSamples(SDL_Libretro* lr) {
    if (!lr || lr->core.singleSampleCount == 0) return;
 
    // While rewinding, emit the buffered frames reversed for a clean rewind sound.
    if (lr->rewindActive) {
        SDL_Libretro_QueueAudioReversed(lr, lr->core.singleSampleBuffer, lr->core.singleSampleCount);
        lr->core.singleSampleCount = 0;
        return;
    }
 
    SDL_Libretro_QueueAudio(lr, lr->core.singleSampleBuffer, (int)(lr->core.singleSampleCount * sizeof(int16_t) * 2));
    lr->core.singleSampleCount = 0;
}
 
// Microphone
 
#ifndef SDL_LIBRETRO_MIC_DEFAULT_RATE
#define SDL_LIBRETRO_MIC_DEFAULT_RATE 44100
#endif
 
static retro_microphone_t* SDL_Libretro_MicOpen(const retro_microphone_params_t* params) {
    SDL_Libretro* lr = SDL_Libretro_active;
    if (!lr) return NULL;
 
    // Only one microphone is supported. Handing back the open one would give
    // the core two handles to the same mic, and closing either frees both.
    if (lr->core.microphone) {
        SDL_LogWarn(SDL_LOG_CATEGORY_AUDIO, "[SDL_Libretro] Microphone already open");
        return NULL;
    }
 
    unsigned rate = (params && params->rate > 0) ? params->rate : SDL_LIBRETRO_MIC_DEFAULT_RATE;
 
    SDL_AudioSpec spec;
    spec.freq = (int)rate;
    spec.format = SDL_AUDIO_S16;
    spec.channels = 1;
 
    SDL_AudioStream* stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_RECORDING, &spec, NULL, (void*)lr);
    if (!stream) {
        SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "[SDL_Libretro] Failed to open microphone: %s", SDL_GetError());
        return NULL;
    }
 
    SDL_LibretroMicrophone* mic = (SDL_LibretroMicrophone*)SDL_calloc(1, sizeof(*mic));
    if (!mic) {
        SDL_DestroyAudioStream(stream);
        SDL_OutOfMemory();
        return NULL;
    }
 
    mic->stream = stream;
    mic->rate = rate;
    mic->active = false;
    mic->lr = lr;
    lr->core.microphone = mic;
 
    SDL_Log("[SDL_Libretro] Microphone opened (%u Hz)", rate);
    return (retro_microphone_t*)mic;
}
 
static void SDL_Libretro_MicClose(retro_microphone_t* microphone) {
    SDL_LibretroMicrophone* mic = (SDL_LibretroMicrophone*)microphone;
    if (!mic) return;
 
    // Dereference from the core if it's actively referencing itself.
    if (mic->lr && mic->lr->core.microphone == mic) {
        mic->lr->core.microphone = NULL;
    }
 
    // Destroy the stream.
    if (mic->stream) {
        SDL_DestroyAudioStream(mic->stream);
        mic->stream = NULL;
    }
    SDL_free(mic);
}
 
static bool SDL_Libretro_MicGetParams(const retro_microphone_t* microphone, retro_microphone_params_t* params) {
    const SDL_LibretroMicrophone* mic = (const SDL_LibretroMicrophone*)microphone;
    if (!mic || !params) return false;
    params->rate = mic->rate;
    return true;
}
 
static bool SDL_Libretro_MicSetState(retro_microphone_t* microphone, bool state) {
    SDL_LibretroMicrophone* mic = (SDL_LibretroMicrophone*)microphone;
    if (!mic || !mic->stream) return false;
 
    bool ok;
    if (state) {
        ok = SDL_ResumeAudioStreamDevice(mic->stream);
    }
    else {
        ok = SDL_PauseAudioStreamDevice(mic->stream);
    }
 
    // If the state changed successfully, update it accordingly.
    if (ok) {
        mic->active = state;
    }
    return ok;
}
 
static bool SDL_Libretro_MicGetState(const retro_microphone_t* microphone) {
    const SDL_LibretroMicrophone* mic = (const SDL_LibretroMicrophone*)microphone;
    if (!mic) return false;
    return mic->active;
}
 
static int SDL_Libretro_MicRead(retro_microphone_t* microphone, int16_t* samples, size_t num_samples) {
    SDL_LibretroMicrophone* mic = (SDL_LibretroMicrophone*)microphone;
    if (!mic || !mic->stream || !samples || num_samples == 0) return 0;
 
    int bytes = SDL_GetAudioStreamData(mic->stream, samples, (int)(num_samples * sizeof(int16_t)));
    if (bytes < 0) return 0;
    return bytes / (int)sizeof(int16_t);
}
 
static void SDL_Libretro_CloseMicrophone(SDL_Libretro* lr) {
    if (!lr || !lr->core.microphone) return;
    SDL_Libretro_MicClose((retro_microphone_t*)lr->core.microphone);
    lr->core.microphone = NULL;
}
 
#endif /* SDL_LIBRETRO_AUDIO_IMPL_ONCE */