Home /Modules/codecs/test_manager.c

test_manager.c

codecs/tests/test_manager.c · 117 line(s) · c

/*
 * Codec Manager test: load -> use -> unload, across native and backend codecs.
 * Exercises the Loader/Unloader/Management Controller that SLeeLa calls.
 */

#include "sleela_codec_manager.h"

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

/* A stand-in backend adapter: the shape a real libFLAC/libopus adapter takes.
 * It just records that it ran, proving the manager dispatches to a registered
 * backend for a BACKEND-state codec. */
static int g_fake_flac_calls = 0;
static sleela_codec_result fake_flac_decode(const uint8_t *input, size_t len,
                                            sleela_pcm_buffer *out) {
    (void)input; (void)len; (void)out;
    g_fake_flac_calls++;
    return SLEELA_CODEC_OK;
}
static const sleela_codec_backend g_fake_flac = { "fake-flac", fake_flac_decode, NULL };

int main(void) {
    sleela_codec_manager *m = sleela_codec_manager_create();
    assert(m != NULL);
    assert(sleela_codec_manager_count(m) == SLEELA_CODEC_COUNT);

    /* Nothing is loaded until asked. */
    assert(sleela_codec_manager_is_loaded(m, SLEELA_CODEC_PCM_WAV) == 0);

    /* --- Load a codec, confirm the loaded flag, double-load is idempotent. */
    assert(sleela_codec_manager_load(m, SLEELA_CODEC_PCM_WAV) == SLEELA_CODEC_OK);
    assert(sleela_codec_manager_is_loaded(m, SLEELA_CODEC_PCM_WAV) == 1);
    assert(sleela_codec_manager_load(m, SLEELA_CODEC_PCM_WAV) == SLEELA_CODEC_OK);

    /* --- Native PCM/WAV round-trip through the manager. */
    sleela_pcm_buffer pcm;
    int16_t src[8] = { 0, 1000, -1000, 32767, -32768, 500, -500, 7 };
    pcm.samples = src; pcm.frame_count = 8; pcm.sample_rate = 44100; pcm.channels = 1;

    size_t need = 0;
    assert(sleela_codec_manager_encode(m, SLEELA_CODEC_PCM_WAV, &pcm, NULL, &need) == SLEELA_CODEC_OK);
    assert(need == 44 + 8 * 2);
    uint8_t *wav = (uint8_t *)malloc(need);
    size_t cap = need;
    assert(sleela_codec_manager_encode(m, SLEELA_CODEC_PCM_WAV, &pcm, wav, &cap) == SLEELA_CODEC_OK);
    assert(memcmp(wav, "RIFF", 4) == 0 && memcmp(wav + 8, "WAVE", 4) == 0);

    sleela_pcm_buffer back;
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_PCM_WAV, wav, cap, &back) == SLEELA_CODEC_OK);
    assert(back.frame_count == 8 && back.channels == 1 && back.sample_rate == 44100);
    for (int i = 0; i < 8; ++i) assert(back.samples[i] == src[i]);  /* lossless */

    /* Probe recognizes the WAV we just wrote (only loaded codecs probe). */
    assert(sleela_codec_manager_resolve_probe(m, wav, cap) == SLEELA_CODEC_PCM_WAV);
    free(wav);

    /* --- Native G.711 mu-law round-trip (companding is lossy but monotone-ish;
     *     just confirm it runs and sizes are right). */
    assert(sleela_codec_manager_load(m, SLEELA_CODEC_G711_MULAW) == SLEELA_CODEC_OK);
    uint8_t ulaw[8]; size_t ucap = sizeof(ulaw);
    assert(sleela_codec_manager_encode(m, SLEELA_CODEC_G711_MULAW, &pcm, ulaw, &ucap) == SLEELA_CODEC_OK);
    assert(ucap == 8);
    sleela_pcm_buffer udec;
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_G711_MULAW, ulaw, 8, &udec) == SLEELA_CODEC_OK);
    assert(udec.frame_count == 8 && udec.channels == 1);

    /* --- Native AIFF round-trip through the manager (big-endian container). */
    assert(sleela_codec_manager_load(m, SLEELA_CODEC_AIFF) == SLEELA_CODEC_OK);
    const sleela_codec_handler *aiff = sleela_codec_manager_describe(m, SLEELA_CODEC_AIFF);
    assert(aiff && aiff->state == SLEELA_CODEC_NATIVE);
    size_t aneed = 0;
    assert(sleela_codec_manager_encode(m, SLEELA_CODEC_AIFF, &pcm, NULL, &aneed) == SLEELA_CODEC_OK);
    uint8_t *aiffbuf = (uint8_t *)malloc(aneed);
    size_t acap = aneed;
    assert(sleela_codec_manager_encode(m, SLEELA_CODEC_AIFF, &pcm, aiffbuf, &acap) == SLEELA_CODEC_OK);
    assert(memcmp(aiffbuf, "FORM", 4) == 0 && memcmp(aiffbuf + 8, "AIFF", 4) == 0);
    sleela_pcm_buffer aback;
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_AIFF, aiffbuf, acap, &aback) == SLEELA_CODEC_OK);
    assert(aback.frame_count == 8 && aback.channels == 1 && aback.sample_rate == 44100);
    for (int i = 0; i < 8; ++i) assert(aback.samples[i] == src[i]);  /* lossless */
    free(aiffbuf);

    /* --- A backend codec: present and resolvable, but decode fails cleanly. */
    const sleela_codec_handler *flac = sleela_codec_manager_describe(m, SLEELA_CODEC_FLAC);
    assert(flac && flac->state == SLEELA_CODEC_BACKEND);
    assert(sleela_codec_manager_resolve_extension(m, ".flac") == SLEELA_CODEC_FLAC);
    assert(sleela_codec_manager_load(m, SLEELA_CODEC_FLAC) == SLEELA_CODEC_OK);
    sleela_pcm_buffer dummy;
    const uint8_t fake[4] = { 'f','L','a','C' };
    /* No backend registered yet -> clean unsupported. */
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_FLAC, fake, 4, &dummy) == SLEELA_CODEC_ERR_UNSUPPORTED);

    /* --- Register a backend adapter and confirm the manager dispatches to it. */
    assert(sleela_codec_backend_register(SLEELA_CODEC_FLAC, &g_fake_flac) == SLEELA_CODEC_OK);
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_FLAC, fake, 4, &dummy) == SLEELA_CODEC_OK);
    assert(g_fake_flac_calls == 1);  /* the adapter's decode ran */
    assert(sleela_codec_backend_register(SLEELA_CODEC_FLAC, NULL) == SLEELA_CODEC_OK); /* clear */
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_FLAC, fake, 4, &dummy) == SLEELA_CODEC_ERR_UNSUPPORTED);

    /* Decoding a NOT-loaded codec returns ERR_STATE, not a crash. */
    assert(sleela_codec_manager_is_loaded(m, SLEELA_CODEC_OPUS) == 0);
    assert(sleela_codec_manager_decode(m, SLEELA_CODEC_OPUS, fake, 4, &dummy) == SLEELA_CODEC_ERR_STATE);

    /* --- Unload and confirm. */
    assert(sleela_codec_manager_unload(m, SLEELA_CODEC_PCM_WAV) == SLEELA_CODEC_OK);
    assert(sleela_codec_manager_is_loaded(m, SLEELA_CODEC_PCM_WAV) == 0);
    assert(sleela_codec_manager_unload(m, SLEELA_CODEC_PCM_WAV) == SLEELA_CODEC_OK); /* idempotent */

    sleela_codec_manager_unload_all(m);
    assert(sleela_codec_manager_is_loaded(m, SLEELA_CODEC_G711_MULAW) == 0);

    sleela_codec_manager_destroy(m);  /* also unloads anything still loaded */
    return 0;
}