SoundInterface.h

Go to the documentation of this file.

// -*- Mode: c++ -*-
/***************************************************************************
    file                 : SoundInterface.h
    created              : Tue Apr 5 19:57:35 CEST 2005
    copyright            : (C) 2005-2024 Christos Dimitrakakis, Bernhard Wymann
    email                : berniw@bluewin.ch

***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SOUND_INTERFACE_H
#define SOUND_INTERFACE_H

#define USE_OPENAL 1

#undef SOUND_LOG


#ifdef SOUND_LOG
#define logmsg printf ("# "); printf
#else
#define logmsg empty_log
static void empty_log(const char* s, ...)
{
}
#endif



#include <plib/sl.h>
#include <plib/sg.h>
#include <raceman.h>
#include <vector>

#include "TorcsSound.h"
//#include "grsound.h"
#include "QSoundChar.h"


#define VOLUME_CUTOFF 0.001f


class CarSoundData;

typedef struct QueueSoundMap_ {
    QSoundChar CarSoundData::*schar; 
    TorcsSound* snd; 
    float max_vol; 
    int id; 
} QueueSoundMap;

enum SoundPriState {
    None=0x0, Loaded, Playing, Paused, Stopped, Cleared
};

typedef struct SoundPri_ {
    float a; 
    int id; 
} SoundPri;

class SoundInterface {
 protected:
    float sampling_rate; 
    int n_channels; 
    int n_engine_sounds; 
    int curCrashSnd; 
    TorcsSound* skid_sound[4]; 
    TorcsSound* road_ride_sound; 
    TorcsSound* grass_ride_sound; 
    TorcsSound* curb_ride_sound; 
    TorcsSound* grass_skid_sound; 
    TorcsSound* metal_skid_sound; 
    TorcsSound* axle_sound; 
    TorcsSound* turbo_sound; 
    TorcsSound* backfire_loop_sound; 
    TorcsSound* crash_sound[NB_CRASH_SOUND]; 
    TorcsSound* bang_sound; 
    TorcsSound* bottom_crash_sound; 
    TorcsSound* backfire_sound; 
    TorcsSound* gear_change_sound; 

    std::vector<TorcsSound*> sound_list; 
    SoundPri* engpri; 

    QueueSoundMap road; 
    QueueSoundMap grass; 
    QueueSoundMap grass_skid;
    QueueSoundMap curb;
    QueueSoundMap metal_skid;
    QueueSoundMap backfire_loop;
    QueueSoundMap turbo;
    QueueSoundMap axle;

    void SortSingleQueue (CarSoundData** car_sound_data, 
                  QueueSoundMap* smap,
                  int n_cars);

    void SetMaxSoundCar(CarSoundData** car_sound_data,
                QueueSoundMap* smap);
    
 public:
    SoundInterface(float sampling_rate, int n_channels);

    virtual ~SoundInterface() {}

    virtual void setNCars(int n_cars) = 0;

    virtual TorcsSound* addSample (const char* filename,
                       int flags = (ACTIVE_VOLUME|ACTIVE_PITCH),
                       bool loop = false, bool static_pool = true) = 0;

    virtual void initSharedSourcePool() {}

    void setSkidSound (const char* sound_name)
    {
        for (int i=0; i<4; i++) {
            TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
            skid_sound[i] = sound;
        }

    }
    void setRoadRideSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        road_ride_sound = sound;
    }
    void setGrassRideSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        grass_ride_sound = sound;
    }
    void setCurbRideSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        curb_ride_sound = sound;
    }
    void setGrassSkidSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        grass_skid_sound = sound;
    }
    void setMetalSkidSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        metal_skid_sound = sound;
    }
    void setAxleSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        axle_sound = sound;
    }
    void setTurboSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        turbo_sound = sound;
    }
    void setBackfireLoopSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, ACTIVE_VOLUME|ACTIVE_PITCH, true);
        backfire_loop_sound = sound;
    }
    void setCrashSound (const char* sound_name, int index)
    {
        TorcsSound* sound = addSample (sound_name, 0, false);
        assert (index>=0 && index<NB_CRASH_SOUND);
        crash_sound[index] = sound;
    }

    void setBangSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, 0, false);
        bang_sound = sound;
    }

    void setBottomCrashSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, 0, false);
        bottom_crash_sound = sound;
    }

    void setBackfireSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, 0, false);
        backfire_sound = sound;
    }

    void setGearChangeSound (const char* sound_name)
    {
        TorcsSound* sound = addSample (sound_name, 0, false);
        gear_change_sound = sound;
    }
    virtual void update(CarSoundData** car_sound_data,
                int n_cars, sgVec3 p_obs, sgVec3 u_obs, 
                sgVec3 c_obs = NULL, sgVec3 a_obs = NULL)
    {
        // do nothing
    }

    virtual void muteForMenu() {}
    virtual float getGlobalGain() {return 1.0f;}
    virtual void setGlobalGain(float g) 
    {
        fprintf (stderr, "Warning, gain setting not supported\n");
    }

};



class PlibSoundInterface : public SoundInterface {
    typedef struct SoundChar_ {
        float f; //frequency modulation
        float a; //amplitude modulation
    } SoundChar;
 protected:
    slScheduler* sched;
    std::vector<TorcsSound*> sound_list;
    SoundPri* engpri;
    SoundSource* car_src;
    SoundSource tyre_src[4];
    void DopplerShift (SoundChar* sound, float* p_src, float* u_src, float* p, float* u);
    void SetMaxSoundCar(CarSoundData** car_sound_data, QueueSoundMap* smap);
    float global_gain;
 public:
    PlibSoundInterface(float sampling_rate, int n_channels);
    virtual ~PlibSoundInterface();
    virtual void setNCars(int n_cars);
    virtual slScheduler* getScheduler();
    virtual TorcsSound* addSample (const char* filename, int flags = (ACTIVE_VOLUME|ACTIVE_PITCH), bool loop = false, bool static_pool = true);
    virtual void update(CarSoundData** car_sound_data, int n_cars, sgVec3 p_obs, sgVec3 u_obs, sgVec3 c_obs = NULL, sgVec3 a_obs = NULL);
    virtual float getGlobalGain() {return global_gain;}
    virtual void setGlobalGain(float g)
    {
        global_gain = 0.5f*g;
        logmsg ("Setting gain to %f\n", global_gain);
    }

};




class SharedSourcePool;

class OpenalSoundInterface : public SoundInterface {
    typedef struct SoundChar_ {
        float f; //frequency modulation
        float a; //amplitude modulation
    } SoundChar;
 protected:
    SoundSource* car_src;
    SoundSource tyre_src[4];
    ALCcontext* cc;
    ALCdevice* dev;
    float global_gain;
    int OSI_MAX_BUFFERS;
    int OSI_MAX_SOURCES;
    int OSI_MAX_STATIC_SOURCES;
    int n_static_sources_in_use;
    SharedSourcePool* sourcepool;
    static const int OSI_MIN_DYNAMIC_SOURCES;

    void DopplerShift (SoundChar* sound, float* p_src, float* u_src, float* p, float* u);
    virtual void SetMaxSoundCar(CarSoundData** car_sound_data, QueueSoundMap* smap);

 public:
    OpenalSoundInterface(float sampling_rate, int n_channels);
    virtual ~OpenalSoundInterface();
    virtual void setNCars(int n_cars);
    virtual TorcsSound* addSample (const char* filename,
                       int flags = (ACTIVE_VOLUME|ACTIVE_PITCH),
                       bool loop = false, bool static_pool = true);
    virtual void update(CarSoundData** car_sound_data, int n_cars, sgVec3 p_obs, sgVec3 u_obs, sgVec3 c_obs, sgVec3 a_obs);
    virtual void muteForMenu();
    virtual float getGlobalGain() { return global_gain; }
    virtual void initSharedSourcePool();
    virtual void setGlobalGain(float g)
    {
        global_gain = 0.5f*g;
        logmsg ("Setting gain to %f\n", global_gain);
    }
    virtual bool getStaticSource(ALuint *source);

    virtual SharedSourcePool* getSourcePool(void) { return sourcepool; } 


};


int sortSndPriority(const void* a, const void* b);


struct sharedSource {
    ALuint source;
    TorcsSound* currentOwner;
    bool in_use;
};


class SharedSourcePool {
    public:
        SharedSourcePool(int nbsources):nbsources(nbsources) {
            pool = new sharedSource[nbsources];
            int i;
            for (i = 0; i < nbsources; i++) {
                pool[i].currentOwner = NULL;
                pool[i].in_use = false;
                alGenSources(1, &(pool[i].source));
                int error = alGetError();
                if (error != AL_NO_ERROR) {
                    printf("OpenAL error, allocating dynamic source index %d\n", i);
                    this->nbsources = i;
                    break;
                }
            }
            printf("  Dynamic Sources: requested: %d, created: %d\n", nbsources, this->nbsources);
        }
        
        virtual ~SharedSourcePool() {
            int i;
            for (i = 0; i < nbsources; i++) {
                alDeleteSources(1, &(pool[i].source));
                alGetError();
            }           
            delete [] pool;
        }

        bool getSource(TorcsSound* sound, ALuint* source, bool* needs_init, int* index) {
            if (*index >= 0 && *index < nbsources) {
                if (sound == pool[*index].currentOwner) {
                    // Resurrect source from pool.
                    *source = pool[*index].source;
                    *needs_init = false;
                    pool[*index].in_use = true;
                    return true;
                }
            }
            
            // TODO: Implement free list with ring buffer or whatever data structure
            // to go from O(n) to O(1). If the ordering is done well it will automatically
            // result in LRU (least recently used).
            int i, firstfree = -1;
            for (i = 0; i < nbsources; i++) {
                if (pool[i].in_use == false && firstfree < 0) {
                    firstfree = i;
                    break;
                }
            }
            
            if (firstfree < 0) {
                // No free source.
                return false;
            }

            pool[firstfree].currentOwner = sound;
            pool[firstfree].in_use = true;
            *source = pool[firstfree].source;
            *needs_init = true;
            *index = firstfree;
            return true;
        }

        bool releaseSource(TorcsSound* sound, int* index) {
            if (*index >= 0 && *index < nbsources) {
                if (sound == pool[*index].currentOwner) {
                    pool[*index].in_use = false;
                    return true;
                }
            }
            return false;
        }

        bool isSourceActive(TorcsSound* sound, int* index) {
            if (*index >= 0 && *index < nbsources &&
                sound == pool[*index].currentOwner &&
                true == pool[*index].in_use)
            {
                return true;
            } else {
                return false;
            }
        }

        int getNbSources(void) { return nbsources; }

    protected:
        int nbsources;
        sharedSource *pool;
};



#endif /* SOUND_INTERFACE_H */