Usando a API Simple DirectMedia Layer

• Abrindo o dispositivo de áudio

Você precisa ter uma função de callback que, mixando os seus dados de áudio,os coloque no fluxo  de áudio.Depois disso, escolha seu formato de áudio e razão desejados e abra o dispositivo de áudio.

O Áudio  não vai ter sua execução iniciada enquanto você não chamar SDL_PauseAudio(0), permitindo a você realizar outras inicializacoes de áudio, ,conforme foi necessário antes de sua função callback ser executada. Depois que você terminar de usar a saída de áudio, você deve fecha-la com a função SDL_CloseAudio().

#include "SDL.h"
#include "SDL_audio.h"
{
    extern void mixaudio(void *unused, Uint8 *stream, int len);
    SDL_AudioSpec fmt;

    /* ajusta para áudio em  16-bit stereo com 22Khz */
    fmt.freq = 22050;
    fmt.format = AUDIO_S16;
    fmt.channels = 2;
    fmt.samples = 512;        /* um bom valor para jogos */
    fmt.callback = mixaudio;
    fmt.userdata = NULL;

/* Abre o dispositivo de áudio e começa a executar som! */
    if ( SDL_OpenAudio(&fmt, NULL) < 0 ) {
        fprintf(stderr, "impossível abrir o áudio: %s\n", SDL_GetError());
        exit(1);
    }
    SDL_PauseAudio(0);

    ...

    SDL_CloseAudio();
}

• Carregando e executando sons

SDL prove uma única rotina de carregamento de sons para sua conveniência, SDL_LoadWAV().Depois de carregar seus sons , você deve converte-los para o formato de áudio da saída de som usando SDL_ConvertAudio(), e faze-los disponíveis para suas funções de mixagem.

As instalações de áudio do SDL são desenhadas para uma mixagem de áudio em software em baixo nível. Um exemplo implementação de mixagem ,disponível sob a licença  LGPL pode ser encontrado no arquivo de demos do SDL.

#define NUM_SOUNDS 2
struct sample {
    Uint8 *data;
    Uint32 dpos;
    Uint32 dlen;
} sounds[NUM_SOUNDS];

void mixaudio(void *unused, Uint8 *stream, int len)
{
    int i;
    Uint32 amount;

    for ( i=0; i<NUM_SOUNDS; ++i ) {
        amount = (sounds[i].dlen-sounds[i].dpos);
        if ( amount > len ) {
            amount = len;
        }
        SDL_MixAudio(stream, &sounds[i].data[sounds[i].dpos], amount, SDL_MIX_MAXVOLUME);
        sounds[i].dpos += amount;
    }
}

void PlaySound(char *file)
{
    int index;
    SDL_AudioSpec wave;
    Uint8 *data;
    Uint32 dlen;
    SDL_AudioCVT cvt;

    /* procura por um slot de som vago (ou finalizado) */
    for ( index=0; index<NUM_SOUNDS; ++index ) {
        if ( sounds[index].dpos == sounds[index].dlen ) {
            break;
        }
    }
    if ( index == NUM_SOUNDS )
        return;

/* carrega o arquivo de som e o converte para 16-bit stereo com 22Khz*/
    if ( SDL_LoadWAV(file, &wave, &data, &dlen) == NULL ) {
        fprintf(stderr, "Não foi possível carregar %s: %s\n", file, SDL_GetError());
        return;
    }
    SDL_BuildAudioCVT(&cvt, wave.format, wave.channels, wave.freq,
                            AUDIO_S16,   2,             22050);
    cvt.buf = malloc(dlen*cvt.len_mult);
    memcpy(cvt.buf, data, dlen);
    cvt.len = dlen;
    SDL_ConvertAudio(&cvt);
    SDL_FreeWAV(data);

/* Coloca os dados de som no slot (ele começa a tocar imediatamente) */
    if ( sounds[index].data ) {
        free(sounds[index].data);
    }
    SDL_LockAudio();
    sounds[index].data = cvt.buf;
    sounds[index].dlen = cvt.len_cvt;
    sounds[index].dpos = 0;
    SDL_UnlockAudio();
}