diff --git a/include/ggwave/ggwave.h b/include/ggwave/ggwave.h
index c781b55..b89fd30 100644
--- a/include/ggwave/ggwave.h
+++ b/include/ggwave/ggwave.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <array>
 #include <cstdint>
 #include <functional>
 #include <vector>
@@ -40,11 +39,11 @@ public:
         { "[U] Fastest", 320, 3, 3, },
     };
 
-    using AmplitudeData   = std::array<float, kMaxSamplesPerFrame>;
-    using AmplitudeData16 = std::array<int16_t, kMaxRecordedFrames*kMaxSamplesPerFrame>;
-    using SpectrumData    = std::array<float, kMaxSamplesPerFrame>;
-    using RecordedData    = std::array<float, kMaxRecordedFrames*kMaxSamplesPerFrame>;
-    using TxRxData        = std::array<std::uint8_t, kMaxDataSize>;
+    using AmplitudeData   = std::vector<float>;
+    using AmplitudeData16 = std::vector<int16_t>;
+    using SpectrumData    = std::vector<float>;
+    using RecordedData    = std::vector<float>;
+    using TxRxData        = std::vector<std::uint8_t>;
 
     using CBQueueAudio = std::function<void(const void * data, uint32_t nBytes)>;
     using CBDequeueAudio = std::function<uint32_t(void * data, uint32_t nMaxBytes)>;
@@ -120,11 +119,11 @@ private:
     int m_framesToAnalyze;
     int m_framesToRecord;
 
-    std::array<float, kMaxSamplesPerFrame> m_fftIn;    // real
-    std::array<float, 2*kMaxSamplesPerFrame> m_fftOut; // complex
+    std::vector<float> m_fftIn;  // real
+    std::vector<float> m_fftOut; // complex
 
-    AmplitudeData m_sampleAmplitude;
     SpectrumData m_sampleSpectrum;
+    AmplitudeData m_sampleAmplitude;
 
     bool m_hasNewRxData;
     int m_lastRxDataLength;
@@ -134,7 +133,7 @@ private:
 
     int m_historyId = 0;
     AmplitudeData m_sampleAmplitudeAverage;
-    std::array<AmplitudeData, kMaxSpectrumHistory> m_sampleAmplitudeHistory;
+    std::vector<AmplitudeData> m_sampleAmplitudeHistory;
 
     RecordedData m_recordedAmplitude;
 
diff --git a/src/ggwave.cpp b/src/ggwave.cpp
index dd7a7f8..c43c3bd 100644
--- a/src/ggwave.cpp
+++ b/src/ggwave.cpp
@@ -147,6 +147,16 @@ GGWave::GGWave(
     m_nMarkerFrames(16),
     m_nPostMarkerFrames(0),
     m_encodedDataOffset(3),
+    m_fftIn(kMaxSamplesPerFrame),
+    m_fftOut(2*kMaxSamplesPerFrame),
+    m_sampleSpectrum(kMaxSamplesPerFrame),
+    m_sampleAmplitude(kMaxSamplesPerFrame),
+    m_rxData(kMaxDataSize),
+    m_sampleAmplitudeAverage(kMaxSamplesPerFrame),
+    m_sampleAmplitudeHistory(kMaxSpectrumHistory),
+    m_recordedAmplitude(kMaxRecordedFrames*kMaxSamplesPerFrame),
+    m_txData(kMaxDataSize),
+    m_txDataEncoded(kMaxDataSize),
     m_rsLength(new RS::ReedSolomon(1, m_encodedDataOffset - 1))
 {
     init(0, "", getDefultTxProtocol(), 0);
@@ -168,8 +178,8 @@ bool GGWave::init(int textLength, const char * stext, const TxProtocol & aProtoc
     const uint8_t * text = reinterpret_cast<const uint8_t *>(stext);
 
     m_hasNewTxData = false;
-    m_txData.fill(0);
-    m_txDataEncoded.fill(0);
+    std::fill(m_txData.begin(), m_txData.end(), 0);
+    std::fill(m_txDataEncoded.begin(), m_txDataEncoded.end(), 0);
 
     if (m_txDataLength > 0) {
         m_txData[0] = m_txDataLength;
@@ -187,13 +197,14 @@ bool GGWave::init(int textLength, const char * stext, const TxProtocol & aProtoc
     m_framesToRecord = 0;
     m_framesLeftToRecord = 0;
 
-    m_sampleAmplitude.fill(0);
-    m_sampleSpectrum.fill(0);
+    std::fill(m_sampleSpectrum.begin(), m_sampleSpectrum.end(), 0);
+    std::fill(m_sampleAmplitude.begin(), m_sampleAmplitude.end(), 0);
     for (auto & s : m_sampleAmplitudeHistory) {
-        s.fill(0);
+        s.resize(kMaxSamplesPerFrame);
+        std::fill(s.begin(), s.end(), 0);
     }
 
-    m_rxData.fill(0);
+    std::fill(m_rxData.begin(), m_rxData.end(), 0);
 
     for (int i = 0; i < m_samplesPerFrame; ++i) {
         m_fftOut[2*i + 0] = 0.0f;
@@ -211,10 +222,10 @@ void GGWave::send(const CBQueueAudio & cbQueueAudio) {
 
     int frameId = 0;
 
-    AmplitudeData outputBlock;
-    AmplitudeData16 outputBlock16;
+    AmplitudeData outputBlock(kMaxSamplesPerFrame);
+    AmplitudeData16 outputBlock16(kMaxRecordedFrames*kMaxSamplesPerFrame);
 
-    std::array<double, kMaxDataBits> phaseOffsets;
+    std::vector<double> phaseOffsets(kMaxDataBits);
 
     for (int k = 0; k < (int) phaseOffsets.size(); ++k) {
         phaseOffsets[k] = (M_PI*k)/(m_txProtocol.nDataBitsPerTx());
@@ -226,14 +237,17 @@ void GGWave::send(const CBQueueAudio & cbQueueAudio) {
 
     std::shuffle(phaseOffsets.begin(), phaseOffsets.end(), g);
 
-    std::array<bool, kMaxDataBits> dataBits;
+    std::vector<bool> dataBits(kMaxDataBits);
 
-    std::array<AmplitudeData, kMaxDataBits> bit1Amplitude;
-    std::array<AmplitudeData, kMaxDataBits> bit0Amplitude;
+    std::vector<AmplitudeData> bit1Amplitude(kMaxDataBits);
+    std::vector<AmplitudeData> bit0Amplitude(kMaxDataBits);
 
     for (int k = 0; k < (int) dataBits.size(); ++k) {
         double freq = bitFreq(m_txProtocol, k);
 
+        bit1Amplitude[k].resize(kMaxSamplesPerFrame);
+        bit0Amplitude[k].resize(kMaxSamplesPerFrame);
+
         double phaseOffset = phaseOffsets[k];
         double curHzPerSample = m_sampleRateOut/m_samplesPerFrame;
         double curIHzPerSample = 1.0/curHzPerSample;
@@ -305,7 +319,7 @@ void GGWave::send(const CBQueueAudio & cbQueueAudio) {
             dataOffset /= m_txProtocol.framesPerTx;
             dataOffset *= m_txProtocol.bytesPerTx;
 
-            dataBits.fill(0);
+            std::fill(dataBits.begin(), dataBits.end(), 0);
 
             for (int j = 0; j < m_txProtocol.bytesPerTx; ++j) {
                 {
@@ -581,8 +595,8 @@ void GGWave::receive(const CBDequeueAudio & CBDequeueAudio) {
                     std::time_t timestamp = std::time(nullptr);
                     printf("%sReceiving sound data ...\n", std::asctime(std::localtime(&timestamp)));
 
-                    m_rxData.fill(0);
                     m_receivingData = true;
+                    std::fill(m_rxData.begin(), m_rxData.end(), 0);
 
                     // max recieve duration
                     m_recvDuration_frames =