comparison data/fileio/CodedAudioFileReader.cpp @ 543:7a66b94ef1c0

* Thread safety (fixing a crash)

         //!!! check for return value! out of disk space, etc!
         sf_writef_float(m_cacheFileWritePtr, buffer, sz);
         break;
 
     case CacheInMemory:
+        m_dataLock.lockForWrite();
         for (size_t s = 0; s < count; ++s) {
-            m_data.push_back(buffer[count]);
+            m_data.push_back(buffer[s]);
         }
 	MUNLOCK_SAMPLEBLOCK(m_data);
+        m_dataLock.unlock();
         break;
     }
 }
 
 void
 CodedAudioFileReader::getInterleavedFrames(size_t start, size_t count,
                                            SampleBlock &frames) const
 {
-    //!!! we want to ensure this doesn't require a lock -- at the
-    // moment it does need one, but it doesn't have one...
+    // Lock is only required in CacheInMemory mode (the cache file
+    // reader is expected to be thread safe and manage its own
+    // locking)
 
     if (!m_initialised) {
         std::cerr << "CodedAudioFileReader::getInterleavedFrames: not initialised" << std::endl;
         return;
     }

     case CacheInMemory:
     {
         frames.clear();
         if (!isOK()) return;
         if (count == 0) return;
-
-        // slownessabounds
-
-        for (size_t i = start; i < start + count; ++i) {
-            for (size_t ch = 0; ch < m_channelCount; ++ch) {
-                size_t index = i * m_channelCount + ch;
-                if (index >= m_data.size()) return;
-                frames.push_back(m_data[index]);
-            }
-        }
-    }
-    }
-}
-
+        frames.reserve(count * m_channelCount);
+
+        size_t idx = start * m_channelCount;
+        size_t i = 0;
+
+        m_dataLock.lockForRead();
+        while (i < count * m_channelCount && idx < m_data.size()) {
+            frames.push_back(m_data[idx]);
+            ++idx;
+        }
+        m_dataLock.unlock();
+    }
+    }
+}
+