Improvements to linear sample rate conversion.

mini_al.h

@@ -780,15 +780,14 @@ struct mal_src
 {
     mal_src_config config;
     float bin[MAL_MAX_CHANNELS][32];
-    mal_src_cache cache;    // <-- For simplifying and optimizing client -> memory reading.
 
     union
     {
         struct
         {
-            float alpha;
-            mal_bool32 isPrevFramesLoaded : 1;
-            mal_bool32 isNextFramesLoaded : 1;
+            float samplesFromClient[MAL_MAX_CHANNELS][256];
+            float t;
+            mal_uint32 leftoverFrames;
         } linear;
     };
 };
@@ -17715,77 +17714,6 @@ mal_uint64 mal_calculate_frame_count_after_src(mal_uint32 sampleRateOut, mal_uin
 }
 
 
-void mal_src_cache_init(mal_src* pSRC, mal_src_cache* pCache)
-{
-    mal_assert(pSRC != NULL);
-    mal_assert(pCache != NULL);
-
-    pCache->pSRC = pSRC;
-    pCache->cachedFrameCount = 0;
-    pCache->iNextFrame = 0;
-}
-
-mal_uint32 mal_src_cache_read_frames_deinterleaved(mal_src_cache* pCache, mal_uint32 frameCount, float** ppSamplesOut, void* pUserData)
-{
-    mal_assert(pCache != NULL);
-    mal_assert(pCache->pSRC != NULL);
-    mal_assert(pCache->pSRC->config.onReadDeinterleaved != NULL);
-    mal_assert(frameCount > 0);
-    mal_assert(ppSamplesOut != NULL);
-
-    mal_uint32 channels = pCache->pSRC->config.channels;
-
-    float* ppCachedFrames[MAL_MAX_CHANNELS];
-    for (mal_uint32 iChannel = 0; iChannel < channels; ++iChannel) {
-        ppCachedFrames[iChannel] = pCache->cachedFrames[iChannel];
-    }
-
-    mal_uint32 totalFramesRead = 0;
-    while (frameCount > 0) {
-        // If there's anything in memory go ahead and copy that over first.
-        mal_uint32 framesRemainingInMemory = pCache->cachedFrameCount - pCache->iNextFrame;
-        mal_uint32 framesToReadFromMemory = frameCount;
-        if (framesToReadFromMemory > framesRemainingInMemory) {
-            framesToReadFromMemory = framesRemainingInMemory;
-        }
-
-        for (mal_uint32 iChannel = 0; iChannel < channels; ++iChannel) {
-            mal_copy_memory(ppSamplesOut[iChannel], pCache->cachedFrames[iChannel] + pCache->iNextFrame, framesToReadFromMemory*sizeof(float));
-        }
-        pCache->iNextFrame += framesToReadFromMemory;
-
-        totalFramesRead += framesToReadFromMemory;
-        frameCount -= framesToReadFromMemory;
-        if (frameCount == 0) {
-            break;
-        }
-
-
-        // At this point there are still more frames to read from the client, so we'll need to reload the cache with fresh data.
-        mal_assert(frameCount > 0);
-
-        pCache->iNextFrame = 0;
-        for (mal_uint32 iChannel = 0; iChannel < channels; ++iChannel) {
-            ppSamplesOut[iChannel] += framesToReadFromMemory;
-        }
-
-        mal_uint32 framesToReadFromClient = mal_countof(pCache->cachedFrames[0]);
-        if (framesToReadFromClient > MAL_SRC_CACHE_SIZE_IN_FRAMES) {
-            framesToReadFromClient = MAL_SRC_CACHE_SIZE_IN_FRAMES;
-        }
-
-        pCache->cachedFrameCount = pCache->pSRC->config.onReadDeinterleaved(pCache->pSRC, framesToReadFromClient, (void**)ppCachedFrames, pUserData);
-
-        // Get out of this loop if nothing was able to be retrieved.
-        if (pCache->cachedFrameCount == 0) {
-            break;
-        }
-    }
-
-    return totalFramesRead;
-}
-
-
 mal_uint64 mal_src_read_deinterleaved__passthrough(mal_src* pSRC, mal_uint64 frameCount, void** ppSamplesOut, mal_bool32 flush, void* pUserData);
 mal_uint64 mal_src_read_deinterleaved__linear(mal_src* pSRC, mal_uint64 frameCount, void** ppSamplesOut, mal_bool32 flush, void* pUserData);
 
@@ -17806,7 +17734,6 @@ mal_result mal_src_init(const mal_src_config* pConfig, mal_src* pSRC)
 
     pSRC->config = *pConfig;
 
-    mal_src_cache_init(pSRC, &pSRC->cache);
     return MAL_SUCCESS;
 }
 
@@ -17887,7 +17814,7 @@ mal_uint64 mal_src_read_deinterleaved__passthrough(mal_src* pSRC, mal_uint64 fra
                 framesToReadRightNow = 0xFFFFFFFF;
             }
 
-            mal_uint32 framesRead = (mal_uint32)pSRC->config.onReadDeinterleaved(pSRC, (mal_uint32)framesToReadRightNow, ppNextSamplesOut, pUserData);
+            mal_uint32 framesRead = (mal_uint32)pSRC->config.onReadDeinterleaved(pSRC, (mal_uint32)framesToReadRightNow, (void**)ppNextSamplesOut, pUserData);
             if (framesRead == 0) {
                 break;
             }
@@ -17904,84 +17831,160 @@ mal_uint64 mal_src_read_deinterleaved__passthrough(mal_src* pSRC, mal_uint64 fra
 
 mal_uint64 mal_src_read_deinterleaved__linear(mal_src* pSRC, mal_uint64 frameCount, void** ppSamplesOut, mal_bool32 flush, void* pUserData)
 {
+    (void)flush;    // No flushing at the moment.
+
     mal_assert(pSRC != NULL);
     mal_assert(frameCount > 0);
     mal_assert(ppSamplesOut != NULL);
 
-    // For linear SRC, the bin is only 2 frames: 1 prior, 1 future.
-
     float* ppNextSamplesOut[MAL_MAX_CHANNELS];
     mal_copy_memory(ppNextSamplesOut, ppSamplesOut, sizeof(void*) * pSRC->config.channels);
 
-    // Load the bin if necessary.
-    float* ppPrevFrame[MAL_MAX_CHANNELS];
-    float* ppNextFrame[MAL_MAX_CHANNELS];
-    for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
-        ppPrevFrame[iChannel] = &pSRC->bin[iChannel][0];
-        ppNextFrame[iChannel] = &pSRC->bin[iChannel][1];
-    }
 
-    if (!pSRC->linear.isPrevFramesLoaded) {
-        mal_uint32 framesRead = mal_src_cache_read_frames_deinterleaved(&pSRC->cache, 1, ppPrevFrame, pUserData);
-        if (framesRead == 0) {
-            return 0;
+    float factor = (float)pSRC->config.sampleRateIn / pSRC->config.sampleRateOut;
+
+    mal_uint32 maxFrameCountPerChunkIn = mal_countof(pSRC->linear.samplesFromClient[0]);
+
+    mal_uint64 totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        mal_uint64 framesRemaining = frameCount - totalFramesRead;
+        mal_uint64 framesToRead = framesRemaining;
+        if (framesToRead > 16384) {
+            framesToRead = 16384;    // <-- Keep this small because we're using 32-bit floats for calculating sample positions and I don't want to run out of precision with huge sample counts.
         }
-        pSRC->linear.isPrevFramesLoaded = MAL_TRUE;
-    }
-    if (!pSRC->linear.isNextFramesLoaded) {
-        mal_uint32 framesRead = mal_src_cache_read_frames_deinterleaved(&pSRC->cache, 1, ppNextFrame, pUserData);
-        if (framesRead == 0) {
-            return 0;
+
+
+        // Read Input Data
+        // ===============
+        float tBeg = pSRC->linear.t;
+        float tEnd = tBeg + (framesToRead*factor);
+
+        mal_uint32 framesToReadFromClient = (mal_uint32)(tEnd) + 1 + 1;   // +1 to make tEnd 1-based and +1 because we always need to an extra sample for interpolation.
+        if (framesToReadFromClient >= maxFrameCountPerChunkIn) {
+            framesToReadFromClient  = maxFrameCountPerChunkIn;
         }
-        pSRC->linear.isNextFramesLoaded = MAL_TRUE;
-    }
 
-    float factor = (float)pSRC->config.sampleRateIn / pSRC->config.sampleRateOut;
+        float* ppSamplesFromClient[MAL_MAX_CHANNELS];
+        for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
+            ppSamplesFromClient[iChannel] = pSRC->linear.samplesFromClient[iChannel] + pSRC->linear.leftoverFrames;
+        }
+        
+        mal_uint32 framesReadFromClient = 0;
+        if (framesToReadFromClient > pSRC->linear.leftoverFrames) {
+            framesReadFromClient = (mal_uint32)pSRC->config.onReadDeinterleaved(pSRC, (mal_uint32)framesToReadFromClient - pSRC->linear.leftoverFrames, (void**)ppSamplesFromClient, pUserData);
+        }
+
+        framesReadFromClient += pSRC->linear.leftoverFrames;  // <-- You can sort of think of it as though we've re-read the leftover samples from the client.
+        if (framesReadFromClient < 2) {
+            break;
+        }
 
-    mal_uint64 totalFramesRead = 0;
-    while (frameCount > 0) {
         for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
-            // The bin is where the previous and next frames are located.
-            float prevSample = pSRC->bin[iChannel][0];
-            float nextSample = pSRC->bin[iChannel][1];
-            ppNextSamplesOut[iChannel][0] = mal_mix_f32(prevSample, nextSample, pSRC->linear.alpha);
-            ppNextSamplesOut[iChannel] = (float*)ppNextSamplesOut[iChannel] + 1;
+            ppSamplesFromClient[iChannel] = pSRC->linear.samplesFromClient[iChannel];
         }
 
-        pSRC->linear.alpha += factor;
 
-        // The new alpha value is how we determine whether or not we need to read fresh frames.
-        mal_uint32 framesToReadFromClient = (mal_uint32)pSRC->linear.alpha;
-        pSRC->linear.alpha = pSRC->linear.alpha - framesToReadFromClient;
+        // Write Output Data
+        // =================
 
-        for (mal_uint32 i = 0; i < framesToReadFromClient; ++i) {
-            for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
-                ppPrevFrame[iChannel][0] = ppNextFrame[iChannel][0];
+        // At this point we have a bunch of frames that the client has given to us for processing. From this we can determine the maximum number of output frames
+        // that can be processed from this input. We want to output as many samples as possible from our input data.
+        float tAvailable = framesReadFromClient - tBeg;
+
+        mal_uint32 maxOutputFramesToRead = (mal_uint32)(tAvailable / factor);
+        if (maxOutputFramesToRead == 0) {
+            maxOutputFramesToRead = 1;
+        }
+        if (maxOutputFramesToRead > framesToRead) {
+            maxOutputFramesToRead = (mal_uint32)framesToRead;
+        }
+
+        // Output frames are always read in groups of 4 because I'm planning on using this as a reference for some SIMD-y stuff later.
+        mal_uint32 maxOutputFramesToRead4 = maxOutputFramesToRead/4;
+        for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
+            float t0 = pSRC->linear.t + factor*0;
+            float t1 = pSRC->linear.t + factor*1;
+            float t2 = pSRC->linear.t + factor*2;
+            float t3 = pSRC->linear.t + factor*3;
+
+            for (mal_uint32 iFrameOut = 0; iFrameOut < maxOutputFramesToRead4; iFrameOut += 1) {
+                float iPrevSample0 = (float)floor(t0);
+                float iPrevSample1 = (float)floor(t1);
+                float iPrevSample2 = (float)floor(t2);
+                float iPrevSample3 = (float)floor(t3);
+                
+                float iNextSample0 = iPrevSample0 + 1;
+                float iNextSample1 = iPrevSample1 + 1;
+                float iNextSample2 = iPrevSample2 + 1;
+                float iNextSample3 = iPrevSample3 + 1;
+
+                float alpha0 = t0 - iPrevSample0;
+                float alpha1 = t1 - iPrevSample1;
+                float alpha2 = t2 - iPrevSample2;
+                float alpha3 = t3 - iPrevSample3;
+
+                float prevSample0 = ppSamplesFromClient[iChannel][(mal_uint32)iPrevSample0];
+                float prevSample1 = ppSamplesFromClient[iChannel][(mal_uint32)iPrevSample1];
+                float prevSample2 = ppSamplesFromClient[iChannel][(mal_uint32)iPrevSample2];
+                float prevSample3 = ppSamplesFromClient[iChannel][(mal_uint32)iPrevSample3];
+                
+                float nextSample0 = ppSamplesFromClient[iChannel][(mal_uint32)iNextSample0];
+                float nextSample1 = ppSamplesFromClient[iChannel][(mal_uint32)iNextSample1];
+                float nextSample2 = ppSamplesFromClient[iChannel][(mal_uint32)iNextSample2];
+                float nextSample3 = ppSamplesFromClient[iChannel][(mal_uint32)iNextSample3];
+
+                ppNextSamplesOut[iChannel][iFrameOut*4 + 0] = mal_mix_f32(prevSample0, nextSample0, alpha0);
+                ppNextSamplesOut[iChannel][iFrameOut*4 + 1] = mal_mix_f32(prevSample1, nextSample1, alpha1);
+                ppNextSamplesOut[iChannel][iFrameOut*4 + 2] = mal_mix_f32(prevSample2, nextSample2, alpha2);
+                ppNextSamplesOut[iChannel][iFrameOut*4 + 3] = mal_mix_f32(prevSample3, nextSample3, alpha3);
+
+                t0 += factor*4;
+                t1 += factor*4;
+                t2 += factor*4;
+                t3 += factor*4;
             }
 
-            mal_uint32 framesRead = mal_src_cache_read_frames_deinterleaved(&pSRC->cache, 1, ppNextFrame, pUserData);
-            if (framesRead == 0) {
-                for (mal_uint32 j = 0; j < pSRC->config.channels; ++j) {
-                    ppNextFrame[j][0] = 0;
-                }
+            float t = pSRC->linear.t + (factor*maxOutputFramesToRead4*4);
+            for (mal_uint32 iFrameOut = (maxOutputFramesToRead4*4); iFrameOut < maxOutputFramesToRead; iFrameOut += 1) {
+                float iPrevSample = (float)floor(t);
+                float iNextSample = iPrevSample + 1;
+                float alpha = t - iPrevSample;
 
-                if (pSRC->linear.isNextFramesLoaded) {
-                    pSRC->linear.isNextFramesLoaded = MAL_FALSE;
-                } else {
-                    if (flush) {
-                        pSRC->linear.isPrevFramesLoaded = MAL_FALSE;
-                    }
-                }
+                float prevSample = ppSamplesFromClient[iChannel][(mal_uint32)iPrevSample];
+                float nextSample = ppSamplesFromClient[iChannel][(mal_uint32)iNextSample];
 
-                break;
+                ppNextSamplesOut[iChannel][iFrameOut] = mal_mix_f32(prevSample, nextSample, alpha);
+
+                t += factor;
             }
+
+            ppNextSamplesOut[iChannel] += maxOutputFramesToRead;
         }
 
-        frameCount -= 1;
-        totalFramesRead += 1;
+        totalFramesRead += maxOutputFramesToRead;
+
+
+        // Residual
+        // ========
+        float tNext = pSRC->linear.t + (maxOutputFramesToRead*factor);
+
+        pSRC->linear.t = tNext;
+        mal_assert(tNext <= framesReadFromClient+1);
+
+        mal_uint32 iNextFrame = (mal_uint32)floor(tNext);
+        pSRC->linear.leftoverFrames = framesReadFromClient - iNextFrame;
+        pSRC->linear.t = tNext - iNextFrame;
+
+        for (mal_uint32 iChannel = 0; iChannel < pSRC->config.channels; ++iChannel) {
+            for (mal_uint32 iFrame = 0; iFrame < pSRC->linear.leftoverFrames; ++iFrame) {
+                float sample = ppSamplesFromClient[iChannel][framesReadFromClient-pSRC->linear.leftoverFrames + iFrame];
+                ppSamplesFromClient[iChannel][iFrame] = sample;
+            }
+        }
 
-        // If there's no frames available we need to get out of this loop.
-        if (!pSRC->linear.isNextFramesLoaded && (!flush || !pSRC->linear.isPrevFramesLoaded)) {
+        
+        // Exit the loop if we've found everything from the client.
+        if (framesReadFromClient < framesToReadFromClient) {
             break;
         }
     }