Fix openal NaCl port.

libraries/openal-soft/nacl-openal-soft.patch

 diff -Naur openal-soft-1.13/Alc/ALc.c openal-soft-1.13-nacl/Alc/ALc.c
 --- openal-soft-1.13/Alc/ALc.c  2011-02-09 11:52:19.000000000 -0800
 +++ openal-soft-1.13-nacl/Alc/ALc.c     2012-01-23 15:45:38.000000000 -0800
 @@ -23,7 +23,7 @@
  #include <math.h>
  #include <stdlib.h>
  #include <stdio.h>
 -#include <memory.h>
 +#include <string.h>
  #include <ctype.h>
  
  #include "alMain.h"
 @@ -69,7 +69,9 @@
  #ifdef HAVE_PORTAUDIO
      { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },
  #endif
 -
 +#ifdef HAVE_PPAPI
 +    { "ppapi", alc_ppapi_init, alc_ppapi_deinit, alc_ppapi_probe, EmptyFuncs },
 +#endif
      { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },
  #ifdef HAVE_WAVE
      { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },
-diff -Naur openal-soft-1.13/Alc/ppapi.c openal-soft-1.13-nacl/Alc/ppapi.c
+diff -Naur openal-soft-1.13/Alc/ppapi.c openal-soft-1.13.nacl/Alc/ppapi.c
 --- openal-soft-1.13/Alc/ppapi.c        1969-12-31 16:00:00.000000000 -0800
-+++ openal-soft-1.13-nacl/Alc/ppapi.c   2012-01-23 15:46:21.000000000 -0800
-@@ -0,0 +1,411 @@
++++ openal-soft-1.13.nacl/Alc/ppapi.c   2013-01-30 13:53:29.840835797 -0800
+@@ -0,0 +1,458 @@
 +/**
 + * OpenAL cross platform audio library
 + * Copyright (C) 2012
 + * This library is free software; you can redistribute it and/or
 + *  modify it under the terms of the GNU Library General Public
 + *  License as published by the Free Software Foundation; either
 + *  version 2 of the License, or (at your option) any later version.
 + *
 + * This library is distributed in the hope that it will be useful,
 + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 17 matching lines @@
 +#include "ppapi/c/pp_completion_callback.h"
 +#include "ppapi/c/pp_instance.h"
 +#include "ppapi/c/ppb.h"
 +#include "ppapi/c/ppb_audio.h"
 +#include "ppapi/c/ppb_audio_config.h"
 +#include "ppapi/c/ppb_core.h"
 +
 +/* The output buffer will be this multiple of the OpenAL device update size.
 + * This needs to be at least 2 or we can't buffer output properly.
 + */
-+const ALuint kBufferPadMult = 4;
++const ALuint kBufferPadMult = 3;
++
 +/* How many samples for each frame will be buffered to Pepper.
 + * Keep this low for low latency, but not too low or we will be CPU bound.
 + */
 +const ALuint kRequestedFrameCount = 1024;
 +/* 4 is 2-channels, 2-bytes per sample. */
 +const ALuint kFrameSizeInBytes = 4;
 +
 +typedef struct {
 +    /* Simple circular buffer (single producer/consumer) to buffer data output
 +     * from OpenAL before it's handed off to PPAPI.
 +     */
 +    ALvoid *buffer;
 +    ALuint size;
 +
 +    PPB_AudioConfig* audio_config;
 +    PPB_Audio* audio;
 +    PPB_Core* core;
 +
 +    PP_Resource audio_config_resource;
 +    PP_Resource audio_resource;
 +    ALuint sample_frame_count;
-+    
++
 +    volatile ALuint read_ptr;
 +    volatile ALuint write_ptr;
++    pthread_mutex_t mutex;
++    pthread_cond_t cond;
 +
 +    ALCdevice *device;
 +
-+    volatile int killNow;
++    int killNow;
 +    ALvoid *thread;
 +    volatile ALuint main_thread_init_status;
 +    ALuint buffer_ready;
 +} ppapi_data;
 +
 +static PP_Instance gInstance;
 +static PPB_GetInterface gGetInterface;
 +
 +AL_API void AL_APIENTRY alSetPpapiInfo(PP_Instance instance, PPB_GetInterface get_interface)
 +{
 +    gInstance = instance;
 +    gGetInterface = get_interface;
 +}
 +
 +/* This is the callback from PPAPI to fill in the audio buffer. */
-+void PPAPI_Audio_Callback(void *sample_buffer,
++static void PPAPI_Audio_Callback(void *sample_buffer,
 +                          uint32_t buffer_size_in_bytes,
 +                          void* user_data)
 +{
 +    ppapi_data* data = (ppapi_data*)user_data;
 +    if (!data->buffer_ready) return;
 +
 +    ALuint write_proxy = data->write_ptr;
 +    if (data->read_ptr > data->write_ptr)
 +        write_proxy = data->write_ptr + data->size;
 +
-+    if (data->read_ptr + buffer_size_in_bytes > write_proxy)
++    int available_bytes = write_proxy - data->read_ptr;
++    if (available_bytes < buffer_size_in_bytes)
 +    {
-+        AL_PRINT("buffer underrun\n");
-+        return;
++        AL_PRINT("buffer underrun (buffer size=%d) (only buffering %d)\n", buffer_size_in_bytes, available_bytes);
++        buffer_size_in_bytes = available_bytes;

[elijahtaylor1, 2013/01/31 00:32:24]

If you're going to fill in part of the buffer, you might want to zero out the
rest?

[Sam Clegg, 2013/01/31 17:13:45]

Done.

 +    }
 +
 +    if (data->read_ptr + buffer_size_in_bytes > data->size)
 +    {
 +        /* This read straddles the buffer boundary, split it up. */
 +        memcpy(sample_buffer,
 +               data->buffer + data->read_ptr,
 +               data->size - data->read_ptr);
 +        memcpy(sample_buffer + (data->size - data->read_ptr),
 +               data->buffer,
 +               buffer_size_in_bytes - (data->size - data->read_ptr));
 +    }
 +    else
 +    {
 +        memcpy(sample_buffer,
 +               data->buffer + data->read_ptr,
 +               buffer_size_in_bytes);
 +    }
 +
++    pthread_mutex_lock(&data->mutex);
 +    data->read_ptr += buffer_size_in_bytes;
++    // wrap read_ptr in circular buffer;
 +    if (data->read_ptr >= data->size)
 +        data->read_ptr -= data->size;
++    pthread_cond_signal(&data->cond);
++    pthread_mutex_unlock(&data->mutex);

[nfullagar1, 2013/01/30 22:19:31]

Putting locks in the audio callback is usually not recommended.  If the lock is
held elsewhere, the scheduler might swap this thread out, and the deadline for
this callback might be missed, causing a glitch in low latency buffers.  Even
through this lock is taken at the end (after data has been copied) it still
might glitch depending on thread quantum and when the next callback needs to
fire.  A lock-free solution would be preferable, see gcc's __sync_schronize
intrinsic as a possible workaround to updating the read_ptr without using a
pthread mutex.

[Sam Clegg, 2013/01/31 17:13:45]

Removed the pthread stuff from this change.

 +}
 +
 +static const ALCchar ppapiDevice[] = "PPAPI Output";
 +
 +static ALuint PpapiProc(ALvoid *ptr)
 +{
 +    ALCdevice *Device = (ALCdevice*)ptr;
 +    ppapi_data *data = (ppapi_data*)Device->ExtraData;
 +
 +    ALuint UpdateSizeInBytes = Device->UpdateSize * kFrameSizeInBytes;
 +    ALuint SampleFrameInBytes = data->sample_frame_count * kFrameSizeInBytes;
++
 +    /* Start to buffer when less than this many bytes are buffered. Keep this
 +     * small for low latency but large enough so we don't starve Pepper.
++     *
++     * SampleFrameInBytes is the size of the buffer that PPAPI asks for each
++     * callback.  We want to keep twice this amount in the buffer at any given
++     * time.
 +     */
-+    const ALuint MinBufferSizeInBytes =
-+        min(max(SampleFrameInBytes*4, UpdateSizeInBytes), data->size/2);
++    const ALuint MinBufferSizeInBytes = max(SampleFrameInBytes,

[elijahtaylor1, 2013/01/31 00:32:24]

Did you mean (SampleFrameInBytes*2, UpdateSizeInBytes)?

[Sam Clegg, 2013/01/31 17:13:45]

Done.

++                                            UpdateSizeInBytes*2);
 +
-+    while(!data->killNow && Device->Connected)
++    pthread_mutex_lock(&data->mutex);
++    while (!data->killNow && Device->Connected)
 +    {
 +        ALuint write_proxy = data->write_ptr;
++
 +        if (data->read_ptr > data->write_ptr)
 +            write_proxy = data->write_ptr + data->size;
 +
-+        if (data->read_ptr + MinBufferSizeInBytes >= write_proxy)
++        ALuint bytes_in_buffer = write_proxy - data->read_ptr;
++        if (bytes_in_buffer < MinBufferSizeInBytes)
 +        {
-+            aluMixData(Device,
-+                       data->buffer + data->write_ptr,
-+                       Device->UpdateSize);
-+            if (data->write_ptr + UpdateSizeInBytes > data->size)
++            // Time to buffer more data
++            pthread_mutex_unlock(&data->mutex);
++
++            // Mix samples into buffer in UpdateSizeInBytes chunks
++            // untill there are more then MinBufferSizeInBytes available.

[elijahtaylor1, 2013/01/31 00:32:24]

until

than

[Sam Clegg, 2013/01/31 17:13:45]

Reverted this stuff until we can find a non-busy solution
that we like.

++            while (bytes_in_buffer < MinBufferSizeInBytes)
 +            {
-+                /* Spilled over the edge, copy the last bits to the beginning
-+                 * of the buffer.
-+                 */
-+                memcpy(data->buffer,
-+                       data->buffer + data->size,
-+                       UpdateSizeInBytes - (data->size - data->write_ptr));
++                aluMixData(Device,
++                           data->buffer + data->write_ptr,
++                           Device->UpdateSize);
++                if (data->write_ptr + UpdateSizeInBytes > data->size)
++                {
++                    /* Spilled over the edge, copy the last bits to the beginning

[elijahtaylor1, 2013/01/31 00:32:24]

80 cols.  I know it's annoying because there might be 2 extra chars because it's
a patch

[Sam Clegg, 2013/01/31 17:13:45]

Reverted this stuff until we can find a non-busy solution
that we like.

++                     * of the buffer.
++                     */
++                    memcpy(data->buffer,
++                           data->buffer + data->size,
++                           UpdateSizeInBytes - (data->size - data->write_ptr));
++                }
++
++                data->write_ptr += UpdateSizeInBytes;
++                if (data->write_ptr >= data->size)
++                    data->write_ptr -= data->size;
++
++                bytes_in_buffer += UpdateSizeInBytes;
 +            }
 +
-+            data->write_ptr += UpdateSizeInBytes;
-+            if (data->write_ptr >= data->size)
-+                data->write_ptr -= data->size;
++            pthread_mutex_lock(&data->mutex);
 +        }
-+        /* Small 1 ms sleep so we don't use too much CPU time. */
-+        Sleep(1);
++        else
++        {
++            // The first time we finished buffering we trigger the reader to
++            // start reading
++            if (!data->buffer_ready)
++            {
++                data->buffer_ready = 1;
++            }
++
++            // Wait for reader to read more data
++            pthread_cond_wait(&data->cond, &data->mutex);
++        }
 +    }
++    pthread_mutex_unlock(&data->mutex);
 +
 +    return 0;
 +}
 +
 +/* This needs to be called on the main PPAPI thread. */
 +static void ppapi_open_playback_main_thread(void* user_data, int32_t result)
 +{
 +    ppapi_data *data = (ppapi_data*)user_data;
 +    (void)result;
 +
 +    PP_AudioSampleRate rate = PP_AUDIOSAMPLERATE_44100;
 +    if (data->device->Frequency == 48000)
 +        rate = PP_AUDIOSAMPLERATE_48000;
 +
 +    data->sample_frame_count =
 +        data->audio_config->RecommendSampleFrameCount(
 +#ifdef PPB_AUDIO_CONFIG_INTERFACE_1_1
 +                                                      gInstance,
 +#endif
 +                                                      rate,
 +                                                      kRequestedFrameCount);
 +
++    //AL_PRINT("recommend frames: %d (rate=%d) (size=%d)\n", data->sample_frame_count, rate, data->sample_frame_count*2*2);
 +    data->audio_config_resource =
 +        data->audio_config->CreateStereo16Bit(gInstance,
 +                                              rate,
 +                                              data->sample_frame_count);
 +
 +    if (PP_FALSE == data->audio_config->IsAudioConfig(data->audio_config_resource)) {
-+        AL_PRINT("PPAPI initialization: audio config creation failed."); 
++        AL_PRINT("PPAPI initialization: audio config creation failed.");
 +        data->main_thread_init_status = -1;
 +        return;
 +    }
 +
 +    data->audio_resource = data->audio->Create(gInstance,
 +                                               data->audio_config_resource,
 +                                               PPAPI_Audio_Callback,
 +                                               (void*)data);
 +
 +    if (PP_FALSE == data->audio->IsAudio(data->audio_resource)) {
-+        AL_PRINT("PPAPI initialization: audio resource creation failed."); 
++        AL_PRINT("PPAPI initialization: audio resource creation failed.");
 +        data->main_thread_init_status = -1;
 +        return;
 +    }
 +
 +    if (PP_FALSE == data->audio->StartPlayback(data->audio_resource)) {
-+        AL_PRINT("PPAPI initialization: start playback failed."); 
++        AL_PRINT("PPAPI initialization: start playback failed.");
 +        data->main_thread_init_status = -1;
 +        return;
 +    }
 +
 +    data->main_thread_init_status = 1;
 +}
 +
 +static ALCboolean ppapi_open_playback(ALCdevice *device,
 +                                      const ALCchar *deviceName)
 +{
 +    ppapi_data *data;
 +
-+    if(!deviceName)
++    if (!deviceName)
 +        deviceName = ppapiDevice;
-+    else if(strcmp(deviceName, ppapiDevice) != 0)
++    else if (strcmp(deviceName, ppapiDevice) != 0)
 +        return ALC_FALSE;
 +
 +    int channels = ChannelsFromDevFmt(device->FmtChans);
 +    int bytes = BytesFromDevFmt(device->FmtType);
 +
 +    if (channels != 2)
 +    {
 +        AL_PRINT("PPAPI only supports 2 channel output\n");
 +        return ALC_FALSE;
 +    }
 +    if (bytes != 2)
 +    {
 +        AL_PRINT("PPAPI only supports 16-bit output\n");
 +        return ALC_FALSE;
 +    }
 +    if (device->Frequency != 44100 && device->Frequency != 44800)
 +    {
 +        AL_PRINT("PPAPI only supports 44100 and 44800 sample frequencies\n");
 +        return ALC_FALSE;
 +    }
 +
 +    data = (ppapi_data*)calloc(1, sizeof(*data));
++    pthread_mutex_init(&data->mutex, NULL);
++    pthread_cond_init(&data->cond, NULL);
 +
 +    device->szDeviceName = strdup(deviceName);
 +    device->ExtraData = data;
 +    data->device = device;
 +
 +    data->audio_config =
 +        (PPB_AudioConfig*)gGetInterface(PPB_AUDIO_CONFIG_INTERFACE);
 +    if (!data->audio_config)
 +    {
 +        free(data);
@@ skipping 62 matching lines @@
 +    }
 +
 +    device->ExtraData = NULL;
 +}
 +
 +static ALCboolean ppapi_reset_playback(ALCdevice *device)
 +{
 +    ppapi_data *data = (ppapi_data*)device->ExtraData;
 +
 +    ALuint UpdateSizeInBytes = device->UpdateSize * kFrameSizeInBytes;
++    ALuint SampleFrameInBytes = data->sample_frame_count * kFrameSizeInBytes;
 +    /* kBufferPadMult is added to protect against buffer underruns. */
-+    data->size = UpdateSizeInBytes * kBufferPadMult;
++    data->size = max(UpdateSizeInBytes, SampleFrameInBytes) * kBufferPadMult;
++
 +    /* Extra UpdateSize added so we can read off the end of the buffer in one
 +     * shot from aluMixData, but treat the buffer like it's of size data->size.
 +     */
 +    data->buffer = calloc(1, data->size + UpdateSizeInBytes);
-+    if(!data->buffer)
++    if (!data->buffer)
 +    {
 +        AL_PRINT("buffer malloc failed\n");
 +        return ALC_FALSE;
 +    }
 +    SetDefaultWFXChannelOrder(device);
 +
 +    data->read_ptr = 0;
 +    data->write_ptr = 0;
 +    data->thread = StartThread(PpapiProc, device);
-+    if(data->thread == NULL)
++    if (data->thread == NULL)
 +    {
 +        free(data->buffer);
 +        data->buffer = NULL;
 +        return ALC_FALSE;
 +    }
-+    data->buffer_ready = 1;
 +    return ALC_TRUE;
 +}
 +
 +static void ppapi_stop_playback(ALCdevice *device)
 +{
 +    ppapi_data *data = (ppapi_data*)device->ExtraData;
 +
-+    if(!data->thread)
++    if (!data->thread)
 +        return;
 +
++    // Signal thread to die
++    pthread_mutex_lock(&data->mutex);
 +    data->killNow = 1;
++    pthread_cond_signal(&data->cond);
++    pthread_mutex_unlock(&data->mutex);
++
 +    StopThread(data->thread);
++
 +    data->thread = NULL;
-+
 +    data->killNow = 0;
-+
 +    data->buffer_ready = 0;
 +    free(data->buffer);
 +    data->buffer = NULL;
 +}
 +
 +
 +static ALCboolean ppapi_open_capture(ALCdevice *device,
 +                                     const ALCchar *deviceName)
 +{
 +    (void)device;
@@ skipping 19 matching lines @@
 +{
 +    *func_list = ppapi_funcs;
 +}
 +
 +void alc_ppapi_deinit(void)
 +{
 +}
 +
 +void alc_ppapi_probe(int type)
 +{
-+    if(type == DEVICE_PROBE)
++    if (type == DEVICE_PROBE)
 +        AppendDeviceList(ppapiDevice);
-+    else if(type == ALL_DEVICE_PROBE)
++    else if (type == ALL_DEVICE_PROBE)
 +        AppendAllDeviceList(ppapiDevice);
 +}
 diff -Naur openal-soft-1.13/Alc/wave.c openal-soft-1.13-nacl/Alc/wave.c
 --- openal-soft-1.13/Alc/wave.c 2010-12-04 17:51:16.000000000 -0800
 +++ openal-soft-1.13-nacl/Alc/wave.c    2012-01-23 15:45:38.000000000 -0800
 @@ -22,7 +22,7 @@
  
  #include <stdlib.h>
  #include <stdio.h>
 -#include <memory.h>
@@ skipping 87 matching lines @@
 +SET(CMAKE_FIND_ROOT_PATH ${NACL_TOOLCHAIN_ROOT})
 +
 +# adjust the default behaviour of the FIND_XXX() commands:
 +# search headers and libraries in the target environment, search 
 +# programs in the host environment
 +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 +set(CMAKE_REQUIRED_INCLUDES "${NACL_SDK_ROOT}/include")
 +include_directories(${NACL_SDK_ROOT}/include)