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-31 08:54:09.078478389 -0800
+@@ -0,0 +1,421 @@
 +/**
 + * 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 39 matching lines @@
 +    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;
 +
 +    ALCdevice *device;
 +
 +    volatile int killNow;
 +    ALvoid *thread;
 +    volatile ALuint main_thread_init_status;
 +    ALuint buffer_ready;
 +} ppapi_data;
@@ skipping 12 matching lines @@
 +                          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);
++        /* Zero the part of the buffer that we cannot fill */

[nfullagar1, 2013/01/31 18:58:50]

Might sound slightly better to replicate the last known sample than zero-fill.

++        memset(sample_buffer + available_bytes, 0, buffer_size_in_bytes - available_bytes);
++        buffer_size_in_bytes = available_bytes;
 +    }
 +
 +    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,
@@ skipping 13 matching lines @@
 +
 +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*2,
++                                            UpdateSizeInBytes);
 +
 +    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)
 +        {
 +            aluMixData(Device,
@@ skipping 37 matching lines @@
 +#endif
 +                                                      rate,
 +                                                      kRequestedFrameCount);
 +
 +    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;
 +    }
@@ skipping 84 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;
 +
 +    data->killNow = 1;
 +    StopThread(data->thread);
 +    data->thread = NULL;
 +
 +    data->killNow = 0;
 +
 +    data->buffer_ready = 0;
 +    free(data->buffer);
@@ skipping 27 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)