Ticket #931: snd_remove_source_suballoc+disable_buf_free.patch

snd_mgr.cpp

@@ -349 +349 @@
 // verify that all buffers have been freed at exit.
 //-----------------------------------------------------------------------------
 
-static int al_bufs_outstanding;
+static intptr_t al_buf_inUse;
 
 
 /**
@@ -370 +370 @@
     AL_CHECK;
 
     ENSURE(alIsBuffer(al_buf));
-    al_bufs_outstanding++;
+    cpu_AtomicAdd(&al_buf_inUse, +1);
 
     return al_buf;
 }
@@ -394 +394 @@
     alDeleteBuffers(1, &al_buf);
     AL_CHECK;
 
-    al_bufs_outstanding--;
+    cpu_AtomicAdd(&al_buf_inUse, -1);
 }
 
 
@@ -404 +404 @@
  */
 static void al_buf_shutdown()
 {
-    ENSURE(al_bufs_outstanding == 0);
+    ENSURE(al_buf_inUse == 0);
 }
 
 
 //-----------------------------------------------------------------------------
-// AL source suballocator: allocate all available sources up-front and
-// pass them out as needed (alGenSources is quite slow, taking 3..5 ms per
-// source returned). also responsible for enforcing user-specified limit
-// on total number of sources (to reduce mixing cost on low-end systems).
+// AL source suballocator
 //-----------------------------------------------------------------------------
 
-// regardless of HW capabilities, we won't use more than this ("enough").
-// necessary in case OpenAL doesn't limit #sources (e.g. if SW mixing).
-static const size_t AL_SRC_MAX = 64;
+// a suballocator used to be necessary because alGenSources took 3-5 ms per
+// source returned on NVidia's native OpenAL. however, OS X CoreAudio can't
+// deal with immediate source reuse (race condition?), and the easiest way
+// to get around this is to generate/delete sources on demand. fortunately,
+// OpenALsoft only takes a few microseconds to do this.
+// this layer is also responsible for enforcing the user-specified limit on
+// the total number of sources (to reduce mixing cost on low-end systems).
 
-// (allow changing at runtime)
-static size_t al_src_maxNumToUse = AL_SRC_MAX;
+// 64 is probably "enough", but the value can be changed at runtime.
+static size_t al_src_maxNumToUse = 64;
 
-static size_t al_src_numPreallocated;
+static volatile intptr_t al_src_inUse;
 
-enum AllocationState
-{
-    kAvailable = 0, // (must match zero-initialization of al_srcs_allocationStates)
-    kInUse
-};
 
-// note: we want to catch double-free bugs and ensure all sources
-// are released at exit, but OpenAL doesn't specify an always-invalid
-// source name, so we need a separate array of AllocationState.
-static ALuint al_srcs[AL_SRC_MAX];
-static intptr_t al_srcs_allocationStates[AL_SRC_MAX];
-
-/**
- * grab as many sources as possible up to the limit.
- * called from al_init.
- */
 static void al_src_init()
 {
-    // grab as many sources as possible and count how many we get.
-    for(size_t i = 0; i < al_src_maxNumToUse; i++)
-    {
-        ALuint al_src;
-        alGenSources(1, &al_src);
-        // we've reached the limit, no more are available.
-        if(alGetError() != AL_NO_ERROR)
-            break;
-        ENSURE(alIsSource(al_src));
-        al_srcs[i] = al_src;
-        al_src_numPreallocated++;
-    }
-
-    // limit user's cap to what we actually got.
-    // (in case snd_set_max_src was called before this)
-    if(al_src_maxNumToUse > al_src_numPreallocated)
-        al_src_maxNumToUse = al_src_numPreallocated;
-
-    // make sure we got the minimum guaranteed by OpenAL.
-    ENSURE(al_src_numPreallocated >= 16);
 }
 
 
 /**
- * release all sources on free list.
- * all sources must already have been released via al_src_free.
  * called from al_shutdown.
+ * all sources must already have been released via al_src_free.
  */
 static void al_src_shutdown()
 {
-    for(size_t i = 0; i < al_src_numPreallocated; i++)
-        ENSURE(al_srcs_allocationStates[i] == kAvailable);
-
-    AL_CHECK;
-    alDeleteSources((ALsizei)al_src_numPreallocated, al_srcs);
-    AL_CHECK;
-
-    al_src_numPreallocated = 0;
+    // (we no longer bother keeping a list of extant sources,
+    // because they will be freed at exit anyway.)
+    ENSURE(al_src_inUse == 0);
 }
 
 
+TIMER_ADD_CLIENT(tc_OpenAL_source);
+
 /**
  * try to allocate a source.
  *
- * @return whether a source was allocated (see al_srcs_allocationStates).
+ * @return whether a source was allocated.
  * @param al_src receives the new source name iff true is returned.
  */
 static bool al_src_alloc(ALuint& al_src)
 {
-    for(size_t i = 0; i < al_src_numPreallocated; i++)
-    {
-        if(cpu_CAS(&al_srcs_allocationStates[i], kAvailable, kInUse))
-        {
-            al_src = al_srcs[i];
-            return true;
-        }
-    }
+TIMER_ACCRUE(tc_OpenAL_source);
 
-    return false;   // no more to give
+    if((size_t)al_src_inUse >= al_src_maxNumToUse)
+        return false;   // allocated too many already
+    cpu_AtomicAdd(&al_src_inUse, +1);
+
+    AL_CHECK;
+    alGenSources(1, &al_src);
+    AL_CHECK;
+    return true;
 }
 
 
@@ -511 +473 @@
  */
 static void al_src_free(ALuint al_src)
 {
+TIMER_ACCRUE(tc_OpenAL_source);
     ENSURE(alIsSource(al_src));
 
-    const ALuint* pos = std::find(al_srcs, al_srcs+al_src_numPreallocated, al_src);
-    if(pos != al_srcs+al_src_numPreallocated)   // found it
-    {
-        const size_t i = pos - al_srcs;
-        ENSURE(cpu_CAS(&al_srcs_allocationStates[i], kInUse, kAvailable));
-    }
-    else
-        DEBUG_WARN_ERR(ERR::LOGIC); // al_src wasn't in al_srcs
+    cpu_AtomicAdd(&al_src_inUse, -1);
+
+    AL_CHECK;
+    alDeleteSources(1, &al_src);
+    AL_CHECK;
 }
 
 
@@ -528 +488 @@
  * set maximum number of voices to play simultaneously,
  * to reduce mixing cost on low-end systems.
  * this limit may be ignored if e.g. there's a stricter
- * implementation- defined ceiling anyway.
+ * implementation-defined ceiling anyway.
  *
  * @param limit max. number of sources
  * @return Status
  */
 Status snd_set_max_voices(size_t limit)
 {
-    // valid if cap is legit (less than what we allocated in al_src_init),
-    // or if al_src_init hasn't been called yet. note: we accept anything
-    // in the second case, as al_src_init will sanity-check al_src_cap.
-    if(!al_src_numPreallocated || limit < al_src_numPreallocated)
-    {
-        al_src_maxNumToUse = limit;
-        return INFO::OK;
-    }
-    // user is requesting a cap higher than what we actually allocated.
-    // that's fine (not an error), but we won't set the cap, since it
-    // determines how many sources may be returned.
-    // there's no return value to indicate this because the cap is
-    // precisely that - an upper limit only, we don't care if it can't be met.
-    else
-        return INFO::OK;
+    al_src_maxNumToUse = limit;
+    return INFO::OK;
 }
 
 
@@ -1536 +1483 @@
  * @param VSrc*
  * @return int number of entries that were removed.
  */
-static int vsrc_deque_finished_bufs(VSrc* vs)
+static ALint vsrc_dequeue_finished_bufs(VSrc* vs)
 {
     ENSURE(vs->HasSource());    // (otherwise there's no sense in calling this function)
 
     AL_CHECK;
-    int num_processed;
+    ALint num_processed;
     alGetSourcei(vs->al_src, AL_BUFFERS_PROCESSED, &num_processed);
     AL_CHECK;
 
-    for(int i = 0; i < num_processed; i++)
+    for(ALint i = 0; i < num_processed; i++)
     {
         ALuint al_buf;
         alSourceUnqueueBuffers(vs->al_src, 1, &al_buf);
@@ -1591 +1538 @@
         alGetSourcei(vs->al_src, AL_BUFFERS_QUEUED, &num_queued);
         AL_CHECK;
 
-        int num_processed = vsrc_deque_finished_bufs(vs);
+        ALint num_processed = vsrc_dequeue_finished_bufs(vs);
         UNUSED2(num_processed);
 
         if(vs->flags & VS_EOF)
@@ -1673 +1620 @@
     if(!vs->HasSource())
         return ERR::FAIL;   // NOWARN
 
+    // apparently even the following contortions aren't enough to
+    // prevent buffer(s) from remaining attached to the source
+    // on OS X when looping is enabled, so we will just have
+    // to let the buffer leak (or "GC" it later).
+    const bool avoidFreeingBufHack = OS_MACOSX && vs->loop;
+
     // clear the source's buffer queue (necessary because buffers cannot
     // be deleted at shutdown while still attached to a source).
     // note: OpenAL 1.1 says all buffers become "processed" when the
-    // source is stopped (so vsrc_deque_finished_bufs ought to have the
-    // desired effect), but that isn't the case on some Linux
+    // source is stopped (so vsrc_dequeue_finished_bufs ought to have the
+    // desired effect), but that isn't the case on some OS X / Linux
     // implementations (OpenALsoft and PulseAudio with on-board NVidia).
     // wiping out the entire queue by attaching the null buffer is safer,
     // but still doesn't cause versions of OpenALsoft older than 2009-08-11
@@ -1693 +1646 @@
 
     alSourceStop(vs->al_src);
 
-    vsrc_deque_finished_bufs(vs);
+    if(!avoidFreeingBufHack)
+        (void)vsrc_dequeue_finished_bufs(vs);
     alSourcei(vs->al_src, AL_BUFFER, AL_NONE);
 
+    // resets the sample position and changes state to AL_STOPPED
+    // (which clears the buffer queue) and then AL_INITIAL.
     alSourceRewind(vs->al_src);
 
     al_src_free(vs->al_src);