Merge branch 'release/1.1.4'

adamstark · adamstark · commit 4554279566c1 · 2025-10-15T21:42:03.000+01:00
diff --git a/AudioFile.h b/AudioFile.h
@@ -207,7 +207,6 @@ class AudioFile
 
     static inline int32_t fourBytesToInt (const std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);
     static inline int16_t twoBytesToInt (const std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);
-    static inline int getIndexOfString (const std::vector<uint8_t>& source, std::string s);
     static inline int getIndexOfChunk (const std::vector<uint8_t>& source, const std::string& chunkHeaderID, int startIndex, Endianness endianness = Endianness::LittleEndian);
 
     //=============================================================
@@ -339,7 +338,7 @@ uint32_t AudioFile<T>::getSampleRate() const
 template <class T>
 int AudioFile<T>::getNumChannels() const
 {
-    return (int)samples.size();
+    return static_cast<int> (samples.size());
 }
 
 //=============================================================
@@ -368,7 +367,7 @@ template <class T>
 int AudioFile<T>::getNumSamplesPerChannel() const
 {
     if (samples.size() > 0)
-        return (int) samples[0].size();
+        return static_cast<int> (samples[0].size());
     else
         return 0;
 }
@@ -377,7 +376,7 @@ int AudioFile<T>::getNumSamplesPerChannel() const
 template <class T>
 double AudioFile<T>::getLengthInSeconds() const
 {
-    return (double)getNumSamplesPerChannel() / (double)sampleRate;
+    return static_cast<double> (getNumSamplesPerChannel()) / static_cast<double> (sampleRate);
 }
 
 //=============================================================
@@ -397,7 +396,7 @@ void AudioFile<T>::printSummary() const
 template <class T>
 bool AudioFile<T>::setAudioBuffer (const AudioBuffer& newBuffer)
 {
-    int numChannels = (int)newBuffer.size();
+    int numChannels = static_cast<int> (newBuffer.size());
     
     if (numChannels <= 0)
     {
@@ -437,16 +436,8 @@ void AudioFile<T>::setAudioBufferSize (int numChannels, int numSamples)
 template <class T>
 void AudioFile<T>::setNumSamplesPerChannel (int numSamples)
 {
-    int originalSize = getNumSamplesPerChannel();
-    
     for (int i = 0; i < getNumChannels();i++)
-    {
-        samples[i].resize (numSamples);
-        
-        // set any new samples to zero
-        if (numSamples > originalSize)
-            std::fill (samples[i].begin() + originalSize, samples[i].end(), (T)0.);
-    }
+        samples[i].resize (numSamples, static_cast<T> (0));
 }
 
 //=============================================================
@@ -460,14 +451,8 @@ void AudioFile<T>::setNumChannels (int numChannels)
     
     // make sure any new channels are set to the right size
     // and filled with zeros
-    if (numChannels > originalNumChannels)
-    {
-        for (int i = originalNumChannels; i < numChannels; i++)
-        {
-            samples[i].resize (originalNumSamplesPerChannel);
-            std::fill (samples[i].begin(), samples[i].end(), (T)0.);
-        }
-    }
+    for (int i = originalNumChannels; i < numChannels; i++)
+        samples[i].resize (originalNumSamplesPerChannel, static_cast<T> (0));
 }
 
 //=============================================================
@@ -590,10 +575,10 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)
     //int32_t formatChunkSize = fourBytesToInt (fileData, f + 4);
     uint16_t audioFormat = twoBytesToInt (fileData, f + 8);
     uint16_t numChannels = twoBytesToInt (fileData, f + 10);
-    sampleRate = (uint32_t) fourBytesToInt (fileData, f + 12);
+    sampleRate = static_cast<uint32_t> (fourBytesToInt (fileData, f + 12));
     uint32_t numBytesPerSecond = fourBytesToInt (fileData, f + 16);
     uint16_t numBytesPerBlock = twoBytesToInt (fileData, f + 20);
-    bitDepth = (int) twoBytesToInt (fileData, f + 22);
+    bitDepth = static_cast<int> (twoBytesToInt (fileData, f + 22));
     
     if (bitDepth > sizeof (T) * 8)
     {
@@ -652,7 +637,7 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)
     {
         for (int channel = 0; channel < numChannels; channel++)
         {
-            int sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample;
+            size_t sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample;
             
             if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())
             {
@@ -689,9 +674,9 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)
                 
                 if (audioFormat == WavAudioFormat::IEEEFloat && std::is_floating_point_v<T>) 
                 {
-                    float f;
-                    memcpy (&f, &sampleAsInt, sizeof(int32_t));
-                    sample = (T)f;
+                    float floatValue;
+                    memcpy (&floatValue, &sampleAsInt, sizeof(int32_t));
+                    sample = static_cast<T> (floatValue);
                 }
                 else // assume PCM
                 {
@@ -712,7 +697,7 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)
     if (indexOfXMLChunk != -1)
     {
         int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);
-        iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);
+        iXMLChunk = std::string (reinterpret_cast<const char*> (&fileData[indexOfXMLChunk + 8]), chunkSize);
     }
 
     return true;
@@ -751,7 +736,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)
     //int32_t commChunkSize = fourBytesToInt (fileData, p + 4, Endianness::BigEndian);
     int16_t numChannels = twoBytesToInt (fileData, p + 8, Endianness::BigEndian);
     int32_t numSamplesPerChannel = fourBytesToInt (fileData, p + 10, Endianness::BigEndian);
-    bitDepth = (int) twoBytesToInt (fileData, p + 14, Endianness::BigEndian);
+    bitDepth = static_cast<int> (twoBytesToInt (fileData, p + 14, Endianness::BigEndian));
     sampleRate = getAiffSampleRate (fileData, p + 16);
     
     if (bitDepth > sizeof (T) * 8)
@@ -797,10 +782,10 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)
     int numBytesPerSample = bitDepth / 8;
     int numBytesPerFrame = numBytesPerSample * numChannels;
     int totalNumAudioSampleBytes = numSamplesPerChannel * numBytesPerFrame;
-    int samplesStartIndex = s + 16 + (int)offset;
+    int samplesStartIndex = s + 16 + static_cast<int> (offset);
         
     // sanity check the data
-    if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes || totalNumAudioSampleBytes > static_cast<long>(fileData.size() - samplesStartIndex))
+    if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes || totalNumAudioSampleBytes > static_cast<long> (fileData.size() - samplesStartIndex))
     {
         reportError ("ERROR: the metadatafor this file doesn't seem right");
         return false;
@@ -813,7 +798,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)
     {
         for (int channel = 0; channel < numChannels; channel++)
         {
-            int sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample;
+            size_t sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample;
             
             if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())
             {
@@ -849,7 +834,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)
                 T sample;
                 
                 if (audioFormat == AIFFAudioFormat::Compressed)
-                    sample = (T)reinterpret_cast<float&> (sampleAsInt);
+                    sample = static_cast<T> (reinterpret_cast<float&> (sampleAsInt));
                 else // assume PCM
                     sample = AudioSampleConverter<T>::thirtyTwoBitIntToSample (sampleAsInt);
                 
@@ -867,7 +852,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)
     if (indexOfXMLChunk != -1)
     {
         int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);
-        iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);
+        iXMLChunk = std::string (reinterpret_cast<const char*> (&fileData[indexOfXMLChunk + 8]), chunkSize);
     }
     
     return true;
@@ -944,16 +929,16 @@ bool AudioFile<T>::encodeWaveFile (std::vector<uint8_t>& fileData)
     addStringToFileData (fileData, "fmt ");
     addInt32ToFileData (fileData, formatChunkSize); // format chunk size (16 for PCM)
     addInt16ToFileData (fileData, audioFormat); // audio format
-    addInt16ToFileData (fileData, (int16_t)getNumChannels()); // num channels
-    addInt32ToFileData (fileData, (int32_t)sampleRate); // sample rate
+    addInt16ToFileData (fileData, static_cast<int16_t> (getNumChannels())); // num channels
+    addInt32ToFileData (fileData, static_cast<int32_t> (sampleRate)); // sample rate
     
-    int32_t numBytesPerSecond = (int32_t) ((getNumChannels() * sampleRate * bitDepth) / 8);
+    int32_t numBytesPerSecond = static_cast<int32_t> ((getNumChannels() * sampleRate * bitDepth) / 8);
     addInt32ToFileData (fileData, numBytesPerSecond);
     
     int16_t numBytesPerBlock = getNumChannels() * (bitDepth / 8);
     addInt16ToFileData (fileData, numBytesPerBlock);
     
-    addInt16ToFileData (fileData, (int16_t)bitDepth);
+    addInt16ToFileData (fileData, static_cast<int16_t> (bitDepth));
     
     if (audioFormat == WavAudioFormat::IEEEFloat)
         addInt16ToFileData (fileData, 0); // extension size
@@ -982,29 +967,29 @@ bool AudioFile<T>::encodeWaveFile (std::vector<uint8_t>& fileData)
                 int32_t sampleAsIntAgain = AudioSampleConverter<T>::sampleToTwentyFourBitInt (samples[channel][i]);
                 
                 uint8_t bytes[3];
-                bytes[2] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;
-                bytes[1] = (uint8_t) (sampleAsIntAgain >>  8) & 0xFF;
-                bytes[0] = (uint8_t) sampleAsIntAgain & 0xFF;
+                bytes[2] = static_cast<uint8_t> ((sampleAsIntAgain >> 16) & 0xFF);
+                bytes[1] = static_cast<uint8_t> ((sampleAsIntAgain >>  8) & 0xFF);
+                bytes[0] = static_cast<uint8_t> (sampleAsIntAgain & 0xFF);
                 
                 fileData.push_back (bytes[0]);
                 fileData.push_back (bytes[1]);
                 fileData.push_back (bytes[2]);
             }
             else if (bitDepth == 32)
             {
-                int32_t sampleAsInt;
+                int32_t sampleAsInt = 0;
                 
                 if (audioFormat == WavAudioFormat::IEEEFloat)
                 {
                     if constexpr (std::is_same_v<T, float>)
                     {
-                        sampleAsInt = (int32_t) reinterpret_cast<int32_t&> (samples[channel][i]);
+                        sampleAsInt = reinterpret_cast<int32_t&> (samples[channel][i]);
                     }
                     else if constexpr (std::is_same_v<T, double>)
                     {
-                        auto sampleAsFloat = (float) samples[channel][i];
+                        auto sampleAsFloat = static_cast<float> (samples[channel][i]);
                         float& referenceToSample = sampleAsFloat;
-                        sampleAsInt = (int32_t) reinterpret_cast<int32_t&> (referenceToSample);
+                        sampleAsInt = reinterpret_cast<int32_t&> (referenceToSample);
                     }
                 }
                 else // assume PCM
@@ -1102,9 +1087,9 @@ bool AudioFile<T>::encodeAiffFile (std::vector<uint8_t>& fileData)
                 int32_t sampleAsIntAgain = AudioSampleConverter<T>::sampleToTwentyFourBitInt (samples[channel][i]);
                 
                 uint8_t bytes[3];
-                bytes[0] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;
-                bytes[1] = (uint8_t) (sampleAsIntAgain >>  8) & 0xFF;
-                bytes[2] = (uint8_t) sampleAsIntAgain & 0xFF;
+                bytes[0] = static_cast<uint8_t> ((sampleAsIntAgain >> 16) & 0xFF);
+                bytes[1] = static_cast<uint8_t> ((sampleAsIntAgain >>  8) & 0xFF);
+                bytes[2] = static_cast<uint8_t> (sampleAsIntAgain & 0xFF);
                 
                 fileData.push_back (bytes[0]);
                 fileData.push_back (bytes[1]);
@@ -1154,7 +1139,7 @@ bool AudioFile<T>::writeDataToFile (const std::vector<uint8_t>& fileData, std::s
         return false;
     }
 
-    outputFile.write ((const char*)fileData.data(), fileData.size());
+    outputFile.write (reinterpret_cast<const char*> (fileData.data()), fileData.size());
     outputFile.close();
     return true;
 }
@@ -1164,7 +1149,7 @@ template <class T>
 void AudioFile<T>::addStringToFileData (std::vector<uint8_t>& fileData, std::string s)
 {
     for (size_t i = 0; i < s.length();i++)
-        fileData.push_back ((uint8_t) s[i]);
+        fileData.push_back (static_cast<uint8_t> (s[i]));
 }
 
 //=============================================================
@@ -1423,7 +1408,7 @@ int32_t AudioSampleConverter<T>::sampleToTwentyFourBitInt (T sample)
     if constexpr (std::is_floating_point<T>::value)
     {
         sample = clamp (sample, -1., 1.);
-        return static_cast<int32_t> (sample * 8388607.);
+        return static_cast<int32_t> (sample * static_cast<T> (8388607.));
     }
     else
     {
@@ -1458,7 +1443,7 @@ int16_t AudioSampleConverter<T>::sampleToSixteenBitInt (T sample)
     if constexpr (std::is_floating_point<T>::value)
     {
         sample = clamp (sample, -1., 1.);
-        return static_cast<int16_t> (sample * 32767.);
+        return static_cast<int16_t> (sample * static_cast<T> (32767.));
     }
     else
     {
@@ -1476,7 +1461,7 @@ uint8_t AudioSampleConverter<T>::sampleToUnsignedByte (T sample)
     if constexpr (std::is_floating_point<T>::value)
     {
         sample = clamp (sample, -1., 1.);
-        sample = (sample + 1.) / 2.;
+        sample = (sample + static_cast<T> (1.)) / static_cast<T> (2.);
         return static_cast<uint8_t> (1 + (sample * 254));
     }
     else
@@ -1495,7 +1480,7 @@ int8_t AudioSampleConverter<T>::sampleToSignedByte (T sample)
     if constexpr (std::is_floating_point<T>::value)
     {
         sample = clamp (sample, -1., 1.);
-        return static_cast<int8_t> (sample * (T)0x7F);
+        return static_cast<int8_t> (sample * static_cast<T> (0x7F));
     }
     else
     {
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,7 +1,7 @@
 #===============================================================================
 cmake_minimum_required (VERSION 3.12)
 
-project ("AudioFile" VERSION 1.1.3
+project ("AudioFile" VERSION 1.1.4
                      DESCRIPTION "A simple C++ library for reading and writing audio files."
                      HOMEPAGE_URL "https://github.com/adamstark/AudioFile")
 
diff --git a/README.md b/README.md
@@ -2,7 +2,7 @@
 
 <!-- Version and License Badges -->
 
-![Version](https://img.shields.io/badge/version-1.1.3-green.svg?style=flat-square)
+![Version](https://img.shields.io/badge/version-1.1.4-green.svg?style=flat-square)
 ![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)
 ![Language](https://img.shields.io/badge/language-C++-yellow.svg?style=flat-square)
 
@@ -189,6 +189,10 @@ If you prefer not to see these messages, you can disable this error logging beha
 
 ## Versions
 
+##### 1.1.4 - 15th Oct 2025
+
+- Bug fixes and code improvements
+
 ##### 1.1.3 - 31st May 2025
 
 - Added saveToMemory() function to save audio data to bytes
@@ -263,6 +267,7 @@ Many thanks to the following people for their contributions to this library:
 - [BenjaminHinchliff](https://github.com/BenjaminHinchliff)
 - [BesselJ](https://github.com/BesselJ)
 - [cgraf78](https://github.com/cgraf78)
+- [danielzgtg](https://github.com/danielzgtg)
 - [emiro85](https://github.com/emiro85)
 - [encoded](https://github.com/encoded)
 - [gitelope](https://github.com/gitelope)
@@ -277,6 +282,7 @@ Many thanks to the following people for their contributions to this library:
 - [Sidelobe](https://github.com/Sidelobe)
 - [sschaetz](https://github.com/sschaetz)
 - [Yhcrown](https://github.com/Yhcrown)
+- [zhouchanglin-rr](https://github.com/zhouchanglin-rr)
 
 ## Want to Contribute?
 
diff --git a/tests/FileWritingTests.cpp b/tests/FileWritingTests.cpp
@@ -14,7 +14,7 @@ template <typename T>
 void writeTestAudioFile (int numChannels, int sampleRate, int bitDepth, AudioFileFormat format)
 {
     std::string sampleType;
-    float sampleRateAsFloat = (float) sampleRate;
+    float sampleRateAsFloat = static_cast<float> (sampleRate);
     
     AudioFile<T> audioFileWriter;
     
@@ -47,12 +47,12 @@ void writeTestAudioFile (int numChannels, int sampleRate, int bitDepth, AudioFil
         T sample;
         
         if constexpr (std::numeric_limits<T>::is_integer && std::is_unsigned_v<T>)
-            sample = (T)(((sinf (2. * M_PI * ((double) i / sampleRateAsFloat) * 440.) + 1.) / 2.) * maxValue);
+            sample = static_cast<T> (((sin (2. * M_PI * (static_cast<double> (i) / static_cast<double> (sampleRateAsFloat)) * 440.) + 1.) / 2.) * maxValue);
         else
-            sample = (T)(sinf (2. * M_PI * ((double) i / sampleRateAsFloat) * 440.) * maxValue);
+            sample = static_cast<T> (sin (2. * M_PI * (static_cast<double> (i) / static_cast<double> (sampleRateAsFloat)) * 440.) * static_cast<double> (maxValue));
         
         for (int k = 0; k < audioFileWriter.getNumChannels(); k++)
-            audioFileWriter.samples[k][i] = sample * 0.5f;
+            audioFileWriter.samples[k][i] = sample * static_cast<T> (0.5);
     }
     
     audioFileWriter.setSampleRate (sampleRate);
diff --git a/tests/SampleConversionTests.cpp b/tests/SampleConversionTests.cpp
@@ -103,7 +103,7 @@ TEST_SUITE ("SampleConversionTests::8-bit Conversions - sampleToSignedByte()")
         REQUIRE_EQ (AudioSampleConverter<float>::sampleToSignedByte (-1.f), -127);
         REQUIRE_EQ (AudioSampleConverter<float>::sampleToSignedByte (std::numeric_limits<float>::lowest()), -127);
         
-        REQUIRE_EQ (AudioSampleConverter<double>::sampleToSignedByte (std::numeric_limits<float>::max()), 127);
+        REQUIRE_EQ (AudioSampleConverter<double>::sampleToSignedByte (std::numeric_limits<double>::max()), 127);
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToSignedByte (1.), 127);
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToSignedByte (0.5), 63);
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToSignedByte (0.), 0);
@@ -717,10 +717,10 @@ TEST_SUITE ("SampleConversionTests::32-bit Conversions")
         REQUIRE_EQ (AudioSampleConverter<float>::sampleToThirtyTwoBitInt (std::numeric_limits<float>::lowest()), -2147483647);
         
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (std::numeric_limits<double>::max()), 2147483647);
-        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (1.f), 2147483647);
-        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (0.5f), 1073741823);
-        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (0.f), 0);
-        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (-0.5f), -1073741823);
+        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (1.), 2147483647);
+        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (0.5), 1073741823);
+        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (0.), 0);
+        REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (-0.5), -1073741823);
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (-1.), -2147483647);
         REQUIRE_EQ (AudioSampleConverter<double>::sampleToThirtyTwoBitInt (std::numeric_limits<double>::lowest()), -2147483647);
     }

Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,6 @@ class AudioFile`
`207`	`207`
`208`	`208`	`static inline int32_t fourBytesToInt (const std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);`
`209`	`209`	`static inline int16_t twoBytesToInt (const std::vector<uint8_t>& source, int startIndex, Endianness endianness = Endianness::LittleEndian);`
`210`		`- static inline int getIndexOfString (const std::vector<uint8_t>& source, std::string s);`
`211`	`210`	`static inline int getIndexOfChunk (const std::vector<uint8_t>& source, const std::string& chunkHeaderID, int startIndex, Endianness endianness = Endianness::LittleEndian);`
`212`	`211`
`213`	`212`	`//=============================================================`
`@@ -339,7 +338,7 @@ uint32_t AudioFile<T>::getSampleRate() const`
`339`	`338`	`template <class T>`
`340`	`339`	`int AudioFile<T>::getNumChannels() const`
`341`	`340`	`{`
`342`		`- return (int)samples.size();`
	`341`	`+ return static_cast<int> (samples.size());`
`343`	`342`	`}`
`344`	`343`
`345`	`344`	`//=============================================================`
`@@ -368,7 +367,7 @@ template <class T>`
`368`	`367`	`int AudioFile<T>::getNumSamplesPerChannel() const`
`369`	`368`	`{`
`370`	`369`	`if (samples.size() > 0)`
`371`		`- return (int) samples[0].size();`
	`370`	`+ return static_cast<int> (samples[0].size());`
`372`	`371`	`else`
`373`	`372`	`return 0;`
`374`	`373`	`}`
`@@ -377,7 +376,7 @@ int AudioFile<T>::getNumSamplesPerChannel() const`
`377`	`376`	`template <class T>`
`378`	`377`	`double AudioFile<T>::getLengthInSeconds() const`
`379`	`378`	`{`
`380`		`- return (double)getNumSamplesPerChannel() / (double)sampleRate;`
	`379`	`+ return static_cast<double> (getNumSamplesPerChannel()) / static_cast<double> (sampleRate);`
`381`	`380`	`}`
`382`	`381`
`383`	`382`	`//=============================================================`
`@@ -397,7 +396,7 @@ void AudioFile<T>::printSummary() const`
`397`	`396`	`template <class T>`
`398`	`397`	`bool AudioFile<T>::setAudioBuffer (const AudioBuffer& newBuffer)`
`399`	`398`	`{`
`400`		`- int numChannels = (int)newBuffer.size();`
	`399`	`+ int numChannels = static_cast<int> (newBuffer.size());`
`401`	`400`
`402`	`401`	`if (numChannels <= 0)`
`403`	`402`	`{`
`@@ -437,16 +436,8 @@ void AudioFile<T>::setAudioBufferSize (int numChannels, int numSamples)`
`437`	`436`	`template <class T>`
`438`	`437`	`void AudioFile<T>::setNumSamplesPerChannel (int numSamples)`
`439`	`438`	`{`
`440`		`- int originalSize = getNumSamplesPerChannel();`
`441`		`-`
`442`	`439`	`for (int i = 0; i < getNumChannels();i++)`
`443`		`- {`
`444`		`- samples[i].resize (numSamples);`
`445`		`-`
`446`		`- // set any new samples to zero`
`447`		`- if (numSamples > originalSize)`
`448`		`- std::fill (samples[i].begin() + originalSize, samples[i].end(), (T)0.);`
`449`		`- }`
	`440`	`+ samples[i].resize (numSamples, static_cast<T> (0));`
`450`	`441`	`}`
`451`	`442`
`452`	`443`	`//=============================================================`
`@@ -460,14 +451,8 @@ void AudioFile<T>::setNumChannels (int numChannels)`
`460`	`451`
`461`	`452`	`// make sure any new channels are set to the right size`
`462`	`453`	`// and filled with zeros`
`463`		`- if (numChannels > originalNumChannels)`
`464`		`- {`
`465`		`- for (int i = originalNumChannels; i < numChannels; i++)`
`466`		`- {`
`467`		`- samples[i].resize (originalNumSamplesPerChannel);`
`468`		`- std::fill (samples[i].begin(), samples[i].end(), (T)0.);`
`469`		`- }`
`470`		`- }`
	`454`	`+ for (int i = originalNumChannels; i < numChannels; i++)`
	`455`	`+ samples[i].resize (originalNumSamplesPerChannel, static_cast<T> (0));`
`471`	`456`	`}`
`472`	`457`
`473`	`458`	`//=============================================================`
`@@ -590,10 +575,10 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)`
`590`	`575`	`//int32_t formatChunkSize = fourBytesToInt (fileData, f + 4);`
`591`	`576`	`uint16_t audioFormat = twoBytesToInt (fileData, f + 8);`
`592`	`577`	`uint16_t numChannels = twoBytesToInt (fileData, f + 10);`
`593`		`- sampleRate = (uint32_t) fourBytesToInt (fileData, f + 12);`
	`578`	`+ sampleRate = static_cast<uint32_t> (fourBytesToInt (fileData, f + 12));`
`594`	`579`	`uint32_t numBytesPerSecond = fourBytesToInt (fileData, f + 16);`
`595`	`580`	`uint16_t numBytesPerBlock = twoBytesToInt (fileData, f + 20);`
`596`		`- bitDepth = (int) twoBytesToInt (fileData, f + 22);`
	`581`	`+ bitDepth = static_cast<int> (twoBytesToInt (fileData, f + 22));`
`597`	`582`
`598`	`583`	`if (bitDepth > sizeof (T) * 8)`
`599`	`584`	`{`
`@@ -652,7 +637,7 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)`
`652`	`637`	`{`
`653`	`638`	`for (int channel = 0; channel < numChannels; channel++)`
`654`	`639`	`{`
`655`		`- int sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample;`
	`640`	`+ size_t sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample;`
`656`	`641`
`657`	`642`	`if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())`
`658`	`643`	`{`
`@@ -689,9 +674,9 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)`
`689`	`674`
`690`	`675`	`if (audioFormat == WavAudioFormat::IEEEFloat && std::is_floating_point_v<T>)`
`691`	`676`	`{`
`692`		`- float f;`
`693`		`- memcpy (&f, &sampleAsInt, sizeof(int32_t));`
`694`		`- sample = (T)f;`
	`677`	`+ float floatValue;`
	`678`	`+ memcpy (&floatValue, &sampleAsInt, sizeof(int32_t));`
	`679`	`+ sample = static_cast<T> (floatValue);`
`695`	`680`	`}`
`696`	`681`	`else // assume PCM`
`697`	`682`	`{`
`@@ -712,7 +697,7 @@ bool AudioFile<T>::decodeWaveFile (const std::vector<uint8_t>& fileData)`
`712`	`697`	`if (indexOfXMLChunk != -1)`
`713`	`698`	`{`
`714`	`699`	`int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);`
`715`		`- iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);`
	`700`	`+ iXMLChunk = std::string (reinterpret_cast<const char*> (&fileData[indexOfXMLChunk + 8]), chunkSize);`
`716`	`701`	`}`
`717`	`702`
`718`	`703`	`return true;`
`@@ -751,7 +736,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)`
`751`	`736`	`//int32_t commChunkSize = fourBytesToInt (fileData, p + 4, Endianness::BigEndian);`
`752`	`737`	`int16_t numChannels = twoBytesToInt (fileData, p + 8, Endianness::BigEndian);`
`753`	`738`	`int32_t numSamplesPerChannel = fourBytesToInt (fileData, p + 10, Endianness::BigEndian);`
`754`		`- bitDepth = (int) twoBytesToInt (fileData, p + 14, Endianness::BigEndian);`
	`739`	`+ bitDepth = static_cast<int> (twoBytesToInt (fileData, p + 14, Endianness::BigEndian));`
`755`	`740`	`sampleRate = getAiffSampleRate (fileData, p + 16);`
`756`	`741`
`757`	`742`	`if (bitDepth > sizeof (T) * 8)`
`@@ -797,10 +782,10 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)`
`797`	`782`	`int numBytesPerSample = bitDepth / 8;`
`798`	`783`	`int numBytesPerFrame = numBytesPerSample * numChannels;`
`799`	`784`	`int totalNumAudioSampleBytes = numSamplesPerChannel * numBytesPerFrame;`
`800`		`- int samplesStartIndex = s + 16 + (int)offset;`
	`785`	`+ int samplesStartIndex = s + 16 + static_cast<int> (offset);`
`801`	`786`
`802`	`787`	`// sanity check the data`
`803`		`- if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes \|\| totalNumAudioSampleBytes > static_cast<long>(fileData.size() - samplesStartIndex))`
	`788`	`+ if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes \|\| totalNumAudioSampleBytes > static_cast<long> (fileData.size() - samplesStartIndex))`
`804`	`789`	`{`
`805`	`790`	`reportError ("ERROR: the metadatafor this file doesn't seem right");`
`806`	`791`	`return false;`
`@@ -813,7 +798,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)`
`813`	`798`	`{`
`814`	`799`	`for (int channel = 0; channel < numChannels; channel++)`
`815`	`800`	`{`
`816`		`- int sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample;`
	`801`	`+ size_t sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample;`
`817`	`802`
`818`	`803`	`if ((sampleIndex + (bitDepth / 8) - 1) >= fileData.size())`
`819`	`804`	`{`
`@@ -849,7 +834,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)`
`849`	`834`	`T sample;`
`850`	`835`
`851`	`836`	`if (audioFormat == AIFFAudioFormat::Compressed)`
`852`		`- sample = (T)reinterpret_cast<float&> (sampleAsInt);`
	`837`	`+ sample = static_cast<T> (reinterpret_cast<float&> (sampleAsInt));`
`853`	`838`	`else // assume PCM`
`854`	`839`	`sample = AudioSampleConverter<T>::thirtyTwoBitIntToSample (sampleAsInt);`
`855`	`840`
`@@ -867,7 +852,7 @@ bool AudioFile<T>::decodeAiffFile (const std::vector<uint8_t>& fileData)`
`867`	`852`	`if (indexOfXMLChunk != -1)`
`868`	`853`	`{`
`869`	`854`	`int32_t chunkSize = fourBytesToInt (fileData, indexOfXMLChunk + 4);`
`870`		`- iXMLChunk = std::string ((const char*) &fileData[indexOfXMLChunk + 8], chunkSize);`
	`855`	`+ iXMLChunk = std::string (reinterpret_cast<const char*> (&fileData[indexOfXMLChunk + 8]), chunkSize);`
`871`	`856`	`}`
`872`	`857`
`873`	`858`	`return true;`
`@@ -944,16 +929,16 @@ bool AudioFile<T>::encodeWaveFile (std::vector<uint8_t>& fileData)`
`944`	`929`	`addStringToFileData (fileData, "fmt ");`
`945`	`930`	`addInt32ToFileData (fileData, formatChunkSize); // format chunk size (16 for PCM)`
`946`	`931`	`addInt16ToFileData (fileData, audioFormat); // audio format`
`947`		`- addInt16ToFileData (fileData, (int16_t)getNumChannels()); // num channels`
`948`		`- addInt32ToFileData (fileData, (int32_t)sampleRate); // sample rate`
	`932`	`+ addInt16ToFileData (fileData, static_cast<int16_t> (getNumChannels())); // num channels`
	`933`	`+ addInt32ToFileData (fileData, static_cast<int32_t> (sampleRate)); // sample rate`
`949`	`934`
`950`		`- int32_t numBytesPerSecond = (int32_t) ((getNumChannels() * sampleRate * bitDepth) / 8);`
	`935`	`+ int32_t numBytesPerSecond = static_cast<int32_t> ((getNumChannels() * sampleRate * bitDepth) / 8);`
`951`	`936`	`addInt32ToFileData (fileData, numBytesPerSecond);`
`952`	`937`
`953`	`938`	`int16_t numBytesPerBlock = getNumChannels() * (bitDepth / 8);`
`954`	`939`	`addInt16ToFileData (fileData, numBytesPerBlock);`
`955`	`940`
`956`		`- addInt16ToFileData (fileData, (int16_t)bitDepth);`
	`941`	`+ addInt16ToFileData (fileData, static_cast<int16_t> (bitDepth));`
`957`	`942`
`958`	`943`	`if (audioFormat == WavAudioFormat::IEEEFloat)`
`959`	`944`	`addInt16ToFileData (fileData, 0); // extension size`
`@@ -982,29 +967,29 @@ bool AudioFile<T>::encodeWaveFile (std::vector<uint8_t>& fileData)`
`982`	`967`	`int32_t sampleAsIntAgain = AudioSampleConverter<T>::sampleToTwentyFourBitInt (samples[channel][i]);`
`983`	`968`
`984`	`969`	`uint8_t bytes[3];`
`985`		`- bytes[2] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;`
`986`		`- bytes[1] = (uint8_t) (sampleAsIntAgain >> 8) & 0xFF;`
`987`		`- bytes[0] = (uint8_t) sampleAsIntAgain & 0xFF;`
	`970`	`+ bytes[2] = static_cast<uint8_t> ((sampleAsIntAgain >> 16) & 0xFF);`
	`971`	`+ bytes[1] = static_cast<uint8_t> ((sampleAsIntAgain >> 8) & 0xFF);`
	`972`	`+ bytes[0] = static_cast<uint8_t> (sampleAsIntAgain & 0xFF);`
`988`	`973`
`989`	`974`	`fileData.push_back (bytes[0]);`
`990`	`975`	`fileData.push_back (bytes[1]);`
`991`	`976`	`fileData.push_back (bytes[2]);`
`992`	`977`	`}`
`993`	`978`	`else if (bitDepth == 32)`
`994`	`979`	`{`
`995`		`- int32_t sampleAsInt;`
	`980`	`+ int32_t sampleAsInt = 0;`
`996`	`981`
`997`	`982`	`if (audioFormat == WavAudioFormat::IEEEFloat)`
`998`	`983`	`{`
`999`	`984`	`if constexpr (std::is_same_v<T, float>)`
`1000`	`985`	`{`
`1001`		`- sampleAsInt = (int32_t) reinterpret_cast<int32_t&> (samples[channel][i]);`
	`986`	`+ sampleAsInt = reinterpret_cast<int32_t&> (samples[channel][i]);`
`1002`	`987`	`}`
`1003`	`988`	`else if constexpr (std::is_same_v<T, double>)`
`1004`	`989`	`{`
`1005`		`- auto sampleAsFloat = (float) samples[channel][i];`
	`990`	`+ auto sampleAsFloat = static_cast<float> (samples[channel][i]);`
`1006`	`991`	`float& referenceToSample = sampleAsFloat;`
`1007`		`- sampleAsInt = (int32_t) reinterpret_cast<int32_t&> (referenceToSample);`
	`992`	`+ sampleAsInt = reinterpret_cast<int32_t&> (referenceToSample);`
`1008`	`993`	`}`
`1009`	`994`	`}`
`1010`	`995`	`else // assume PCM`
`@@ -1102,9 +1087,9 @@ bool AudioFile<T>::encodeAiffFile (std::vector<uint8_t>& fileData)`
`1102`	`1087`	`int32_t sampleAsIntAgain = AudioSampleConverter<T>::sampleToTwentyFourBitInt (samples[channel][i]);`
`1103`	`1088`
`1104`	`1089`	`uint8_t bytes[3];`
`1105`		`- bytes[0] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF;`
`1106`		`- bytes[1] = (uint8_t) (sampleAsIntAgain >> 8) & 0xFF;`
`1107`		`- bytes[2] = (uint8_t) sampleAsIntAgain & 0xFF;`
	`1090`	`+ bytes[0] = static_cast<uint8_t> ((sampleAsIntAgain >> 16) & 0xFF);`
	`1091`	`+ bytes[1] = static_cast<uint8_t> ((sampleAsIntAgain >> 8) & 0xFF);`
	`1092`	`+ bytes[2] = static_cast<uint8_t> (sampleAsIntAgain & 0xFF);`
`1108`	`1093`
`1109`	`1094`	`fileData.push_back (bytes[0]);`
`1110`	`1095`	`fileData.push_back (bytes[1]);`
`@@ -1154,7 +1139,7 @@ bool AudioFile<T>::writeDataToFile (const std::vector<uint8_t>& fileData, std::s`
`1154`	`1139`	`return false;`
`1155`	`1140`	`}`
`1156`	`1141`
`1157`		`- outputFile.write ((const char*)fileData.data(), fileData.size());`
	`1142`	`+ outputFile.write (reinterpret_cast<const char*> (fileData.data()), fileData.size());`
`1158`	`1143`	`outputFile.close();`
`1159`	`1144`	`return true;`
`1160`	`1145`	`}`
`@@ -1164,7 +1149,7 @@ template <class T>`
`1164`	`1149`	`void AudioFile<T>::addStringToFileData (std::vector<uint8_t>& fileData, std::string s)`
`1165`	`1150`	`{`
`1166`	`1151`	`for (size_t i = 0; i < s.length();i++)`
`1167`		`- fileData.push_back ((uint8_t) s[i]);`
	`1152`	`+ fileData.push_back (static_cast<uint8_t> (s[i]));`
`1168`	`1153`	`}`
`1169`	`1154`
`1170`	`1155`	`//=============================================================`
`@@ -1423,7 +1408,7 @@ int32_t AudioSampleConverter<T>::sampleToTwentyFourBitInt (T sample)`
`1423`	`1408`	`if constexpr (std::is_floating_point<T>::value)`
`1424`	`1409`	`{`
`1425`	`1410`	`sample = clamp (sample, -1., 1.);`
`1426`		`- return static_cast<int32_t> (sample * 8388607.);`
	`1411`	`+ return static_cast<int32_t> (sample * static_cast<T> (8388607.));`
`1427`	`1412`	`}`
`1428`	`1413`	`else`
`1429`	`1414`	`{`
`@@ -1458,7 +1443,7 @@ int16_t AudioSampleConverter<T>::sampleToSixteenBitInt (T sample)`
`1458`	`1443`	`if constexpr (std::is_floating_point<T>::value)`
`1459`	`1444`	`{`
`1460`	`1445`	`sample = clamp (sample, -1., 1.);`
`1461`		`- return static_cast<int16_t> (sample * 32767.);`
	`1446`	`+ return static_cast<int16_t> (sample * static_cast<T> (32767.));`
`1462`	`1447`	`}`
`1463`	`1448`	`else`
`1464`	`1449`	`{`
`@@ -1476,7 +1461,7 @@ uint8_t AudioSampleConverter<T>::sampleToUnsignedByte (T sample)`
`1476`	`1461`	`if constexpr (std::is_floating_point<T>::value)`
`1477`	`1462`	`{`
`1478`	`1463`	`sample = clamp (sample, -1., 1.);`
`1479`		`- sample = (sample + 1.) / 2.;`
	`1464`	`+ sample = (sample + static_cast<T> (1.)) / static_cast<T> (2.);`
`1480`	`1465`	`return static_cast<uint8_t> (1 + (sample * 254));`
`1481`	`1466`	`}`
`1482`	`1467`	`else`
`@@ -1495,7 +1480,7 @@ int8_t AudioSampleConverter<T>::sampleToSignedByte (T sample)`
`1495`	`1480`	`if constexpr (std::is_floating_point<T>::value)`
`1496`	`1481`	`{`
`1497`	`1482`	`sample = clamp (sample, -1., 1.);`
`1498`		`- return static_cast<int8_t> (sample * (T)0x7F);`
	`1483`	`+ return static_cast<int8_t> (sample * static_cast<T> (0x7F));`
`1499`	`1484`	`}`
`1500`	`1485`	`else`
`1501`	`1486`	`{`