OggVorbis_File Stream;
FILE*          File       = NULL;
ALenum         Format     = 0;
ALsizei        SampleRate = 0;

bool OpenOgg(const std::string& Filename)
{
    // Ouverture du fichier
    File = fopen(Filename.c_str(), "rb");
    if (File)
        return false;

    // On ouvre un flux ogg-vorbis à partir du fichier que l'on vient d'ouvrir
    int Error = ov_open(File, &Stream, NULL, 0);
    if (Error < 0)
        return false;

    // Récupération des informations du son
    vorbis_info* Infos = ov_info(&Stream, -1);
    Format     = Infos->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
    SampleRate = Infos->rate;

    return true;
}

size_t MyReadFunc(void *ptr, size_t size, size_t nmemb, void *datasource);
int    MySeekFunc(void *datasource, ogg_int64_t offset, int whence);
int    MyCloseFunc(void *datasource);
long   MyTellFunc(void *datasource);

ov_callbacks Callbacks =
{
    &MyReadFunc,
    &MySeekFunc,
    &MyCloseFunc,
    &MyTellFunc
};

ov_open_callbacks(Data, &Stream, NULL, 0, Callbacks);

void CloseOgg()
{
    // Fermeture du flux ogg-vorbis
    ov_clear(&Stream);

    // Fermeture du fichier
    fclose(File);
}

void ReadOgg(ALuint Buffer, ALsizei NbSamples)
{
    // Tableau qui va recevoir les échantillons lus
    std::vector<ALshort> Samples(NbSamples);

    // Définition de variables utiles à la lecture
    ALsizei TotalRead  = 0;
    ALsizei TotalSize  = NbSamples * sizeof(ALshort);
    char*   SamplesPtr = reinterpret_cast<char*>(&Samples[0]);

    // Tant qu'on n'a pas atteint la taille voulue, on lit
    while (TotalRead < TotalSize)
    {
        // Lecture des échantillons à partir du flux ogg-vorbis
        ALsizei Read = ov_read(&Stream, SamplesPtr + TotalRead, TotalSize - TotalRead, 0, 2, 1, NULL);

        if (Read > 0)
        {
            // La lecture a réussi, on avance du nombre d'octets lus
            TotalRead += Read;
        }
        else
        {
            // La lecture a échoué, on arrête de lire
            break;
        }
    }

    // Remplissage du tampon avec les données lues
    if (TotalRead > 0)
        alBufferData(Buffer, Format, &Samples[0], TotalRead, SampleRate);
}

// Création des deux tampons OpenAL que nous allons utiliser pour la lecture en flux
ALuint Buffers[2];
alGenBuffers(2, Buffers);

// Création de la source qui jouera le son
ALuint Source;
alGenSources(1, &Source);

// Remplissage des tampons avec le début du son à jouer
ReadOgg(Buffers[0], 44100);
ReadOgg(Buffers[1], 44100);

// On ajoute les 2 tampons à la file de la source
alSourceQueueBuffers(Source, 2, Buffers);

// On peut commencer la lecture
alSourcePlay(Source);

ALint Status;
do
{
    // On récupère le nombre de tampons qui ont été traités (ie. qui sont prêts à être réutilisés)
    ALint NbProcessed;
    alGetSourcei(Source, AL_BUFFERS_PROCESSED, &NbProcessed);

    // On les re-remplit et on les réinjecte dans la file
    for (ALint i = 0; i < NbProcessed; ++i)
    {
        // On sort le tampon de la file
        ALuint Buffer;
        alSourceUnqueueBuffers(Source, 1, &Buffer);

        // On le remplit avec les données du fichier
        ReadOgg(Buffer, 44100);

        // On le réinjecte dans la file
        alSourceQueueBuffers(Source, 1, &Buffer);
    }

    // On récupère l'état de la source
    alGetSourcei(Source, AL_SOURCE_STATE, &Status);
}
while (Status == AL_PLAYING);

// On purge la file de tampons de la source
ALint  NbQueued;
ALuint Buffer;
alGetSourcei(Source, AL_BUFFERS_QUEUED, &NbQueued);
for (ALint i = 0; i < NbQueued; ++i)
    alSourceUnqueueBuffers(Source, 1, &Buffer);
alSourcei(Source, AL_BUFFER, 0);

// On détruit les deux tampons
alDeleteBuffers(2, Buffers);

// On détruit la source
alDeleteSources(1, &Source);