C언어로 객체를 활용한 음악 및 사운드 엔진 설계 방법

#include <stdio.h>
#include <string.h>

// 객체 역할의 구조체
typedef struct {
    char name[50];
    void (*play_sound)(const char*); // 메서드 역할의 함수 포인터
} SoundEngine;

// 메서드 정의
void playSoundImpl(const char* sound) {
    printf("Playing sound: %s\n", sound);
}

// 객체 초기화 함수
void initSoundEngine(SoundEngine* engine, const char* name) {
    strcpy(engine->name, name);
    engine->play_sound = playSoundImpl;
}

int main() {
    SoundEngine engine;
    initSoundEngine(&engine, "Basic Engine");
    printf("Engine Name: %s\n", engine.name);
    engine.play_sound("test.wav"); // 메서드 호출
    return 0;
}

typedef struct {
    void (*play)(void);
} AudioInterface;

typedef struct {
    AudioInterface base;
    const char* sound_name;
} Music;

void playMusic() {
    printf("Playing music...\n");
}

void initMusic(Music* music) {
    music->base.play = playMusic;
    music->sound_name = "Default Music";
}

typedef struct {
    char* filepath;
    int sample_rate;
    int channels;
    void* pcm_data;
} SoundData;

typedef enum {
    SOUND_STOPPED,
    SOUND_PLAYING,
    SOUND_PAUSED
} SoundState;

void mixAudioStreams(int16_t* output, int16_t* stream1, int16_t* stream2, size_t length) {
    for (size_t i = 0; i < length; i++) {
        int32_t mixed = stream1[i] + stream2[i];
        // 클리핑 방지
        if (mixed > INT16_MAX) mixed = INT16_MAX;
        else if (mixed < INT16_MIN) mixed = INT16_MIN;
        output[i] = (int16_t)mixed;
    }
}

typedef struct {
    int16_t* buffer;
    size_t size;
    size_t write_pos;
    size_t read_pos;
} AudioBuffer;

void applyReverb(int16_t* audio, size_t length, float decay) {
    for (size_t i = 1; i < length; i++) {
        audio[i] += (int16_t)(audio[i - 1] * decay);
    }
}

typedef struct {
    char* filepath;
    int16_t* pcm_data;
    size_t size;
} SoundResource;

SoundResource* loadSound(const char* filepath) {
    // 파일 로딩 및 PCM 데이터 변환 로직
    SoundResource* resource = malloc(sizeof(SoundResource));
    resource->filepath = strdup(filepath);
    resource->pcm_data = NULL; // PCM 데이터 로드
    resource->size = 0; // PCM 데이터 크기 설정
    return resource;
}

typedef struct {
    char* key;
    SoundResource* resource;
} HashMapEntry;

typedef struct {
    HashMapEntry* entries;
    size_t capacity;
    size_t size;
} HashMap;

SoundResource* getResource(HashMap* map, const char* key);
void addResource(HashMap* map, const char* key, SoundResource* resource);

typedef struct {
    int16_t* data;
    size_t capacity;
    size_t head;
    size_t tail;
} CircularBuffer;

void writeBuffer(CircularBuffer* buffer, int16_t* data, size_t length);
void readBuffer(CircularBuffer* buffer, int16_t* output, size_t length);

typedef struct {
    SoundResource* resource;
    int ref_count;
} SoundHandle;

void retainSound(SoundHandle* handle) {
    handle->ref_count++;
}

void releaseSound(SoundHandle* handle) {
    if (--handle->ref_count == 0) {
        // 메모리 해제
        free(handle->resource);
        free(handle);
    }
}

#include <pthread.h>
#include <stdio.h>

void* audioProcessing(void* arg) {
    printf("Audio processing thread running.\n");
    return NULL;
}

int main() {
    pthread_t audio_thread;
    pthread_create(&audio_thread, NULL, audioProcessing, NULL);
    pthread_join(audio_thread, NULL);
    return 0;
}

void audioOutputThread(CircularBuffer* buffer) {
    while (1) {
        int16_t output[256];
        readBuffer(buffer, output, 256);
        // 디바이스로 출력
    }
}

#include <pthread.h>

pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;

void writeData(CircularBuffer* buffer, int16_t* data, size_t length) {
    pthread_mutex_lock(&buffer_mutex);
    // 데이터 쓰기
    pthread_mutex_unlock(&buffer_mutex);
}

typedef struct {
    pthread_t* threads;
    size_t thread_count;
} ThreadPool;

void initThreadPool(ThreadPool* pool, size_t thread_count);
void executeTask(ThreadPool* pool, void* (*task)(void*), void* arg);

find_package(OpenAL REQUIRED)
target_link_libraries(MySoundEngine PRIVATE OpenAL::OpenAL)

#include "SDL.h"

void playSound(const char* filepath) {
    if (SDL_Init(SDL_INIT_AUDIO) < 0) {
        printf("Failed to initialize SDL: %s\n", SDL_GetError());
        return;
    }
    SDL_AudioSpec wavSpec;
    Uint32 wavLength;
    Uint8* wavBuffer;
    if (SDL_LoadWAV(filepath, &wavSpec, &wavBuffer, &wavLength) == NULL) {
        printf("Failed to load WAV file: %s\n", SDL_GetError());
        SDL_Quit();
        return;
    }
    SDL_QueueAudio(1, wavBuffer, wavLength);
    SDL_Delay(3000); // 재생 대기
    SDL_FreeWAV(wavBuffer);
    SDL_Quit();
}

typedef enum {
    EVENT_PLAY,
    EVENT_PAUSE,
    EVENT_STOP,
    EVENT_EFFECT_APPLY
} AudioEventType;

typedef struct {
    AudioEventType type;
    void* data; // 이벤트와 관련된 추가 데이터
} AudioEvent;

typedef void (*EventHandler)(AudioEvent*);

typedef struct {
    AudioEventType event_type;
    EventHandler handler;
} EventBinding;

EventBinding bindings[10];
int binding_count = 0;

void registerHandler(AudioEventType type, EventHandler handler) {
    bindings[binding_count++] = (EventBinding){type, handler};
}

void triggerEvent(AudioEvent* event) {
    for (int i = 0; i < binding_count; i++) {
        if (bindings[i].event_type == event->type) {
            bindings[i].handler(event);
        }
    }
}

typedef struct {
    EventBinding bindings[10];
    int binding_count;
} EventDispatcher;

void initDispatcher(EventDispatcher* dispatcher) {
    dispatcher->binding_count = 0;
}

void addListener(EventDispatcher* dispatcher, AudioEventType type, EventHandler handler) {
    dispatcher->bindings[dispatcher->binding_count++] = (EventBinding){type, handler};
}

void dispatchEvent(EventDispatcher* dispatcher, AudioEvent* event) {
    for (int i = 0; i < dispatcher->binding_count; i++) {
        if (dispatcher->bindings[i].event_type == event->type) {
            dispatcher->bindings[i].handler(event);
        }
    }
}

void playEventHandler(AudioEvent* event) {
    printf("Playing sound.\n");
}

int main() {
    EventDispatcher dispatcher;
    initDispatcher(&dispatcher);
    addListener(&dispatcher, EVENT_PLAY, playEventHandler);

    AudioEvent playEvent = {EVENT_PLAY, NULL};
    dispatchEvent(&dispatcher, &playEvent);
    return 0;
}

#ifndef SOUND_ENGINE_H
#define SOUND_ENGINE_H

typedef struct {
    char* filepath;
    void* pcm_data;
    size_t size;
} SoundResource;

typedef struct {
    void (*loadSound)(const char* filepath);
    void (*playSound)(void);
    void (*stopSound)(void);
} SoundEngine;

typedef struct {
    void (*addListener)(int event_type, void (*handler)(void));
    void (*dispatchEvent)(int event_type);
} EventDispatcher;

#endif

#include "SoundEngine.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

SoundResource resource;

void loadSound(const char* filepath) {
    resource.filepath = strdup(filepath);
    resource.pcm_data = NULL; // PCM 데이터 로드 (간소화 처리)
    resource.size = 0;
    printf("Sound loaded: %s\n", filepath);
}

void playSound() {
    if (resource.filepath) {
        printf("Playing sound: %s\n", resource.filepath);
    } else {
        printf("No sound loaded.\n");
    }
}

void stopSound() {
    printf("Sound stopped.\n");
}

SoundEngine createSoundEngine() {
    SoundEngine engine;
    engine.loadSound = loadSound;
    engine.playSound = playSound;
    engine.stopSound = stopSound;
    return engine;
}

#include "SoundEngine.h"
#include <stdio.h>

typedef struct {
    int event_type;
    void (*handler)(void);
} EventBinding;

EventBinding bindings[10];
int binding_count = 0;

void addListener(int event_type, void (*handler)(void)) {
    bindings[binding_count++] = (EventBinding){event_type, handler};
}

void dispatchEvent(int event_type) {
    for (int i = 0; i < binding_count; i++) {
        if (bindings[i].event_type == event_type) {
            bindings[i].handler();
        }
    }
}

EventDispatcher createEventDispatcher() {
    EventDispatcher dispatcher;
    dispatcher.addListener = addListener;
    dispatcher.dispatchEvent = dispatchEvent;
    return dispatcher;
}

#include "SoundEngine.h"
#include <stdio.h>

void onSoundPlay() {
    printf("Event: Sound is playing.\n");
}

int main() {
    // 사운드 엔진 초기화
    SoundEngine engine = createSoundEngine();
    engine.loadSound("test.wav");

    // 이벤트 디스패처 초기화
    EventDispatcher dispatcher = createEventDispatcher();
    dispatcher.addListener(1, onSoundPlay);

    // 사운드 재생 및 이벤트 트리거
    engine.playSound();
    dispatcher.dispatchEvent(1);

    engine.stopSound();
    return 0;
}

Sound loaded: test.wav  
Playing sound: test.wav  
Event: Sound is playing.  
Sound stopped.