dmusic.h

// Copyright © 2024. GothicKit Contributors
// SPDX-License-Identifier: MIT-Modern-Variant
#pragma once
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
    #define DM_EXTERN extern "C"
#else
    #define DM_EXTERN
#endif
 
#if defined(_WIN32) || defined(__CYGWIN__)
    #ifdef DM_BUILD
        #ifdef __GNUC__
            #define DMAPI DM_EXTERN __attribute__((dllexport))
        #else
            #define DMAPI DM_EXTERN __declspec(dllexport)
        #endif
    #else
        #ifdef __GNUC__
            #define DMAPI DM_EXTERN __attribute__((dllimport))
        #else
            #define DMAPI DM_EXTERN __declspec(dllimport)
        #endif
    #endif
    #define DMINT
#else
    #define DMAPI DM_EXTERN __attribute__((visibility("default")))
    #define DMINT DM_EXTERN __attribute__((visibility("hidden")))
#endif
 
 
typedef enum DmResult {
    DmResult_SUCCESS = 0,
 
    DmResult_INVALID_ARGUMENT,
 
    DmResult_INVALID_STATE,
 
    DmResult_MEMORY_EXHAUSTED,
 
    DmResult_NOT_FOUND,
 
    DmResult_FILE_CORRUPT,
 
    DmResult_MUTEX_ERROR,
} DmResult;
 
typedef struct DmGuid {
    uint8_t data[16];
} DmGuid;
 
DMAPI size_t DmGuid_toString(DmGuid const* slf, char* out, size_t len);
 
typedef void* DmMemoryAlloc(void* ctx, size_t len);
 
typedef void DmMemoryFree(void* ctx, void* ptr);
 
DMAPI DmResult Dm_setHeapAllocator(DmMemoryAlloc* alloc, DmMemoryFree* free, void* ctx);
 
typedef uint32_t DmRng(void* ctx);
 
DMAPI void Dm_setRandomNumberGenerator(DmRng* rng, void* ctx);
 
typedef enum DmLogLevel {
    DmLogLevel_FATAL = 10,
 
    DmLogLevel_ERROR = 20,
 
    DmLogLevel_WARN = 30,
 
    DmLogLevel_INFO = 40,
 
    DmLogLevel_DEBUG = 50,
 
    DmLogLevel_TRACE = 60,
} DmLogLevel;
 
typedef void DmLogHandler(void* ctx, DmLogLevel lvl, char const* msg);
 
DMAPI void Dm_setLogger(DmLogLevel lvl, DmLogHandler* log, void* ctx);
 
DMAPI void Dm_setLoggerDefault(DmLogLevel lvl);
 
DMAPI void Dm_setLoggerLevel(DmLogLevel lvl);
 
 
 
typedef struct DmSegment DmSegment;
 
 
typedef struct DmLoader DmLoader;
 
 
typedef struct DmPerformance DmPerformance;
 
 
DMAPI DmSegment* DmSegment_retain(DmSegment* slf);
 
DMAPI void DmSegment_release(DmSegment* slf);
 
DMAPI DmResult DmSegment_download(DmSegment* slf, DmLoader* loader);
 
DMAPI DmGuid const* DmSegment_getGuid(DmSegment const* slf);
 
DMAPI char const* DmSegment_getName(DmSegment const* slf);
 
DMAPI double DmSegment_getLength(DmSegment const* slf);
 
DMAPI uint32_t DmSegment_getRepeats(DmSegment const* slf);
 
 
 
typedef enum DmLoaderOptions {
    DmLoader_DOWNLOAD = 1U << 0U,
 
    DmLoader_DEFAULT = 0U,
} DmLoaderOptions;
 
typedef void* DmLoaderResolverCallback(void* ctx, char const* file, size_t* len);
 
DMAPI DmResult DmLoader_create(DmLoader** slf, DmLoaderOptions opt);
 
DMAPI DmLoader* DmLoader_retain(DmLoader* slf);
 
DMAPI void DmLoader_release(DmLoader* slf);
 
DMAPI DmResult DmLoader_addResolver(DmLoader* slf, DmLoaderResolverCallback* resolve, void* ctx);
 
DMAPI DmResult DmLoader_getSegment(DmLoader* slf, char const* name, DmSegment** segment);
 
 
 
typedef enum DmRenderOptions {
    DmRender_SHORT = 1 << 0,
 
    DmRender_FLOAT = 1 << 1,
 
    DmRender_STEREO = 1 << 2,
} DmRenderOptions;
 
typedef enum DmTiming {
    DmTiming_INSTANT = 1,
 
    DmTiming_GRID = 2,
 
    DmTiming_BEAT = 3,
 
    DmTiming_MEASURE = 4,
} DmTiming;
 
typedef enum DmEmbellishmentType {
    DmEmbellishment_NONE = 0,
 
    DmEmbellishment_GROOVE = 1,
 
    DmEmbellishment_FILL = 2,
 
    DmEmbellishment_INTRO = 3,
 
    DmEmbellishment_BREAK = 4,
 
    DmEmbellishment_END = 5,
 
    DmEmbellishment_END_AND_INTRO = 6,
} DmEmbellishmentType;
 
DMAPI DmResult DmPerformance_create(DmPerformance** slf, uint32_t rate);
 
DMAPI DmPerformance* DmPerformance_retain(DmPerformance* slf);
 
DMAPI void DmPerformance_release(DmPerformance* slf);
 
DMAPI DmResult DmPerformance_playSegment(DmPerformance* slf, DmSegment* sgt, DmTiming timing);
 
DMAPI DmResult DmPerformance_playTransition(DmPerformance* slf,
                                            DmSegment* sgt,
                                            DmEmbellishmentType embellishment,
                                            DmTiming timing);
 
DMAPI DmResult DmPerformance_renderPcm(DmPerformance* slf, void* buf, size_t num, DmRenderOptions opts);
 
DMAPI void DmPerformance_setVolume(DmPerformance* slf, float vol);