WebSVN – Games.Chess Giants – Diff – /audio.cpp

 // structures used in this module only
 typedef struct openal_buffer_s
+{
-   wchar_t pathname[MAX_PATH]; // sound pathname
+   wchar_t *pathname; // sound pathname (mallocated, if NULL then slot is empty)
    ALshort *openal_samples; // OpenAL samples (16-bit mono)
    ALuint openal_buffer; // associated OpenAL buffer ID
+   struct openal_buffer_s *next; // pointer to the next element in list
 } openal_buffer_t;
 typedef struct openal_source_s
+{
 // global variables used in this module only
 static ALCdevice *openal_device;
 static ALCcontext *openal_context;
-static openal_buffer_t *soundbuffers; // mallocated
+static openal_buffer_t *soundbuffers; // mallocated linked list
-static int soundbuffer_count;
 static openal_source_t *sources; // mallocated
 static int source_count;
 bool Audio_Init (void)
+{
    if (!alcMakeContextCurrent (openal_context)) // select this audio context
       return (false);
    soundbuffers = NULL; // we know no soundbuffer yet
-   soundbuffer_count = 0;
    sources = NULL; // we have no playing source yet
    source_count = 0;
    return (true); // audio subsystem successfully initialized
 void Audio_Shutdown (void)
+{
    // this function shuts down the audio subsystem
+   openal_buffer_t *soundbuffer;
+   openal_buffer_t *oldbuffer;
    int array_index;
    ALint status;
    // cycle through all sound sources, stop them if needed and delete them
    for (array_index = 0; array_index < source_count; array_index++)
       alDeleteSources (1, &sources[array_index].openal_source); // and tell OpenAL to dispose of it
       sources[array_index].is_used = false; // mark this source as unused now
+   }
    // cycle through all known sound buffers and delete them
-   for (array_index = 0; array_index < soundbuffer_count; array_index++)
+   soundbuffer = soundbuffers;
+   while (soundbuffer != NULL)
+   {
-      alDeleteBuffers (1, &soundbuffers[array_index].openal_buffer); // tell OpenAL to dispose of this buffer
+      alDeleteBuffers (1, &soundbuffer->openal_buffer); // tell OpenAL to dispose of this buffer
-      SAFE_free ((void **) &soundbuffers[array_index].openal_samples); // free the buffer by our side
+      SAFE_free ((void **) &soundbuffer->openal_samples); // free the buffer by our side
-      soundbuffers[array_index].pathname[0] = 0; // remember this buffer is now empty
+      SAFE_free ((void **) &soundbuffer->pathname); // remember this buffer is now empty
+      oldbuffer = soundbuffer; // save a pointer to the element we just processed
+      soundbuffer = soundbuffer->next; // proceed to the next element in the linked list
+      SAFE_free ((void **) &oldbuffer); // and free the element we just processed
+   }
+   soundbuffers = NULL; // at this point, all elements in the linked list are free
    alcMakeContextCurrent (NULL); // unselect the audio context
    alcDestroyContext (openal_context); // destroy it (only after it's been unselected!)
    alcCloseDevice (openal_device); // and close the audio device
 void Audio_PlaySound (int sound_type, float pos_x, float pos_y, float pos_z)
+{
    // helper function to play a sound
    static wchar_t soundfile_path[MAX_PATH];
-   int soundbuffer_index;
+   openal_buffer_t *soundbuffer;
    buffer_t soundfile;
    unsigned long current_pos;
    uint16_t temp16;
    uint32_t temp32;
    uint32_t blksiz;
       swprintf_s(soundfile_path, WCHAR_SIZEOF(soundfile_path), L"%s/themes/%s/sounds/slide.wav", app_path, theme->name);
       pitch = 1.0f + ((((float)rand()) / RAND_MAX) - 0.5f) / 2.0f; // set a random pitch for these sounds between 0.75 and 1.25
+   }
    // now cycle through our known OpenAL buffers and see if we already know this one
-   for (soundbuffer_index = 0; soundbuffer_index < soundbuffer_count; soundbuffer_index++)
+   for (soundbuffer = soundbuffers; soundbuffer != NULL; soundbuffer = soundbuffer->next)
-      if (wcscmp (soundbuffers[soundbuffer_index].pathname, soundfile_path) == 0)
+      if ((soundbuffer->pathname != NULL) && (wcscmp (soundbuffer->pathname, soundfile_path) == 0))
          break; // break as soon as we find it
    // have we NOT found it ? if so, we must create it
-   if (soundbuffer_index == soundbuffer_count)
+   if (soundbuffer == NULL)
+   {
       // load the sound file
       Buffer_Initialize (&soundfile);
       if (!Buffer_ReadFromFileW (&soundfile, soundfile_path))
          return; // if unable to load this sound file, give up (FIXME: log something ?)
          return; // FIXME: not a wav file
       // compute the total number of samples (number of channels * number of frames)
       sample_count /= sample_size;
-      // reallocate space for one more sound buffer
+      // allocate space for one more sound buffer, and tie it to the linked list
+      if (soundbuffers == NULL)
+      {
-      soundbuffers = (openal_buffer_t *) SAFE_realloc (soundbuffers, soundbuffer_count, soundbuffer_count + 1, sizeof (openal_buffer_t), false);
+         soundbuffers = (openal_buffer_t *) SAFE_malloc (1, sizeof (openal_buffer_t), false); // allocate a new slot to initialize the linked list
+         soundbuffer = soundbuffers; // and set the pointer to the beginning of the list
+      }
+      else
+      {
-      wcscpy_s (soundbuffers[soundbuffer_index].pathname, sizeof (soundbuffers[soundbuffer_index].pathname), soundfile_path); // save this sound's pathname
+         for (soundbuffer = soundbuffers; soundbuffer->next != NULL; soundbuffer = soundbuffer->next); // locate the last slot in the linked list
+         soundbuffer->next = (openal_buffer_t *) SAFE_malloc (1, sizeof (openal_buffer_t), false); // allocate a new slot and tie it there at the same time
+         soundbuffer = soundbuffer->next; // and update the pointer to it
+      }
+      soundbuffer->next = NULL; // this is the last sound buffer in the linked list, do remember it.
+      temp32 = wcslen (soundfile_path) + 1; // compute pathname buffer length (including null terminator)
+      soundbuffer->pathname = (wchar_t *) SAFE_malloc (temp32, sizeof (wchar_t), false); // allocate space for it
+      wcscpy_s (soundbuffer->pathname, temp32, soundfile_path); // and copy this sound's pathname in the newly allocated buffer
       // allocate the samples buffer and fill it, mixing all the WAV channels altogether in a 16-bit mono stream
-      soundbuffers[soundbuffer_index].openal_samples = (ALshort *) SAFE_malloc (sample_count, sizeof (ALshort), false);
+      soundbuffer->openal_samples = (ALshort *) SAFE_malloc (sample_count, sizeof (ALshort), false);
       for (sample_index = 0; sample_index < sample_count; sample_index++)
+      {
          sample_value = 0;
          if (channel_size == 1)
             for (channel_index = 0; channel_index < channel_count; channel_index++)
                sample_value += *((int8_t *) soundfile.data[current_pos + sample_index * sample_size + channel_index * channel_size]);
          else if (channel_size == 2)
             for (channel_index = 0; channel_index < channel_count; channel_index++)
                sample_value += *((int16_t *) &soundfile.data[current_pos + sample_index * sample_size + channel_index * channel_size]);
          sample_value /= channel_count;
-         soundbuffers[soundbuffer_index].openal_samples[sample_index] = (ALshort) sample_value;
+         soundbuffer->openal_samples[sample_index] = (ALshort) sample_value;
+      }
       Buffer_Forget (&soundfile); // we can now forget this sound file
-      alGenBuffers (1, &soundbuffers[soundbuffer_index].openal_buffer); // create an OpenAL sound buffer and fill it with our samples
+      alGenBuffers (1, &soundbuffer->openal_buffer); // create an OpenAL sound buffer and fill it with our samples
-      alBufferData (soundbuffers[soundbuffer_index].openal_buffer, AL_FORMAT_MONO16, soundbuffers[soundbuffer_index].openal_samples, sample_count * sizeof (ALushort), (ALsizei) sample_rate);
+      alBufferData (soundbuffer->openal_buffer, AL_FORMAT_MONO16, soundbuffer->openal_samples, sample_count * sizeof (ALushort), (ALsizei) sample_rate);
       if (alGetError () != AL_NO_ERROR)
          return; // FIXME: couldn't fill OpenAL buffer
-      soundbuffer_count++; // one more sound buffer has been created
+   }
    // now we have a buffer to play
    // cycle through our known OpenAL sources and find a free one
    alSourcef (sources[source_index].openal_source, AL_PITCH, (ALfloat) pitch); // set the source's pitch
    alSourcef (sources[source_index].openal_source, AL_GAIN, 1.0f); // set the source's volume (full)
    alSource3f (sources[source_index].openal_source, AL_POSITION, (ALfloat) pos_x * ATTENUATION_FACTOR, (ALfloat) pos_y * ATTENUATION_FACTOR, (ALfloat) pos_z * ATTENUATION_FACTOR);
    alSource3f (sources[source_index].openal_source, AL_VELOCITY, 0, 0, 0); // set the source's velocity (static)
    alSourcei (sources[source_index].openal_source, AL_LOOPING, AL_FALSE); // set it as non-looping
-   alSourcei (sources[source_index].openal_source, AL_BUFFER, soundbuffers[soundbuffer_index].openal_buffer); // attach our bufferized data to it
+   alSourcei (sources[source_index].openal_source, AL_BUFFER, soundbuffer->openal_buffer); // attach our bufferized data to it
    // play the source! Audio_Think() will dispose of it when it's finished
    alSourcePlay (sources[source_index].openal_source);
    return; // finished

Subversion Repositories Games.Chess Giants

Games.Chess Giants/audio.cpp – Rev 130 → 136