Add carla_copy* calls and use them where useful

source/backend/engine/CarlaEngine.cpp

@@ -1370,8 +1370,8 @@ void CarlaEngine::processRack(float* inBuf[2], float* outBuf[2], const uint32_t
         if (processed)
         {
             // initialize inputs (from previous outputs)
-            std::memcpy(inBuf[0], outBuf[0], sizeof(float)*frames);
-            std::memcpy(inBuf[1], outBuf[1], sizeof(float)*frames);
+            carla_copyFloat(inBuf[0], outBuf[0], frames);
+            carla_copyFloat(inBuf[1], outBuf[1], frames);
             std::memcpy(kData->rack.in, kData->rack.out, sizeof(EngineEvent)*RACK_EVENT_COUNT);
 
             // initialize outputs (zero)
@@ -1432,8 +1432,8 @@ void CarlaEngine::processRack(float* inBuf[2], float* outBuf[2], const uint32_t
     // if no plugins in the rack, copy inputs over outputs
     if (! processed)
     {
-        std::memcpy(outBuf[0], inBuf[0], sizeof(float)*frames);
-        std::memcpy(outBuf[1], inBuf[1], sizeof(float)*frames);
+        carla_copyFloat(outBuf[0], inBuf[0], frames);
+        carla_copyFloat(outBuf[1], inBuf[1], frames);
         std::memcpy(kData->rack.out, kData->rack.in, sizeof(EngineEvent)*RACK_EVENT_COUNT);
     }
 }

source/backend/engine/CarlaEngineJack.cpp

@@ -340,7 +340,7 @@ public:
             return;
 
         uint8_t jdata[size];
-        std::memcpy(jdata, data, sizeof(uint8_t)*size);
+        carla_copy<uint8_t>(jdata, data, size);
 
         jdata[0] = data[0] + channel;
 

source/backend/engine/CarlaEnginePlugin.cpp

@@ -64,7 +64,7 @@ public:
         paramBuffers[paramBalance] = 63.5f;
         paramBuffers[paramPan]     = 63.5f;
 
-        std::memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);
+        carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);
 
         // set-up engine
         fOptions.processMode = PROCESS_MODE_CONTINUOUS_RACK;
@@ -400,7 +400,7 @@ protected:
         }
 #endif
 
-        std::memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);
+        carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);
     }
 
     void d_deactivate()
@@ -443,7 +443,7 @@ protected:
                 carlaEvent->value     = paramBuffers[i]/127;
             }
         }
-        std::memcpy(prevParamBuffers, paramBuffers, sizeof(float)*paramCount);
+        carla_copyFloat(prevParamBuffers, paramBuffers, paramCount);
 
         // initialize midi input
         std::memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*CarlaEngine::MAX_MIDI_EVENTS);

source/backend/engine/CarlaEngineRtAudio.cpp

@@ -298,8 +298,8 @@ protected:
         }
         else
         {
-            std::memcpy(fAudioInBuf1, insPtr, sizeof(float)*nframes);
-            std::memcpy(fAudioInBuf2, insPtr+nframes, sizeof(float)*nframes);
+            carla_copyFloat(fAudioInBuf1, insPtr, nframes);
+            carla_copyFloat(fAudioInBuf2, insPtr+nframes, nframes);
         }
 
         // initialize audio output
@@ -417,8 +417,8 @@ protected:
         }
         else
         {
-            std::memcpy(outsPtr, fAudioOutBuf1, sizeof(float)*nframes);
-            std::memcpy(outsPtr+nframes, fAudioOutBuf2, sizeof(float)*nframes);
+            carla_copyFloat(outsPtr, fAudioOutBuf1, nframes);
+            carla_copyFloat(outsPtr+nframes, fAudioOutBuf2, nframes);
         }
 
         // output events

source/backend/plugin/DssiPlugin.cpp

@@ -1365,7 +1365,7 @@ public:
                 if (doBalance)
                 {
                     if (i % 2 == 0)
-                        std::memcpy(oldBufLeft, outBuffer[i], sizeof(float)*frames);
+                        carla_copyFloat(oldBufLeft, outBuffer[i], frames);
 
                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;
                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;
@@ -1400,7 +1400,7 @@ public:
             if (kData->latency > 0 && kData->latency < frames)
             {
                 for (i=0; i < kData->audioIn.count; i++)
-                    std::memcpy(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), sizeof(float)*kData->latency);
+                    carla_copyFloat(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), kData->latency);
             }
 #endif
         } // End of Post-processing
@@ -1438,7 +1438,7 @@ public:
     void processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset, const uint32_t midiEventCount)
     {
         for (uint32_t i=0; i < kData->audioIn.count; i++)
-            std::memcpy(fAudioInBuffers[i], inBuffer[i]+timeOffset, sizeof(float)*frames);
+            carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);
         for (uint32_t i=0; i < kData->audioOut.count; i++)
             carla_zeroFloat(fAudioOutBuffers[i], frames);
 

source/backend/plugin/FluidSynthPlugin.cpp

@@ -1219,7 +1219,7 @@ public:
                 if (doBalance)
                 {
                     if (i % 2 == 0)
-                        std::memcpy(oldBufLeft, outBuffer[i], sizeof(float)*frames);
+                        carla_copyFloat(oldBufLeft, outBuffer[i], frames);
 
                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;
                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;

source/backend/plugin/LadspaPlugin.cpp

@@ -1036,7 +1036,7 @@ public:
                 if (doBalance)
                 {
                     if (i % 2 == 0)
-                        std::memcpy(oldBufLeft, outBuffer[i], sizeof(float)*frames);
+                        carla_copyFloat(oldBufLeft, outBuffer[i], frames);
 
                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;
                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;
@@ -1071,7 +1071,7 @@ public:
             if (kData->latency > 0 && kData->latency < frames)
             {
                 for (i=0; i < kData->audioIn.count; i++)
-                    std::memcpy(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), sizeof(float)*kData->latency);
+                    carla_copyFloat(kData->latencyBuffers[i], inBuffer[i] + (frames - kData->latency), kData->latency);
             }
 #endif
         } // End of Post-processing
@@ -1109,7 +1109,7 @@ public:
     void processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)
     {
         for (uint32_t i=0; i < kData->audioIn.count; i++)
-            std::memcpy(fAudioInBuffers[i], inBuffer[i]+timeOffset, sizeof(float)*frames);
+            carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);
         for (uint32_t i=0; i < kData->audioOut.count; i++)
             carla_zeroFloat(fAudioOutBuffers[i], frames);
 

source/backend/plugin/LinuxSamplerPlugin.cpp

@@ -764,7 +764,7 @@ public:
                 if (do_balance)
                 {
                     if (i%2 == 0)
-                        memcpy(&oldBufLeft, outBuffer[i], sizeof(float)*frames);
+                        carla_copyFloat(oldBufLeft, outBuffer[i], frames);
 
                     bal_rangeL = (x_balanceLeft+1.0)/2;
                     bal_rangeR = (x_balanceRight+1.0)/2;

source/backend/plugin/NativePlugin.cpp

@@ -1377,7 +1377,7 @@ public:
                 if (doBalance)
                 {
                     if (i % 2 == 0)
-                        std::memcpy(oldBufLeft, outBuffer[i], sizeof(float)*frames);
+                        carla_copyFloat(oldBufLeft, outBuffer[i], frames);
 
                     float balRangeL = (kData->postProc.balanceLeft  + 1.0f)/2.0f;
                     float balRangeR = (kData->postProc.balanceRight + 1.0f)/2.0f;
@@ -1465,7 +1465,7 @@ public:
     void processSingle(float** const inBuffer, float** const outBuffer, const uint32_t frames, const uint32_t timeOffset)
     {
         for (uint32_t i=0; i < kData->audioIn.count; i++)
-            std::memcpy(fAudioInBuffers[i], inBuffer[i]+timeOffset, sizeof(float)*frames);
+            carla_copyFloat(fAudioInBuffers[i], inBuffer[i]+timeOffset, frames);
         for (uint32_t i=0; i < kData->audioOut.count; i++)
             carla_zeroFloat(fAudioOutBuffers[i], frames);
 
@@ -1576,7 +1576,7 @@ protected:
         return &fTimeInfo;
     }
 
-    bool handleWriteMidiEvent(const MidiEvent* const event)
+    bool handleWriteMidiEvent(const ::MidiEvent* const event)
     {
         CARLA_ASSERT(fEnabled);
         CARLA_ASSERT(fMidiOut.count > 0);

source/utils/CarlaLibUtils.hpp

@@ -77,7 +77,7 @@ const char* lib_error(const char* const filename)
 
 #ifdef CARLA_OS_WIN
     static char libError[2048];
-    std::memset(libError, 0, sizeof(char)*2048);
+    carla_zeroMem(libError, sizeof(char)*2048);
 
     LPVOID winErrorString;
     DWORD  winErrorCode = GetLastError();

source/utils/CarlaString.hpp

@@ -313,7 +313,7 @@ public:
         if (unsigned int len = carla_base64_decode(buffer, binaryBuffer))
         {
             uint8_t* const binaryBufferHeap = new uint8_t[len];
-            std::memcpy(binaryBufferHeap, binaryBuffer, len);
+            carla_copy<uint8_t>(binaryBufferHeap, binaryBuffer, len);
 
             *rawPtr = binaryBufferHeap;
             return len;

source/utils/CarlaUtils.hpp

@@ -235,6 +235,36 @@ const T& carla_fixValue(const T& min, const T& max, const T& value)
     return value;
 }
 
+template<typename T>
+static inline
+void carla_copy(T* dataDst, T* dataSrc, const size_t size)
+{
+    CARLA_ASSERT(dataDst != nullptr);
+    CARLA_ASSERT(dataSrc != nullptr);
+    CARLA_ASSERT(size > 0);
+
+    if (dataDst == nullptr || dataSrc == nullptr || size == 0)
+        return;
+
+    for (size_t i=0; i < size; i++)
+        *dataDst++ = *dataSrc++;
+}
+
+template<typename T>
+static inline
+void carla_copy(T* dataDst, const T* dataSrc, const size_t size)
+{
+    CARLA_ASSERT(dataDst != nullptr);
+    CARLA_ASSERT(dataSrc != nullptr);
+    CARLA_ASSERT(size > 0);
+
+    if (dataDst == nullptr || dataSrc == nullptr || size == 0)
+        return;
+
+    for (size_t i=0; i < size; i++)
+        *dataDst++ = *dataSrc++;
+}
+
 template<typename T>
 static inline
 void carla_fill(T* data, const size_t size, const T v)
@@ -242,13 +272,25 @@ void carla_fill(T* data, const size_t size, const T v)
     CARLA_ASSERT(data != nullptr);
     CARLA_ASSERT(size > 0);
 
-    if (data == nullptr)
+    if (data == nullptr || size == 0)
         return;
 
-    for (unsigned int i=0; i < size; i++)
+    for (size_t i=0; i < size; i++)
         *data++ = v;
 }
 
+static inline
+void carla_copyDouble(double* dataDst, double* dataSrc, const size_t size)
+{
+    carla_copy<double>(dataDst, dataSrc, size);
+}
+
+static inline
+void carla_copyFloat(float* dataDst, float* dataSrc, const size_t size)
+{
+    carla_copy<float>(dataDst, dataSrc, size);
+}
+
 static inline
 void carla_zeroDouble(double* data, const size_t size)
 {
@@ -268,8 +310,9 @@ static inline
 void carla_zeroMem(void* const memory, const size_t numBytes)
 {
     CARLA_ASSERT(memory != nullptr);
+    CARLA_ASSERT(numBytes > 0);
 
-    if (memory == nullptr)
+    if (memory == nullptr || numBytes == 0)
         return;
 
     std::memset(memory, 0, numBytes);

source/utils/RtList.hpp

@@ -268,7 +268,7 @@ private:
         if (reset)
         {
             reset = false;
-            std::memset(&value, 0, sizeof(T));
+            carla_zeroMem(&value, sizeof(T));
         }
 
         return value;