Codecs: void* to uint8_t*

examples/build-arch-log.txt

@@ -7,4 +7,4 @@ esp8266:esp8266:generic ./examples-stream/streams-generator-serial -> rc=0
 rp2040:rp2040:generic ./examples-stream/streams-generator-serial -> rc=0
 arduino:avr:nano ./examples-stream/streams-generator-serial -> rc=0
 arduino:samd:arduino_zero_native ./examples-stream/streams-generator-serial -> rc=0
-arduino:renesas_uno:unor4wifi ./examples-stream/streams-generator-serial -> rc=1
+arduino:renesas_uno:unor4wifi ./examples-stream/streams-generator-serial -> rc=0

src/AudioAnalog/AnalogAudioArduino.h

@@ -72,11 +72,11 @@ class AnalogAudioArduino : public AudioStream {
   };
 
   /// Provides the sampled audio data
-  size_t readBytes(uint8_t *values, size_t len) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (config.rx_tx_mode == TX_MODE) return 0;
     if (buffer == nullptr) return 0;
     int bytes = len / frame_size * frame_size;
-    return buffer->readArray(values, bytes);
+    return buffer->readArray(data, bytes);
   }
 
   int availableForWrite() override {

src/AudioAnalog/AnalogAudioStream.h

@@ -78,13 +78,13 @@ class AnalogAudioStream  : public AudioStream {
     }
 
      /// ESP32 only: writes the data to the I2S interface
-    size_t write(const uint8_t *src, size_t size_bytes) override { 
+    size_t write(const uint8_t *data, size_t len) override { 
       TRACED();
-      return p_analog->write(src, size_bytes);
+      return p_analog->write(data, len);
     }   
 
-    size_t readBytes(uint8_t *dest, size_t size_bytes) override {
+    size_t readBytes(uint8_t *data, size_t len) override {
-        return p_analog->readBytes(dest, size_bytes);
+        return p_analog->readBytes(data, len);
     }
 
     int available() override {

src/AudioAnalog/AnalogConfigStd.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "AudioConfig.h"
-#if defined(USE_ANALOG) 
+//#if defined(USE_ANALOG) 
 
 #ifndef PIN_ANALOG_START
 #  define PIN_ANALOG_START 1
@@ -57,4 +57,4 @@ using AnalogConfig = AnalogConfigStd;
 #endif
 
 } // ns
-#endif
+#//endif

src/AudioAnalog/AnalogDriverArduino.h

@@ -4,7 +4,7 @@
 #if defined(USE_ANALOG_ARDUINO) || defined(DOXYGEN)
 
 #include <limits.h>  // for INT_MIN and INT_MAX
-#include "AudioAnalog/AnalogAudioBase.h"
+#include "AudioAnalog/AnalogAudioArduino.h"
 #include "AudioTimer/AudioTimer.h"
 #include "AudioTools/AudioStreams.h"
 #include "AudioTools/AudioTypes.h"

src/AudioCodecs/AudioCodecsBase.h

@@ -138,9 +138,9 @@ class CodecNOP : public AudioDecoder, public AudioEncoder {
   virtual int readStream(Stream &in) { return 0; };
 
   // just output silence
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    memset((void *)in_ptr, 0, in_size);
+    memset((void *)data, 0, len);
-    return in_size;
+    return len;
   }
 
   virtual const char *mime() { return nullptr; }
@@ -198,7 +198,7 @@ class StreamingDecoder : public AudioInfoSource {
   virtual bool copy() = 0;
 
  protected:
-  virtual size_t readBytes(uint8_t *buffer, size_t len) = 0;
+  virtual size_t readBytes(uint8_t *data, size_t len) = 0;
   Print *p_print = nullptr;
   Stream *p_input = nullptr;
 };
@@ -248,9 +248,9 @@ class StreamingDecoderAdapter : public StreamingDecoder {
   AudioDecoder *p_decoder = nullptr;
   Vector<uint8_t> buffer{0};
 
-  size_t readBytes(uint8_t *buffer, size_t len) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (p_input == nullptr) return 0;
-    return p_input->readBytes(buffer, len);
+    return p_input->readBytes(data, len);
   }
 };
 

src/AudioCodecs/AudioEncoded.h

@@ -352,8 +352,8 @@ class EncodedAudioStream : public ReformatBaseStream {
     return enc_out.write(data, len);
   }
 
-  size_t readBytes(uint8_t *data, size_t size) {
+  size_t readBytes(uint8_t *data, size_t len) {
-    return reader.readBytes(data, size);
+    return reader.readBytes(data, len);
   }
 
   void addNotifyAudioChange(AudioInfoSupport &bi) override {
@@ -380,8 +380,8 @@ class EncodedAudioStream : public ReformatBaseStream {
 class AudioWriterToAudioOutput : public AudioOutputAdapter {
  public:
   void setWriter(AudioWriter *writer) { p_writer = writer; }
-  size_t write(const uint8_t *in_ptr, size_t in_size) {
+  size_t write(const uint8_t *data, size_t len) {
-    return p_writer->write(in_ptr, in_size);
+    return p_writer->write(data, len);
   };
 
  protected:

src/AudioCodecs/CodecAACFAAD.h

@@ -86,9 +86,9 @@ class AACDecoderFAAD : public AudioDecoder {
   }
 
   /// Write AAC data to decoder
-  size_t write(const void *aac_data, size_t len) {
+  size_t write(const uint8_t *data, size_t len) {
     // Write supplied data to input buffer
-    size_t result = input_buffer.writeArray((uint8_t *)aac_data, len);
+    size_t result = input_buffer.writeArray((uint8_t *)data, len);
     // Decode from input buffer
     decode(underflow_limit);
 

src/AudioCodecs/CodecAACFDK.h

@@ -61,8 +61,8 @@ class AACDecoderFDK : public AudioDecoder  {
         }
 
         // write AAC data to be converted to PCM data
-        virtual size_t write(const void *in_ptr, size_t in_size) {
+        virtual size_t write(const uint8_t *data, size_t len) {
-            return dec->write(in_ptr, in_size);
+            return dec->write(data, len);
         }
 
         // provides detailed information about the stream
@@ -278,9 +278,9 @@ public:
     }
     
     // convert PCM data to AAC
-    size_t write(const void *in_ptr, size_t in_size){
+    size_t write(const uint8_t *data, size_t len){
-        LOGD("write %d bytes", (int)in_size);
+        LOGD("write %d bytes", (int)len);
-        return enc->write((uint8_t*)in_ptr, in_size);
+        return enc->write((uint8_t*)data, len);
     }
 
     // release resources

src/AudioCodecs/CodecAACHelix.h

@@ -116,14 +116,14 @@ class AACDecoderHelix : public AudioDecoder  {
         }
 
         /// Write AAC data to decoder
-        size_t write(const void* aac_data, size_t len) override {
+        size_t write(const uint8_t* data, size_t len) override {
             LOGD("AACDecoderHelix::write: %d", (int)len);
             if (aac==nullptr) return 0;
             int open = len;
             int processed = 0;
-            uint8_t *data = (uint8_t*)aac_data;
+            uint8_t *data8 = (uint8_t*)data;
             while(open>0){
-                 int act_write = aac->write(data+processed, min(open, DEFAULT_BUFFER_SIZE));
+                 int act_write = aac->write(data8+processed, min(open, DEFAULT_BUFFER_SIZE));
                  open -= act_write;
                  processed += act_write;
             }

src/AudioCodecs/CodecADPCM.h

@@ -64,15 +64,15 @@ class ADPCMDecoder : public AudioDecoderExt {
 
   virtual void setOutput(Print &out_stream) override { p_print = &out_stream; }
 
-  virtual size_t write(const void *input_buffer, size_t length) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     TRACED();
 
-    uint8_t *input_buffer8 = (uint8_t *)input_buffer;
+    uint8_t *input_buffer8 = (uint8_t *)data;
-    LOGD("write: %d", (int)length);
+    LOGD("write: %d", (int)len);
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       decode(input_buffer8[j]);
     }
-    return length;
+    return len;
   }
 
   operator bool() override { return is_started; }
@@ -165,13 +165,13 @@ class ADPCMEncoder : public AudioEncoderExt {
 
   operator bool() override { return is_started; }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", (int)in_size);
+    LOGD("write: %d", (int)len);
-    int16_t *data16 = (int16_t *)in_ptr;
+    int16_t *data16 = (int16_t *)data;
-    for (int j = 0; j < in_size / 2; j++) {
+    for (int j = 0; j < len / 2; j++) {
       encode(data16[j]);
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecADPCMXQ.h

@@ -85,17 +85,17 @@ class ADPCMDecoderXQ : public AudioDecoder {
 
   operator bool() override { return adpcm_cnxt != nullptr; }
 
-  virtual size_t write(const void *input_buffer, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    uint8_t *input_buffer8 = (uint8_t *)input_buffer;
+    uint8_t *input_buffer8 = (uint8_t *)data;
-    LOGD("write: %d", (int)length);
+    LOGD("write: %d", (int)len);
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       adpcm_block[current_byte++] = input_buffer8[j];
       if (current_byte == block_size) {
         decode(current_byte);
         current_byte = 0;
       }
     }
-    return length;
+    return len;
   }
 
  protected:
@@ -190,18 +190,18 @@ class ADPCMEncoderXQ : public AudioEncoder {
 
   operator bool() override { return adpcm_cnxt != nullptr; }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", (int)in_size);
+    LOGD("write: %d", (int)len);
-    int16_t *input_buffer = (int16_t *)in_ptr;
+    int16_t *input_buffer = (int16_t *)data;
     pcm_block_size = samples_per_block * info.channels;
-    for (int j = 0; j < in_size / 2; j++) {
+    for (int j = 0; j < len / 2; j++) {
       pcm_block[current_sample++] = input_buffer[j];
       if (current_sample == samples_per_block * info.channels) {
         encode();
         current_sample = 0;
       }
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecADTS.h

@@ -133,7 +133,7 @@ class ADTSDecoder : public AudioDecoder {
   void end() override { buffer.resize(0); }
 
   /// Write AAC data to decoder
-  size_t write(const void *dataIn, size_t len) override {
+  size_t write(const uint8_t *data, size_t len) override {
     LOGD("AACDecoderADTS::write: %d", (int)len);
 
     // make sure that we can hold at least the len
@@ -142,7 +142,6 @@ class ADTSDecoder : public AudioDecoder {
     }
 
     // write data to buffer
-    uint8_t *data = (uint8_t *)dataIn;
     size_t result = buffer.writeArray(data, len);
     LOGD("buffer size: %d", buffer.available());
 

src/AudioCodecs/CodecAPTX.h

@@ -51,22 +51,22 @@ class APTXDecoder : public AudioDecoder {
 
   operator bool() { return ctx != nullptr; }
 
-  virtual size_t write(const void *input_buffer, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGI("write: %d", length);
+    LOGI("write: %d", len);
     bool is_ok = true;
     size_t dropped;
     int synced;
 
     if (is_first_write) {
       is_first_write = false;
-      if (!checkPrefix(input_buffer, length)) {
+      if (!checkPrefix(data, len)) {
         return 0;
       }
     }
 
-    output_buffer.resize(length * 10);
+    output_buffer.resize(len * 10);
     memset(output_buffer.data(), 0, output_buffer.size());
-    processed = aptx_decode_sync(ctx, (const uint8_t *)input_buffer, length,
+    processed = aptx_decode_sync(ctx, (const uint8_t *)data, len,
                                  output_buffer.data(), output_buffer.size(),
                                  &written, &synced, &dropped);
 
@@ -74,14 +74,14 @@ class APTXDecoder : public AudioDecoder {
 
     // If we have not decoded all supplied samples then decoding unrecoverable
     // failed
-    if (processed != length) {
+    if (processed != len) {
-      LOGE("aptX decoding reqested: %d eff: %d", length, processed);
+      LOGE("aptX decoding reqested: %d eff: %d", len, processed);
       is_ok = false;
     }
 
     writeData(written, is_ok);
 
-    return is_ok ? length : 0;
+    return is_ok ? len : 0;
   }
 
  protected:
@@ -244,14 +244,14 @@ class APTXEncoder : public AudioEncoder {
 
   operator bool() { return ctx != nullptr; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGI("write: %d", in_size);
+    LOGI("write: %d", len);
     if (ctx == nullptr) return 0;
     size_t output_written = 0;
 
     // process all bytes
-    int16_t *in_ptr16 = (int16_t *)in_ptr;
+    int16_t *in_ptr16 = (int16_t *)data;
-    int in_samples = in_size / 2;
+    int in_samples = len / 2;
     for (int j = 0; j < in_samples; j++) {
       input_buffer[input_pos++].setAndScale16(in_ptr16[j]);
 
@@ -284,7 +284,7 @@ class APTXEncoder : public AudioEncoder {
       }
     }
 
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecBase64.h

@@ -78,10 +78,10 @@ class DecoderBase64 : public AudioDecoder {
     buffer.resize(0);
   }
 
-  size_t write(const void *data, size_t byteCount) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (p_print == nullptr) return 0;
     TRACED();
-    addToBuffer((uint8_t *)data, byteCount);
+    addToBuffer((uint8_t *)data, len);
     int decode_size = 4;  // maybe we should increase this ?
     while (buffer.available() >= decode_size) {
       uint8_t tmp[decode_size];
@@ -89,7 +89,7 @@ class DecoderBase64 : public AudioDecoder {
       decodeLine(tmp, decode_size);
     }
 
-    return byteCount;
+    return len;
   }
 
   operator bool() override { return active; }
@@ -218,14 +218,13 @@ class EncoderBase64 : public AudioEncoder {
   void end() override { is_open = false; }
 
   /// Writes PCM data to be encoded as RAW
-  virtual size_t write(const void *binary, size_t len) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     LOGD("EncoderBase64::write: %d", (int)len);
-    uint8_t *data = (uint8_t *)binary;
 
     switch (newline_logic) {
       case NoCR:
       case CRforWrite:
-        encodeLine((uint8_t *)binary, len);
+        encodeLine(data, len);
         break;
       case CRforFrame: {
         int frames = len / frame_size;
@@ -266,7 +265,7 @@ class EncoderBase64 : public AudioEncoder {
 #endif
   }
 
-  void encodeLine(uint8_t *data, size_t input_length) {
+  void encodeLine(const uint8_t *data, size_t input_length) {
     LOGD("EncoderBase64::encodeLine: %d", (int)input_length);
     int output_length = 4 * ((input_length + 2) / 3);
     if (ret.size() < output_length + 1) {

src/AudioCodecs/CodecBasic.h

@@ -69,8 +69,8 @@ public:
 
   void end() override { decoder.end(); }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    return decoder.write((uint8_t *)in_ptr, in_size);
+    return decoder.write((uint8_t *)data, len);
   }
 
   virtual operator bool() override { return decoder; }
@@ -116,7 +116,7 @@ public:
   void end() override { encoder.end(); }
 
   /// Writes PCM data to be encoded as RAW
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *in_ptr, size_t in_size) override {
     return encoder.write((uint8_t *)in_ptr, in_size);
   }
 

src/AudioCodecs/CodecCodec2.h

@@ -132,19 +132,19 @@ class Codec2Decoder : public AudioDecoder {
 
   operator bool() { return is_active; }
 
-  size_t write(const void *data, size_t length) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", length);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
 
     uint8_t *p_byte = (uint8_t *)data;
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       processByte(p_byte[j]);
     }
 
-    return length;
+    return len;
   }
 
  protected:
@@ -257,7 +257,7 @@ class Codec2Encoder : public AudioEncoder {
 
   operator bool() { return is_active; }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *in_ptr, size_t in_size) override {
     LOGD("write: %d", in_size);
     if (!is_active) {
       LOGE("inactive");

src/AudioCodecs/CodecCopy.h

@@ -34,7 +34,7 @@ public:
 
   void end() {}
 
-  size_t write(const void *data, size_t len) { 
+  size_t write(const uint8_t *data, size_t len) { 
     TRACED();
     return pt_print->write((uint8_t*)data,len);
   }
@@ -72,7 +72,7 @@ public:
 
   void end() {}
 
-  size_t write(const void *data, size_t len) { return pt_print->write((uint8_t*)data,len); }
+  size_t write(const uint8_t *data, size_t len) { return pt_print->write((uint8_t*)data,len); }
 
   operator bool() { return true; }
 

src/AudioCodecs/CodecFLAC.h

@@ -159,8 +159,8 @@ class FLACDecoder : public StreamingDecoder {
     LOGE(FLAC__StreamDecoderErrorStatusString[status]);
   }
 
-  size_t readBytes(uint8_t *buffer, size_t len) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-      return p_input->readBytes(buffer, len);
+      return p_input->readBytes(data, len);
   }
 
   /// Callback which reads from stream
@@ -361,26 +361,26 @@ class FLACEncoder : public AudioEncoder {
   }
 
   /// Writes FLAC Packet
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (!is_open || p_print == nullptr) return 0;
-    LOGD("write: %zu", in_size);
+    LOGD("write: %zu", len);
     size_t result = 0;
     int samples=0;
     int frames=0;
-    int32_t *data=nullptr;
+    int32_t *data32=nullptr;
     switch(cfg.bits_per_sample){
       case 16:
-        samples = in_size / sizeof(int16_t); 
+        samples = len / sizeof(int16_t); 
         frames = samples / cfg.channels;
-        writeBuffer((int16_t*)in_ptr, samples);
+        writeBuffer((int16_t*)data, samples);
-        data = buffer.data();
+        data32 = buffer.data();
         break;
 
       case 24:
       case 32:
-        samples = in_size / sizeof(int32_t);
+        samples = len / sizeof(int32_t);
         frames = samples / cfg.channels;
-        data = (int32_t*) in_ptr;
+        data32 = (int32_t*) data;
         break;
 
       default:
@@ -389,8 +389,8 @@ class FLACEncoder : public AudioEncoder {
     }
 
     if (frames>0){
-      if (FLAC__stream_encoder_process_interleaved(p_encoder, data, frames)){
+      if (FLAC__stream_encoder_process_interleaved(p_encoder, data32, frames)){
-        result = in_size;
+        result = len;
       } else {
         LOGE("FLAC__stream_encoder_process_interleaved");
       }

src/AudioCodecs/CodecFloat.h

@@ -43,9 +43,9 @@ class DecoderFloat : public AudioDecoder {
         }
 
         /// Converts data from float to int16_t
-        virtual size_t write(const void *data, size_t in_size) override {
+        virtual size_t write(const uint8_t *data, size_t len) override {
             if (p_print==nullptr)  return 0;
-            int samples = in_size/sizeof(float);
+            int samples = len/sizeof(float);
             buffer.resize(samples);
             float* p_float = (float*) data;
             for (int j=0;j<samples;j++){
@@ -111,10 +111,10 @@ class EncoderFloat : public AudioEncoder {
         }
 
         /// Converts data from int16_t to float
-        virtual size_t write(const void *in_ptr, size_t in_size) override {
+        virtual size_t write(const uint8_t *data, size_t len) override {
             if (p_print==nullptr)  return 0;
-            int16_t *pt16 = (int16_t*)in_ptr;
+            int16_t *pt16 = (int16_t*)data;
-            size_t samples = in_size / sizeof(int16_t);
+            size_t samples = len / sizeof(int16_t);
             buffer.resize(samples);
             for (size_t j=0;j<samples;j++){
                 buffer[j] = static_cast<float>(pt16[j]) / 32768.0;

src/AudioCodecs/CodecG722.h

@@ -61,19 +61,19 @@ class G722Decoder : public AudioDecoder {
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *data, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", length);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
 
     uint8_t *p_byte = (uint8_t *)data;
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       processByte(p_byte[j]);
     }
 
-    return length;
+    return len;
   }
 
  protected:
@@ -153,18 +153,18 @@ class G722Encoder : public AudioEncoder {
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", in_size);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
     // encode bytes
-    uint8_t *p_byte = (uint8_t *)in_ptr;
+    uint8_t *p_byte = (uint8_t *)data;
-    for (int j = 0; j < in_size; j++) {
+    for (int j = 0; j < len; j++) {
       processByte(p_byte[j]);
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecG7xx.h

@@ -86,20 +86,20 @@ class G7xxDecoder : public AudioDecoder {
 
   operator bool() { return is_active; }
 
-  size_t write(const void *data, size_t length) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", length);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
 
     uint8_t *p_byte = (uint8_t *)data;
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       sample = (*dec_routine)(p_byte[j], AUDIO_ENCODING_LINEAR, &state);
       p_print->write((uint8_t*)&sample, out_size);
     }
 
-    return length;
+    return len;
   }
 
  protected:
@@ -192,21 +192,21 @@ class G7xxEncoder : public AudioEncoder {
 
   operator bool() { return is_active; }
 
-   size_t write(const void *in_ptr, size_t byte_count) override {
+   size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", byte_count);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
     // encode bytes
-    int16_t *p_16 = (int16_t *)in_ptr;
+    int16_t *p_16 = (int16_t *)data;
-    int samples = byte_count / sizeof(int16_t);
+    int samples = len / sizeof(int16_t);
     for (int j = 0; j < samples; j++) {
         code = (*enc_routine)(p_16[j], AUDIO_ENCODING_LINEAR, &state);
         p_print->write(&code, 1);
     }
    
-    return byte_count;
+    return len;
   }
 
  protected:
@@ -306,21 +306,21 @@ class G711Encoder : public G7xxEncoder {
     this->enc = enc;
     assert(this->enc!=nullptr);
   };
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", in_size);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
     // encode bytes
-    int samples = in_size/2;
+    int samples = len/2;
-    int16_t *p_16 = (int16_t *)in_ptr;
+    int16_t *p_16 = (int16_t *)data;
     uint8_t buffer[samples];
     for (int j = 0; j < samples; j++) {
 	      buffer[j] = enc(p_16[j]);
     }
     p_print->write(buffer,samples);
-    return in_size;
+    return len;
   }
   protected:
   uint8_t(*enc)(int)=nullptr;
@@ -341,19 +341,19 @@ class G711Decoder : public G7xxDecoder {
     assert(this->dec!=nullptr);
   };
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", in_size);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
     // decode bytes
-    uint8_t *p_8 = (uint8_t *)in_ptr;
+    uint8_t *p_8 = (uint8_t *)data;
-    for (int j = 0; j < in_size; j++) {
+    for (int j = 0; j < len; j++) {
 	      int16_t result = dec(p_8[j]);
         p_print->write((uint8_t*)&result,sizeof(int16_t));
     }
-    return in_size;
+    return len;
   }
   protected:
   int (*dec)(uint8_t a_val)=nullptr;

src/AudioCodecs/CodecGSM.h

@@ -53,19 +53,18 @@ class GSMDecoder : public AudioDecoder {
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *data, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", length);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
 
-    uint8_t *p_byte = (uint8_t *) data;
+    for (int j = 0; j < len; j++) {
-    for (int j = 0; j < length; j++) {
+      processByte(data[j]);
-      processByte(p_byte[j]);
     }
 
-    return length;
+    return len;
   }
 
  protected:
@@ -168,18 +167,17 @@ class GSMEncoder : public AudioEncoder {
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", in_size);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
     // encode bytes
-    uint8_t *p_byte = (uint8_t *) in_ptr;
+    for (int j = 0; j < len; j++) {
-    for (int j = 0; j < in_size; j++) {
+      processByte(data[j]);
-      processByte(p_byte[j]);
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecHelix.h

@@ -58,7 +58,7 @@ public:
   }
 
   /// Write mp3 data to decoder
-  size_t write(const void *data, size_t len) {
+  size_t write(const uint8_t *data, size_t len) {
     LOGD("%s: %zu", LOG_METHOD, len);
     if (p_decoder == nullptr) {
       setupDecoder((const byte *)data);

src/AudioCodecs/CodecILBC.h

@@ -68,11 +68,11 @@ class ILBCDecoder : public AudioDecoder {
 
   operator bool() { return p_ilbc != nullptr; }
 
-  virtual size_t write(const void *input_buffer, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
     if (p_ilbc==nullptr) return 0;
-    LOGI("write: %d", length);
+    LOGI("write: %d", len);
-    int samples = length / sizeof(int16_t);
+    int samples = len / sizeof(int16_t);
-    int16_t *p_samples = (int16_t *)input_buffer;
+    int16_t *p_samples = (int16_t *)data;
     for (int j=0;j<samples;j++){
       encoded_buffer[encoded_buffer_pos++]=p_samples[j];
       if (encoded_buffer_pos>=encoded_buffer.size()){
@@ -85,7 +85,7 @@ class ILBCDecoder : public AudioDecoder {
         encoded_buffer_pos = 0;
       }
     }
-    return length;
+    return len;
   }
 
  protected:
@@ -159,12 +159,12 @@ class ILBCEncoder : public AudioEncoder {
 
   operator bool() { return p_ilbc != nullptr; }
 
-  virtual size_t write(const void *in_data, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
     if (p_ilbc==nullptr) return 0;
-    LOGI("write: %d", in_size);
+    LOGI("write: %d", len);
 
-    int samples = in_size / sizeof(int16_t);
+    int samples = len / sizeof(int16_t);
-    int16_t *p_samples = (int16_t *)in_data;
+    int16_t *p_samples = (int16_t *)data;
 
     for (int j=0;j<samples;j++){
       decoded_buffer[decoded_buffer_pos++]=p_samples[j];
@@ -177,7 +177,7 @@ class ILBCEncoder : public AudioEncoder {
         decoded_buffer_pos = 0;
       }
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecL16.h

@@ -44,14 +44,14 @@ public:
   /// Defines the output Stream
   void setOutput(Print &out_stream) override { p_print = &out_stream; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (p_print == nullptr)
       return 0;
-    int16_t *data16 = (int16_t *)in_ptr;
+    int16_t *data16 = (int16_t *)data;
-    for (int j = 0; j < in_size / 2; j++) {
+    for (int j = 0; j < len / 2; j++) {
       data16[j] = ntohs(data16[j]);
     }
-    return p_print->write((uint8_t *)in_ptr, in_size);
+    return p_print->write((uint8_t *)data, len);
   }
 
   virtual operator bool() override { return p_print!=nullptr; }
@@ -99,16 +99,16 @@ public:
   void end() override { is_open = false; }
 
   /// Writes PCM data to be encoded as RAW
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (p_print == nullptr)
       return 0;
 
-    int16_t *data16 = (int16_t *)in_ptr;
+    int16_t *data16 = (int16_t *)data;
-    for (int j = 0; j < in_size / 2; j++) {
+    for (int j = 0; j < len / 2; j++) {
       data16[j] = htons(data16[j]);
     }
 
-    return p_print->write((uint8_t *)in_ptr, in_size);
+    return p_print->write((uint8_t *)data, len);
   }
 
   operator bool() override { return is_open; }

src/AudioCodecs/CodecL8.h

@@ -67,24 +67,24 @@ class DecoderL8 : public AudioDecoder {
     info = from;
   }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (p_print == nullptr) return 0;
-    buffer.resize(in_size);
+    buffer.resize(len);
-    memset(buffer.data(), 0, in_size * 2);
+    memset(buffer.data(), 0, len * 2);
     if (is_signed) {
-      int8_t *pt8 = (int8_t *)in_ptr;
+      int8_t *pt8 = (int8_t *)data;
-      for (size_t j = 0; j < in_size; j++) {
+      for (size_t j = 0; j < len; j++) {
         buffer[j] = convertSample(pt8[j]);
       }
     } else {
-      uint8_t *pt8 = (uint8_t *)in_ptr;
+      uint8_t *pt8 = (uint8_t *)data;
-      for (size_t j = 0; j < in_size; j++) {
+      for (size_t j = 0; j < len; j++) {
         buffer[j] = convertSample(pt8[j]);
       }
     }
-    int write_byte_count = in_size * sizeof(int16_t);
+    int write_byte_count = len * sizeof(int16_t);
     size_t result = p_print->write((uint8_t *)buffer.data(), write_byte_count);
-    LOGD("DecoderL8 %d -> %d -> %d", (int)in_size, write_byte_count, (int)result);
+    LOGD("DecoderL8 %d -> %d -> %d", (int)len, write_byte_count, (int)result);
     return result / sizeof(int16_t);
   }
 
@@ -150,10 +150,10 @@ class EncoderL8 : public AudioEncoder {
   void end() override { is_open = false; }
 
   /// Writes PCM data to be encoded as RAW
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (p_print == nullptr) return 0;
-    int16_t *pt16 = (int16_t *)in_ptr;
+    int16_t *pt16 = (int16_t *)data;
-    size_t samples = in_size / 2;
+    size_t samples = len / 2;
     buffer.resize(samples);
     memset(buffer.data(), 0, samples);
     for (size_t j = 0; j < samples; j++) {
@@ -161,7 +161,7 @@ class EncoderL8 : public AudioEncoder {
     }
 
     size_t result = p_print->write((uint8_t *)buffer.data(), samples);
-    LOGD("EncoderL8 %d -> %d -> %d", (int)in_size,(int) samples, (int)result);
+    LOGD("EncoderL8 %d -> %d -> %d", (int)len,(int) samples, (int)result);
     return result * sizeof(int16_t);
   }
 

src/AudioCodecs/CodecLC3.h

@@ -89,13 +89,13 @@ class LC3Decoder : public AudioDecoder {
 
   operator bool() { return active; }
 
-  virtual size_t write(const void *input, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
     if (!active) return 0;
-    LOGD("write %u", length);
+    LOGD("write %u", len);
 
-    uint8_t *p_ptr8 = (uint8_t *)input;
+    uint8_t *p_ptr8 = (uint8_t *)data;
 
-    for (int j = 0; j < length; j++) {
+    for (int j = 0; j < len; j++) {
       input_buffer[input_pos++] = p_ptr8[j];
       if (input_pos >= input_buffer.size()) {
         if (lc3_decode(lc3_decoder, input_buffer.data(), input_buffer.size(),
@@ -113,7 +113,7 @@ class LC3Decoder : public AudioDecoder {
         input_pos = 0;
       }
     }
-    return length;
+    return len;
   }
 
  protected:
@@ -236,12 +236,12 @@ class LC3Encoder : public AudioEncoder {
 
   operator bool() { return lc3_encoder != nullptr; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
     if (!active) return 0;
-    LOGD("write %u", in_size);
+    LOGD("write %u", len);
-    uint8_t *p_ptr8 = (uint8_t *)in_ptr;
+    uint8_t *p_ptr8 = (uint8_t *)data;
 
-    for (int j = 0; j < in_size; j++) {
+    for (int j = 0; j < len; j++) {
       input_buffer[input_pos++] = p_ptr8[j];
       if (input_pos >= num_frames * 2) {
         if (lc3_encode(lc3_encoder, pcm_format,
@@ -259,7 +259,7 @@ class LC3Encoder : public AudioEncoder {
         input_pos = 0;
       }
     }
-    return in_size;
+    return len;
   }
 
  protected:

src/AudioCodecs/CodecMP3Helix.h

@@ -108,10 +108,10 @@ class MP3DecoderHelix : public AudioDecoder  {
         }
 
         /// Write mp3 data to decoder
-        size_t write(const void* mp3Data, size_t len) {
+        size_t write(const uint8_t* data, size_t len) {
             LOGD("%s: %zu", LOG_METHOD, len);
             if (mp3==nullptr) return 0;
-            return use_filter ? filter.write((uint8_t*)mp3Data, len): mp3->write((uint8_t*)mp3Data, len);
+            return use_filter ? filter.write((uint8_t*)data, len): mp3->write((uint8_t*)data, len);
         }
 
         /// checks if the class is active 

src/AudioCodecs/CodecMP3LAME.h

@@ -94,10 +94,10 @@ public:
     }
 
     // convert PCM data to convert into MP3
-    size_t write(const void *in_ptr, size_t in_size){
+    size_t write(const uint8_t *data, size_t len){
         if (enc==nullptr) return 0;
-        LOGD("write %d bytes", (int) in_size);
+        LOGD("write %d bytes", (int) len);
-        return enc->write((uint8_t*)in_ptr, in_size);
+        return enc->write((uint8_t*)data, len);
     }
 
     // release resources

src/AudioCodecs/CodecMP3MAD.h

@@ -91,7 +91,7 @@ class MP3DecoderMAD : public AudioDecoder  {
         }
 
         /// Makes the mp3 data available for decoding: however we recommend to provide the data via a callback or input stream
-        size_t write(const void *data, size_t len){
+        size_t write(const uint8_t *data, size_t len){
             TRACED();
             return mad->write(data,len);
         }

src/AudioCodecs/CodecMP3Mini.h

@@ -61,7 +61,7 @@ class MP3DecoderMini : public AudioDecoder {
   void setOutput(Print &outStream) { this->out = &outStream; }
 
   /// Write mp3 data to decoder
-  size_t write(const void *data, size_t len) {
+  size_t write(const uint8_t *data, size_t len) {
     LOGD("write: %zu", len);
     if (active) {
       if (buffer_pos+len>=buffer.size()){

src/AudioCodecs/CodecMTS.h

@@ -116,10 +116,10 @@ class MTSDecoder : public AudioDecoder {
 
   const char *mime() { return "video/MP2T"; }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!is_active) return 0;
-    LOGD("MTSDecoder::write: %d", (int)in_size);
+    LOGD("MTSDecoder::write: %d", (int)len);
-    size_t result = buffer.writeArray((uint8_t*)in_ptr, in_size);
+    size_t result = buffer.writeArray((uint8_t*)data, len);
     // demux
     demux(underflowLimit);
     return result;

src/AudioCodecs/CodecOpus.h

@@ -193,14 +193,14 @@ class OpusAudioDecoder : public AudioDecoder {
     cfg.bits_per_sample = from.bits_per_sample;
   }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!active || p_print == nullptr) return 0;
     // decode data
-    LOGD("OpusAudioDecoder::write: %d", (int)in_size);
+    LOGD("OpusAudioDecoder::write: %d", (int)len);
     int in_band_forward_error_correction = 0;
     int frame_count = cfg.max_buffer_size / cfg.channels / sizeof(opus_int16);
     int out_samples = opus_decode(
-        dec, (uint8_t *)in_ptr, in_size, (opus_int16 *)outbuf.data(),
+        dec, (uint8_t *)data, len, (opus_int16 *)outbuf.data(),
         frame_count, in_band_forward_error_correction);
     if (out_samples < 0) {
       LOGW("opus-decode: %s", opus_strerror(out_samples));
@@ -217,7 +217,7 @@ class OpusAudioDecoder : public AudioDecoder {
         processed += written;
       }
     }
-    return in_size;
+    return len;
   }
 
   operator bool() override { return active; }
@@ -304,16 +304,15 @@ class OpusAudioEncoder : public AudioEncoder {
   }
 
   /// Writes PCM data to be encoded as Opus
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!is_open || p_print == nullptr) return 0;
-    LOGD("OpusAudioEncoder::write: %d", (int)in_size);
+    LOGD("OpusAudioEncoder::write: %d", (int)len);
 
     // fill frame
-    uint8_t *p_byte = (uint8_t *)in_ptr;
+    for (int j = 0; j < len; j++) {
-    for (int j = 0; j < in_size; j++) {
+      encodeByte(data[j]);
-      encodeByte(p_byte[j]);
     }
-    return in_size;
+    return len;
   }
 
   operator bool() override { return is_open; }

src/AudioCodecs/CodecSBC.h

@@ -56,22 +56,22 @@ public:
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *data, size_t length) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", length);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
     }
 
     uint8_t *start = (uint8_t *)data;
-    int count = length;
+    int count = len;
     if (is_first) {
-      framelen = firstWrite(data, length);
+      framelen = firstWrite(data, len);
       LOGI("framelen: %d", framelen);
       // check if we have a valid frame length
       if (isValidFrameLen(framelen)) {
         start = start + framelen;
-        count = length - framelen;
+        count = len - framelen;
         is_first = false;
       }
     }
@@ -82,7 +82,7 @@ public:
       }
     }
 
-    return length;
+    return len;
   }
 
 
@@ -258,8 +258,8 @@ public:
 
   operator bool() { return is_active; }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("write: %d", in_size);
+    LOGD("write: %d", len);
     if (!is_active) {
       LOGE("inactive");
       return 0;
@@ -269,13 +269,12 @@ public:
       return 0;
     }
 
-    const uint8_t *start = (const uint8_t *)in_ptr;
     // encode bytes
-    for (int j = 0; j < in_size; j++) {
+    for (int j = 0; j < len; j++) {
-      processByte(start[j]);
+      processByte(data[j]);
     }
 
-    return in_size;
+    return len;
   }
 
 

src/AudioCodecs/CodecTSDemux.h

@@ -109,10 +109,10 @@ class MTSDecoder : public AudioDecoder {
 
   const char *mime() { return "video/MP2T"; }
 
-  size_t write(const void *in_ptr, size_t in_size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!is_active) return 0;
-    LOGD("MTSDecoder::write: %d", (int)in_size);
+    LOGD("MTSDecoder::write: %d", (int)len);
-    size_t result = buffer.writeArray((uint8_t*)in_ptr, in_size);
+    size_t result = buffer.writeArray((uint8_t*)data, len);
     // demux
     demux(underflowLimit);
     return result;

src/AudioCodecs/CodecVorbis.h

@@ -148,9 +148,9 @@ protected:
     return result;
   }
 
-  virtual size_t readBytes(uint8_t *ptr, size_t size) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
-    size_t read_size =  min(size,(size_t)VARBIS_MAX_READ_SIZE);
+    size_t read_size =  min(len,(size_t)VARBIS_MAX_READ_SIZE);
-    size_t result = p_input->readBytes((uint8_t *)ptr, read_size);
+    size_t result = p_input->readBytes((uint8_t *)data, read_size);
     LOGD("readBytes: %zu",result);
     return result;
   }

src/AudioCodecs/CodecWAV.h

@@ -318,17 +318,17 @@ class WAVDecoder : public AudioDecoder {
 
   AudioInfo audioInfo() override { return header.audioInfo(); }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     size_t result = 0;
     if (active) {
       if (isFirst) {
-        result = decodeHeader((uint8_t*) in_ptr, in_size);
+        result = decodeHeader((uint8_t*) data, len);
-        if (result<in_size){
+        if (result<len){
-          result += write_out((uint8_t *)in_ptr+result, in_size-result);
+          result += write_out((uint8_t *)data+result, len-result);
         }
       } else if (isValid) {
-        result = write_out((uint8_t *)in_ptr, in_size);
+        result = write_out((uint8_t *)data, len);
       }
     }
     return result;
@@ -560,7 +560,7 @@ class WAVEncoder : public AudioEncoder {
   void end() override { is_open = false; }
 
   /// Writes PCM data to be encoded as WAV
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (!is_open) {
       LOGE("The WAVEncoder is not open - please call begin()");
       return 0;
@@ -582,10 +582,10 @@ class WAVEncoder : public AudioEncoder {
     int32_t result = 0;
     Print *p_out = p_encoder==nullptr ? p_print : &enc_out;;
     if (audioInfo.is_streamed) {
-      result = p_out->write((uint8_t *)in_ptr, in_size);
+      result = p_out->write((uint8_t *)data, len);
     } else if (size_limit > 0) {
-      size_t write_size = min((size_t)in_size, (size_t)size_limit);
+      size_t write_size = min((size_t)len, (size_t)size_limit);
-      result = p_out->write((uint8_t *)in_ptr, write_size);
+      result = p_out->write((uint8_t *)data, write_size);
       size_limit -= result;
 
       if (size_limit <= 0) {

src/AudioCodecs/CodecWavIMA.h

@@ -356,25 +356,25 @@ class WavIMADecoder : public AudioDecoder {
             return header.audioInfo();
         }
 
-        virtual size_t write(const void *in_ptr, size_t in_size) {
+        virtual size_t write(const uint8_t *data, size_t len) {
             TRACED();
             if (active) {
                 if (isFirst) {
                     // we expect at least the full header
-                    int written = header.write((uint8_t*)in_ptr, in_size);
+                    int written = header.write((uint8_t*)data, len);
                     if (written == IMA_ERR_INVALID_CONTAINER || written == IMA_ERR_INVALID_CHUNK) {
                         isValid = false;
                         isFirst = false;
                         LOGE("File is not valid");
-                        return in_size;
+                        return len;
                     }
 
                     if (!header.isDataComplete()) {
-                        return in_size;
+                        return len;
                     }
 
-                    size_t len = in_size - written;
+                    size_t len_open = len - written;
-                    uint8_t *sound_ptr = (uint8_t *) in_ptr + written;
+                    uint8_t *sound_ptr = (uint8_t *) data + written;
                     isFirst = false;
                     isValid = header.audioInfo().is_valid;
 
@@ -400,13 +400,13 @@ class WavIMADecoder : public AudioDecoder {
                         notifyAudioChange(bi);
                         // write prm data from first record
                         LOGI("WavIMADecoder writing first sound data");
-                        processInput(sound_ptr, len);
+                        processInput(sound_ptr, len_open);
                     }
                 } else if (isValid) {
-                    processInput((uint8_t*)in_ptr, in_size);
+                    processInput((uint8_t*)data, len);
                 }
             }
-            return in_size;
+            return len;
         }
 
         /// Alternative API which provides the data from an input stream

src/AudioCodecs/ContainerAVI.h

@@ -293,9 +293,9 @@ public:
     p_output_video = &out_stream;
   }
 
-  virtual size_t write(const void *data, size_t length) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", (int)length);
+    LOGD("write: %d", (int)len);
-    int result = parse_buffer.writeArray((uint8_t *)data, length);
+    int result = parse_buffer.writeArray((uint8_t *)data, len);
     if (is_parsing_active) {
       // we expect the first parse to succeed
       if (parse()) {
@@ -307,7 +307,7 @@ public:
       } else {
         LOGD("Parse Error");
         parse_buffer.clear();
-        result = length;
+        result = len;
         is_parsing_active = false;
       }
     }

src/AudioCodecs/ContainerBinary.h

@@ -127,7 +127,7 @@ public:
   }
 
   /// Add data segment. On first write we also add a AudioInfo header
-  size_t write(const void *data, size_t len) {
+  size_t write(const uint8_t *data, size_t len) {
     LOGD("BinaryContainerEncoder::write: %d", (int)len);
     if (is_beginning) {
       writeHeader();
@@ -223,7 +223,7 @@ public:
 
   void end() { TRACED(); }
 
-  size_t write(const void *data, size_t len) {
+  size_t write(const uint8_t *data, size_t len) {
     LOGD("write: %d", (int)len);
     uint8_t *data8 = (uint8_t *)data;
     if (buffer.size() < len) {

src/AudioCodecs/ContainerMP4.h

@@ -93,10 +93,10 @@ class MP4ParseBuffer {
  public:
   MP4ParseBuffer(ContainerMP4 *container) { this->container = container; };
   // provides the data
-  size_t write(const uint8_t *data, size_t length) {
+  size_t write(const uint8_t *data, size_t len) {
     // initialize buffer size
-    if (buffer.size() == 0) buffer.resize(length);
+    if (buffer.size() == 0) buffer.resize(len);
-    return buffer.writeArray(data, length);
+    return buffer.writeArray(data, len);
   }
 
   /// returns the parsed atoms
@@ -161,15 +161,14 @@ class ContainerMP4 : public ContainerDecoder {
   operator bool() override { return is_active; }
 
   /// writes the data to be parsed into atoms
-  size_t write(const void *in, size_t length) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
-    uint8_t *data = (uint8_t *)in;
     // initialize the max_size with copy length
-    if (max_size == 0) setMaxSize(length);
+    if (max_size == 0) setMaxSize(len);
 
     // direct output to stream
     if (stream_out_open > 0) {
-      int len = min(stream_out_open, (int)length);
+      int len = min(stream_out_open, (int)len);
       int result = len;
       MP4Atom atom{this, stream_atom};
       atom.total_size = len;
@@ -184,7 +183,7 @@ class ContainerMP4 : public ContainerDecoder {
     }
 
     // parse data and provide info via callback
-    size_t result = buffer.write(data, length);
+    size_t result = buffer.write(data, len);
     MP4Atom atom = buffer.parse();
     while (atom && !atom.is_stream) {
       // atom.start_pos = current_pos;

src/AudioCodecs/ContainerOgg.h

@@ -100,19 +100,19 @@ class OggContainerDecoder : public ContainerDecoder {
       ;
   }
 
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    LOGD("write: %d", (int)in_size);
+    LOGD("write: %d", (int)len);
 
     // fill buffer
-    size_t size_consumed = buffer.writeArray((uint8_t *)in_ptr, in_size);
+    size_t size_consumed = buffer.writeArray((uint8_t *)data, len);
     if (buffer.availableForWrite() == 0) {
       // Read all bytes into oggz, calling any read callbacks on the fly.
       flush();
     }
     // write remaining bytes
-    if (size_consumed < in_size) {
+    if (size_consumed < len) {
-      size_consumed += buffer.writeArray((uint8_t *)in_ptr + size_consumed,
+      size_consumed += buffer.writeArray((uint8_t *)data + size_consumed,
-                                         in_size - size_consumed);
+                                         len - size_consumed);
       flush();
     }
     return size_consumed;
@@ -247,15 +247,14 @@ class OggContainerOutput : public AudioOutput {
   }
 
   /// Writes raw data to be encoded and packaged
-  virtual size_t write(const uint8_t *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    if (in_ptr == nullptr) return 0;
+    if (data == nullptr) return 0;
-    LOGD("OggContainerOutput::write: %d", (int)in_size);
+    LOGD("OggContainerOutput::write: %d", (int)len);
     assert(cfg.channels != 0);
 
     // encode the data
-    uint8_t *data = (uint8_t *)in_ptr;
     op.packet = (uint8_t *)data;
-    op.bytes = in_size;
+    op.bytes = len;
     if (op.bytes > 0) {
       int bytes_per_sample = cfg.bits_per_sample / 8;
       granulepos += op.bytes / bytes_per_sample;  // sample
@@ -269,10 +268,10 @@ class OggContainerOutput : public AudioOutput {
       }
     }
     // trigger pysical write
-    while ((oggz_write(p_oggz, in_size)) > 0)
+    while ((oggz_write(p_oggz, len)) > 0)
       ;
 
-    return in_size;
+    return len;
   }
   bool isOpen() { return is_open; }
 
@@ -392,14 +391,14 @@ class OggContainerEncoder : public AudioEncoder {
   }
 
   /// Writes raw data to be encoded and packaged
-  virtual size_t write(const void *in_ptr, size_t in_size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    if (!p_ogg->isOpen() || in_ptr == nullptr) return 0;
+    if (!p_ogg->isOpen() || data == nullptr) return 0;
-    LOGD("OggContainerEncoder::write: %d", (int)in_size);
+    LOGD("OggContainerEncoder::write: %d", (int)len);
     size_t result = 0;
     if (p_codec == nullptr) {
-      result = p_ogg->write((const uint8_t *)in_ptr, in_size);
+      result = p_ogg->write((const uint8_t *)data, len);
     } else {
-      result = p_codec->write(in_ptr, in_size);
+      result = p_codec->write(data, len);
     }
     return result;
   }

src/AudioCodecs/DecoderFromStreaming.h

@@ -51,10 +51,10 @@ public:
     if (is_setup) rbuffer.resize(size);
   }
 
-  size_t write(const void *data, size_t byteCount) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     setupLazy();
-    size_t result = queue.write((uint8_t *)data, byteCount);
+    size_t result = queue.write((uint8_t *)data, len);
     // trigger processing - we leave byteCount in the buffer
     // while(queue.available()>byteCount){
     //   p_dec->copy(); 

src/AudioEffects/AudioEffects.h

@@ -259,14 +259,14 @@ class AudioEffectStreamT : public ModifyingStream {
      * Provides the audio data by reading the assinged Stream and applying
      * the effects on that input
     */
-    size_t readBytes(uint8_t *buffer, size_t length) override {
+    size_t readBytes(uint8_t *data, size_t len) override {
         if (!active || p_io==nullptr)return 0;
         size_t result_size = 0;
 
         // read data from source
-        size_t result = p_io->readBytes((uint8_t*)buffer, length);
+        size_t result = p_io->readBytes((uint8_t*)data, len);
         int frames = result / sizeof(T) / info.channels;
-        T* samples = (T*) buffer;
+        T* samples = (T*) data;
 
         for (int count=0;count<frames;count++){
             // determine sample by combining all channels in frame
@@ -283,7 +283,7 @@ class AudioEffectStreamT : public ModifyingStream {
             }
 
             // write result multiplying channels 
-            T* p_buffer = ((T*)buffer)+(count*info.channels);
+            T* p_buffer = ((T*)data)+(count*info.channels);
             for (int ch=0;ch<info.channels;ch++){
                 p_buffer[ch] = result_sample;
                 result_size += sizeof(T);
@@ -296,17 +296,17 @@ class AudioEffectStreamT : public ModifyingStream {
      * Writes the samples passed in the buffer and applies the effects before writing the
      * result to the output defined in the constructor.
     */
-    size_t write(const uint8_t *buffer, size_t length) override {
+    size_t write(const uint8_t *data, size_t len) override {
         if (!active)return 0;
         // length must be multple of channels
-        assert(length % (sizeof(T)*info.channels)==0);
+        assert(len % (sizeof(T)*info.channels)==0);
-        int frames = length / sizeof(T) / info.channels;
+        int frames = len / sizeof(T) / info.channels;
         size_t result_size = 0;
 
         // process all samples
         for (int j=0;j<frames;j++){
             // calculate sample for frame
-            T* p_buffer = ((T*)buffer) + (j*info.channels);
+            T* p_buffer = ((T*)data) + (j*info.channels);
             T sample=0;
             for (int ch=0;ch<info.channels;ch++){
                 sample += p_buffer[ch] / info.channels;
@@ -464,16 +464,16 @@ class AudioEffectStream : public ModifyingStream {
      * Provides the audio data by reading the assinged Stream and applying
      * the effects on that input
     */
-    size_t readBytes(uint8_t *buffer, size_t length) override {
+    size_t readBytes(uint8_t *data, size_t len) override {
-        return std::visit( [buffer, length](auto&& e) {return e.readBytes(buffer, length);}, variant );
+        return std::visit( [data, len](auto&& e) {return e.readBytes(data, len);}, variant );
     }
 
     /**
      * Writes the samples passed in the buffer and applies the effects before writing the
      * result to the output defined in the constructor.
     */
-    size_t write(const uint8_t *buffer, size_t length) override {
+    size_t write(const uint8_t *data, size_t len) override {
-        return std::visit( [buffer, length](auto&& e) {return e.write(buffer, length);}, variant );
+        return std::visit( [data, len](auto&& e) {return e.write(data, len);}, variant );
     }
 
     int available() override {

src/AudioEffects/SoundGenerator.h

@@ -58,17 +58,17 @@ public:
   virtual T readSample() = 0;
 
   /// Provides the data as byte array with the requested number of channels
-  virtual size_t readBytes(uint8_t *buffer, size_t lengthBytes) {
+  virtual size_t readBytes(uint8_t *data, size_t len) {
-    LOGD("readBytes: %d", (int)lengthBytes);
+    LOGD("readBytes: %d", (int)len);
     if (!active)
       return 0;
     int channels = audioInfo().channels;
     int frame_size = sizeof(T) * channels;
-    int frames = lengthBytes / frame_size;
+    int frames = len / frame_size;
-    if (lengthBytes >= frame_size) {
+    if (len >= frame_size) {
-      return readBytesFrames(buffer, lengthBytes, frames, channels);
+      return readBytesFrames(data, len, frames, channels);
     }
-    return readBytesFromBuffer(buffer, lengthBytes, frame_size, channels);
+    return readBytesFromBuffer(data, len, frame_size, channels);
   }
 
   /// Provides the default configuration

src/AudioHttp/ICYStream.h

@@ -87,23 +87,23 @@ class ICYStream : public AbstractURLStream {
   virtual int available() override { return url.available(); }
 
   /// reads the audio bytes
-  virtual size_t readBytes(uint8_t* buffer, size_t len) override {
+  virtual size_t readBytes(uint8_t* data, size_t len) override {
     size_t result = 0;
     if (icy.hasMetaData()) {
       // get data
-      int read = url.readBytes(buffer, len);
+      int read = url.readBytes(data, len);
       // remove metadata from data
       int pos = 0;
       for (int j = 0; j < read; j++) {
-        icy.processChar(buffer[j]);
+        icy.processChar(data[j]);
         if (icy.isData()) {
-          buffer[pos++] = buffer[j];
+          data[pos++] = data[j];
         }
       }
       result = pos;
     } else {
       // fast access if there is no metadata
-      result = url.readBytes(buffer, len);
+      result = url.readBytes(data, len);
     }
     LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
     return result;

src/AudioHttp/ICYStreamBuffered.h

@@ -69,9 +69,9 @@ class ICYStreamBuffered : public AbstractURLStream {
 
   virtual int available() override { return taskStream.available(); }
 
-  virtual size_t readBytes(uint8_t* buffer, size_t length) override {
+  virtual size_t readBytes(uint8_t* data, size_t len) override {
-    size_t result = taskStream.readBytes(buffer, length);
+    size_t result = taskStream.readBytes(data, len);
-    LOGD("%s: %zu -> %zu", LOG_METHOD, length, result);
+    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
     return result;
   }
 

src/AudioHttp/URLStream.h

@@ -139,15 +139,15 @@ class URLStream : public AbstractURLStream {
     return result;
   }
 
-  virtual size_t readBytes(uint8_t* buffer, size_t length) override {
+  virtual size_t readBytes(uint8_t* data, size_t len) override {
     if (!active || !request) return 0;
 
-    int read = request.read((uint8_t*)&buffer[0], length);
+    int read = request.read((uint8_t*)&data[0], len);
     if (read < 0) {
       read = 0;
     }
     total_read += read;
-    LOGD("readBytes %d -> %d", (int)length, read);
+    LOGD("readBytes %d -> %d", (int)len, read);
     return read;
   }
 
@@ -174,7 +174,7 @@ class URLStream : public AbstractURLStream {
 
   virtual size_t write(uint8_t) override { return not_supported(0); }
 
-  virtual size_t write(const uint8_t*, size_t) override {
+  virtual size_t write(const uint8_t*, size_t len) override {
     return not_supported(0);
   }
 

src/AudioHttp/URLStreamBuffered.h

@@ -91,11 +91,11 @@ class BufferedTaskStream : public AudioStream {
   };
 
   /// Use this method !!
-  virtual size_t readBytes(uint8_t *data, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
     // if (!ready) return 0;
     size_t result = 0;
-    result = buffers.readArray(data, length);
+    result = buffers.readArray(data, len);
-    LOGD("%s: %zu -> %zu", LOG_METHOD, length, result);
+    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
     return result;
   }
 
@@ -185,9 +185,9 @@ class URLStreamBuffered : public AbstractURLStream {
 
   virtual int available() { return taskStream.available(); }
 
-  virtual size_t readBytes(uint8_t *buffer, size_t length) {
+  virtual size_t readBytes(uint8_t *data, size_t len) {
-    size_t result = taskStream.readBytes(buffer, length);
+    size_t result = taskStream.readBytes(data, len);
-    LOGD("%s: %zu -> %zu", LOG_METHOD, length, result);
+    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
     return result;
   }
 

src/AudioI2S/I2SStream.h

@@ -110,15 +110,15 @@ class I2SStream : public AudioStream {
   }
 
   /// Writes the audio data to I2S
-  virtual size_t write(const uint8_t *buffer, size_t size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("I2SStream::write: %d", size);
+    LOGD("I2SStream::write: %d", len);
-    if (buffer == nullptr || size == 0 || !is_active)  return 0;
+    if (data == nullptr || len == 0 || !is_active)  return 0;
-    return i2s.writeBytes(buffer, size);
+    return i2s.writeBytes(data, len);
   }
 
   /// Reads the audio data
-  virtual size_t readBytes(uint8_t *data, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
-    return i2s.readBytes(data, length);
+    return i2s.readBytes(data, len);
   }
 
   /// Provides the available audio data

src/AudioLibs/AudioESP8266.h

@@ -81,11 +81,11 @@ class ESP3288AudioOutput : public AudioStream {
     this->channels = channels;
   }
 
-  virtual size_t write(const uint8_t *buffer, size_t size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
     size_t result = 0;
-    int16_t *v = (int16_t *)buffer;
+    int16_t *v = (int16_t *)data;
     if (channels == 2) {
-      result = p_out->ConsumeSamples(v, size / 2);
+      result = p_out->ConsumeSamples(v, len / 2);
     } else {
       LOGE("Only 2 Channels are supported");
       result = 0;

src/AudioLibs/AudioFaust.h

@@ -143,17 +143,17 @@ class FaustStream : public AudioStream {
     }
 
     /// Used if FaustStream is used as audio sink or filter
-    size_t write(const uint8_t *write_data, size_t len) override {
+    size_t write(const uint8_t *data, size_t len) override {
         LOGD("FaustStream::write: %d", len);
         switch(cfg.bits_per_sample){
             case 8:
-                return writeT<int8_t>(write_data, len);
+                return writeT<int8_t>(data, len);
             case 16:
-                return writeT<int16_t>(write_data, len);
+                return writeT<int16_t>(data, len);
             case 24:
-                return writeT<int24_t>(write_data, len);
+                return writeT<int24_t>(data, len);
             case 32:
-                return writeT<int32_t>(write_data, len);
+                return writeT<int32_t>(data, len);
             default:
                 TRACEE();
         }

src/AudioLibs/AudioKit.h

@@ -245,13 +245,13 @@ class AudioKitStream : public AudioStream {
     return cfg.rx_tx_mode == TX_MODE ? 0 :  DEFAULT_BUFFER_SIZE;
   }
 
-  size_t write(const uint8_t *data, size_t length) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    return i2s_stream.write(data, length);
+    return i2s_stream.write(data, len);
   }
 
   /// Reads the audio data
-  size_t readBytes(uint8_t *data, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    return i2s_stream.readBytes(data, length);
+    return i2s_stream.readBytes(data, len);
   }
 
   /// Update the audio info with new values: e.g. new sample_rate,

src/AudioLibs/AudioMP34DT05.h

@@ -82,9 +82,9 @@ class AudioMP34DT05 : public AudioStream {
     p_buffer=nullptr;
   }
 
-  size_t readBytes(uint8_t *buffer, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (p_buffer == nullptr) return 0;
-    return p_buffer->readArray(buffer, length);
+    return p_buffer->readArray(data, len);
   }
 
   int available() override {

src/AudioLibs/Desktop/File.h

@@ -115,8 +115,8 @@ class File : public Stream {
         return stream.get();
     } 
 
-    virtual size_t readBytes(uint8_t* buffer, size_t len) override {
+    virtual size_t readBytes(uint8_t* data, size_t len) override {
-         stream.read((char*)buffer, len);
+         stream.read((char*)data, len);
          return stream?len : stream.gcount();
     } 
 

src/AudioLibs/Desktop/JupyterAudio.h

@@ -21,9 +21,9 @@ public:
     FileOutput(std::fstream &stream){
         p_audio_stream = &stream;
     }
-    size_t write(const uint8_t *buffer, size_t size) override {
+    size_t write(const uint8_t *data, size_t len) override {
-         p_audio_stream->write((const char*)buffer,size);
+         p_audio_stream->write((const char*)data,len);
-         return size;
+         return len;
     }
     int availableForWrite() override {
       return 1024;

src/AudioLibs/Desktop/NoArduino.h

@@ -103,12 +103,12 @@ public:
 
 #endif
 
-    virtual size_t write(const uint8_t *buffer, size_t size){
+    virtual size_t write(const uint8_t *data, size_t len){
-        if (buffer == nullptr) return 0;
+        if (data == nullptr) return 0;
-    	for (size_t j=0;j<size;j++){
+    	for (size_t j=0;j<len;j++){
-    		write(buffer[j]);
+    		write(data[j]);
     	}
-    	return size;
+    	return len;
     }
 
 
@@ -125,7 +125,7 @@ public:
 class Stream : public Print {
 public:
 	virtual int available(){return 0;}
-	virtual size_t readBytes(uint8_t* buffer, size_t len) {return 0;}
+	virtual size_t readBytes(uint8_t* data, size_t len) {return 0;}
 #ifndef DOXYGEN
 	virtual int read(){return -1;}
 	virtual int peek(){return -1;}

src/AudioLibs/HLSStream.h

@@ -324,14 +324,14 @@ class HLSParser {
     return result;
   }
 
-  size_t readBytes(uint8_t *buffer, size_t len) {
+  size_t readBytes(uint8_t *data, size_t len) {
     TRACED();
     size_t result = 0;
     custom_log_level.set();
 #if !USE_TASK
     reloadSegments();
 #endif
-    if (active) result = p_url_loader->readBytes(buffer, len);
+    if (active) result = p_url_loader->readBytes(data, len);
     custom_log_level.reset();
     return result;
   }

src/AudioLibs/I2SCodecStream.h

@@ -118,14 +118,14 @@ class I2SCodecStream : public AudioStream, public VolumeSupport {
   }
 
   /// Writes the audio data to I2S
-  virtual size_t write(const uint8_t *buffer, size_t size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    LOGD("I2SStream::write: %d", size);
+    LOGD("I2SStream::write: %d", len);
-    return i2s.write(buffer, size);
+    return i2s.write(data, len);
   }
 
   /// Reads the audio data
-  virtual size_t readBytes(uint8_t *data, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
-    return i2s.readBytes(data, length);
+    return i2s.readBytes(data, len);
   }
 
   /// Provides the available audio data

src/AudioLibs/MozziStream.h

@@ -71,9 +71,9 @@ class MozziStream : public AudioStream, public VolumeSupport {
   }
 
   /// Provides the data filled by calling updateAudio()
-  size_t readBytes(uint8_t* data, size_t byteCount) {
+  size_t readBytes(uint8_t* data, size_t len) {
     if (!active) return 0;
-    int samples = byteCount / sizeof(int16_t);
+    int samples = len / sizeof(int16_t);
     int frames = samples / cfg.channels;
     int16_t* data16 = (int16_t*)data;
     int idx = 0;
@@ -87,12 +87,12 @@ class MozziStream : public AudioStream, public VolumeSupport {
   }
 
   /// Write data to buffer so that we can access them by calling getAudioInput()
-  size_t write(const uint8_t* data, size_t byteCount) {
+  size_t write(const uint8_t* data, size_t len) {
     if (!active) return 0;
     if (buffer.size() == 0) {
-      buffer.resize(byteCount * 2);
+      buffer.resize(len * 2);
     }
-    return buffer.writeArray(data, byteCount);
+    return buffer.writeArray(data, len);
   }
 
   /// Gets the next audio value either from the assigned Input Stream or the

src/AudioLibs/RTSP.h

@@ -578,9 +578,9 @@ public:
    * We write PCM data which is encoded on the fly by the indicated encoder.
    * This data is provided by the IAudioSource
    */
-  size_t write(const uint8_t *buffer, size_t byteCount) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
-    size_t result = p_encoder->write(buffer, byteCount);
+    size_t result = p_encoder->write(data, len);
     return result;
   }
 

src/AudioLibs/StdioStream.h

@@ -27,18 +27,18 @@ public:
 
   int available() override { return DEFAULT_BUFFER_SIZE; }
 
-  size_t readBytes(uint8_t* buffer, size_t len) override {
+  size_t readBytes(uint8_t* data, size_t len) override {
     // read from stdin
-    return ::read(0, buffer, len);
+    return ::read(0, data, len);
   }
 
   int availableForWrite() override { return DEFAULT_BUFFER_SIZE; }
 
-  size_t write(const uint8_t *buffer, size_t len) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!is_open)
       return 0;
     // write to stdout
-    return ::write(1, buffer, len);
+    return ::write(1, data, len);
   }
 
   void end()  {

src/AudioLibs/TfLiteAudioStream.h

@@ -409,7 +409,7 @@ class TfLiteAudioStreamBase : public AudioStream {
     virtual int availableToWrite() = 0;
 
     /// process the data in batches of max kMaxAudioSampleSize.
-    virtual size_t write(const uint8_t* audio, size_t bytes)= 0;
+    virtual size_t write(const uint8_t* data, size_t len)= 0;
     virtual tflite::MicroInterpreter& interpreter()= 0;
 
     /// Provides the TfLiteConfig information
@@ -894,18 +894,18 @@ class TfLiteAudioStream : public TfLiteAudioStreamBase {
   virtual int availableToWrite() override { return DEFAULT_BUFFER_SIZE; }
 
   /// process the data in batches of max kMaxAudioSampleSize.
-  virtual size_t write(const uint8_t* audio, size_t bytes) override {
+  virtual size_t write(const uint8_t* data, size_t len) override {
     TRACED();
     if (cfg.writer==nullptr){
       LOGE("cfg.output is null");
       return 0;
     }
-    int16_t* samples = (int16_t*)audio;
+    int16_t* samples = (int16_t*)data;
-    int16_t sample_count = bytes / 2;
+    int16_t sample_count = len / 2;
     for (int j = 0; j < sample_count; j++) {
       cfg.writer->write(samples[j]);
     }
-    return bytes;
+    return len;
   }
 
   /// We can provide only some audio data when cfg.input is defined

src/AudioLibs/VBANStream.h

@@ -97,11 +97,11 @@ class VBANStream : public AudioStream {
     }
   }
 
-  size_t write(const uint8_t* data, size_t byteCount) override {
+  size_t write(const uint8_t* data, size_t len) override {
     if (!udp_connected) return 0;
 
     int16_t* adc_data = (int16_t*)data;
-    size_t samples = byteCount / (cfg.bits_per_sample/8);
+    size_t samples = len / (cfg.bits_per_sample/8);
 
     // limit output speed
     if (cfg.throttle_active) {
@@ -126,18 +126,18 @@ class VBANStream : public AudioStream {
         tx_buffer.reset();
       }
     }
-    return byteCount;
+    return len;
   }
 
   int availableForWrite() { return cfg.max_write_size; }
 
-  size_t readBytes(uint8_t* data, size_t byteCount) override {
+  size_t readBytes(uint8_t* data, size_t len) override {
     TRACED();
-    size_t samples = byteCount / (cfg.bits_per_sample/8);
+    size_t samples = len / (cfg.bits_per_sample/8);
     if (cfg.throttle_active) {
       throttle.delayFrames(samples / cfg.channels);
     }
-    return rx_buffer.readArray(data, byteCount);
+    return rx_buffer.readArray(data, len);
   }
 
   int available() { return available_active ? rx_buffer.available() : 0; }

src/AudioLibs/VS1053Stream.h

@@ -59,14 +59,14 @@ class VS1053Stream : public AudioStream, public VolumeSupport {
         VS1053StreamOut(VS1053 *vs){
             p_VS1053 = vs;
         }
-        size_t write(const uint8_t *buffer, size_t size) override { 
+        size_t write(const uint8_t *data, size_t len) override { 
             if (p_VS1053==nullptr) {
                 LOGE("NPE");
                 return 0;
             }
             TRACED();
-            p_VS1053->playChunk((uint8_t*)buffer, size);
+            p_VS1053->playChunk((uint8_t*)data, len);
-            return size;
+            return len;
         }
       protected:
         VS1053 *p_VS1053=nullptr;
@@ -229,14 +229,14 @@ public:
     }
 
     /// Write audio data
-    virtual size_t write(const uint8_t *buffer, size_t size) override { 
+    virtual size_t write(const uint8_t *data, size_t len) override { 
         TRACED();
-        if (size==0) return 0;
+        if (len==0) return 0;
         if (p_out==nullptr) {
             LOGE("vs1053 is closed");
             return 0;
         }
-        return p_out->write(buffer, size);
+        return p_out->write(data, len);
     }
 
     /// returns the VS1053 object

src/AudioMetaData/AbstractMetaData.h

@@ -42,7 +42,7 @@ class AbstractMetaData {
         // ends the processing
         virtual void end() = 0;
         // provide audio data which contains the metadata to be extracted
-        virtual size_t write(const uint8_t *data, size_t length) = 0;
+        virtual size_t write(const uint8_t *data, size_t len) = 0;
         // select Icecast/Shoutcast Metadata
         virtual void setIcyMetaInt(int value){}
 

src/AudioMetaData/MetaData.h

@@ -80,13 +80,13 @@ class MetaDataOutput : public AudioOutput {
     }
 
     /// Provide tha audio data to the API to parse for Meta Data
-    virtual size_t write(const uint8_t *data, size_t length){
+    virtual size_t write(const uint8_t *data, size_t len){
-        LOGD("%s: %d", LOG_METHOD, (int)length);
+        LOGD("%s: %d", LOG_METHOD, (int)len);
 
         if (callback!=nullptr){
             if (meta!=nullptr){
                 //CHECK_MEMORY();
-                if (meta->write(data, length)!=length){
+                if (meta->write(data, len)!=len){
                     LOGE("Did not write all data");
                 }
                 //CHECK_MEMORY();
@@ -94,7 +94,7 @@ class MetaDataOutput : public AudioOutput {
                 LOGW("meta is null");
             }
         }
-        return length;
+        return len;
     }
 
      virtual size_t write(uint8_t c) {

src/AudioMetaData/MetaDataICY.h

@@ -69,10 +69,10 @@ class MetaDataICY : public AbstractMetaData {
         }
 
         /// Writes the data in order to retrieve the metadata and perform the corresponding callbacks 
-        virtual size_t write(const uint8_t *buffer, size_t len) override {
+        virtual size_t write(const uint8_t *data, size_t len) override {
             if (callback!=nullptr){
                 for (size_t j=0;j<len;j++){
-                    processChar((char)buffer[j]);
+                    processChar((char)data[j]);
                 }
             }
             return len;

src/AudioMetaData/MetaDataID3.h

@@ -578,13 +578,13 @@ class MetaDataID3 : public AbstractMetaData {
     }
 
     /// Provide tha audio data to the API to parse for Meta Data
-    virtual size_t write(const uint8_t *data, size_t length){
+    virtual size_t write(const uint8_t *data, size_t len){
         TRACED();
-        if (filter & SELECT_ID3V2) id3v2.write(data, length);
+        if (filter & SELECT_ID3V2) id3v2.write(data, len);
         if (!id3v2.isProcessed()) {
-            if (filter & SELECT_ID3V1) id3v1.write(data, length);
+            if (filter & SELECT_ID3V1) id3v1.write(data, len);
         }
-        return length;
+        return len;
     }
 
   protected:

src/AudioPWM/AudioPWM.h

@@ -65,8 +65,8 @@ class PWMAudioOutput : public AudioOutput {
 
   // blocking write for an array: we expect a singed value and convert it into a
   // unsigned
-  size_t write(const uint8_t *wrt_buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    return pwm.write(wrt_buffer, size);
+    return pwm.write(data, len);
   }
 
   // When the timer does not have enough data we increase the underflow_count;

src/AudioPWM/PWMAudioBase.h

@@ -164,15 +164,15 @@ class DriverPWMBase {
 
   // blocking write for an array: we expect a singed value and convert it into a
   // unsigned
-  virtual size_t write(const uint8_t *wrt_buffer, size_t bytes) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    size_t size = bytes;
+    size_t size = len;
 
     // only allow full frame
     size = (size / frame_size) * frame_size;
     LOGD("adjusted size: %d", (int)size);
 
     if (isDecimateActive()) {
-      size = decimate.convert((uint8_t *)wrt_buffer, size);
+      size = decimate.convert((uint8_t *)data, size);
       LOGD("decimated size: %d", (int)size);
     }
 
@@ -183,7 +183,7 @@ class DriverPWMBase {
       size = min((size_t)availableForWrite(), size);
     }
 
-    size_t result = buffer->writeArray(wrt_buffer, size);
+    size_t result = buffer->writeArray(data, size);
     if (result != size) {
       LOGW("Could not write all data: %u -> %d", (unsigned int)size, result);
     }

src/AudioTools/AudioIO.h

@@ -41,8 +41,8 @@ class TransformationReader {
     }
   }
 
-  size_t readBytes(uint8_t *data, size_t byteCount) {
+  size_t readBytes(uint8_t *data, size_t len) {
-    LOGD("TransformationReader::readBytes: %d", (int)byteCount);
+    LOGD("TransformationReader::readBytes: %d", (int)len);
     if (!active) {
       LOGE("inactive");
       return 0;
@@ -54,7 +54,7 @@ class TransformationReader {
 
     // we read half the necessary bytes
     if (buffer.size() == 0) {
-      int size = (0.5 / p_transform->getByteFactor() * byteCount);
+      int size = (0.5 / p_transform->getByteFactor() * len);
       // process full samples/frames
       size = size / 4 * 4;
       LOGI("read size: %d", size);
@@ -63,16 +63,16 @@ class TransformationReader {
 
     if (rb.size() == 0) {
       // make sure that the ring buffer is big enough
-      int rb_size = byteCount * byte_count_factor;
+      int rb_size = len * byte_count_factor;
       LOGI("buffer size: %d", rb_size);
       rb.resize(rb_size);
       result_queue.begin();
     }
 
-    if (result_queue.available() < byteCount) {
+    if (result_queue.available() < len) {
       Print *tmp = setupOutput();
       int zero_count = 0;
-      while (result_queue.available() < byteCount) {
+      while (result_queue.available() < len) {
         int read_eff = p_stream->readBytes(buffer.data(), buffer.size());
         if (read_eff > 0) {
           zero_count  = 0; // reset 0 count
@@ -93,9 +93,9 @@ class TransformationReader {
       restoreOutput(tmp);
     }
 
-    int result_len = min((int)byteCount, result_queue.available());
+    int result_len = min((int)len, result_queue.available());
     result_len = result_queue.readBytes(data, result_len);
-    LOGD("TransformationReader::readBytes: %d -> %d", (int)byteCount,
+    LOGD("TransformationReader::readBytes: %d -> %d", (int)len,
          result_len);
 
     return result_len;
@@ -169,9 +169,9 @@ class ReformatBaseStream : public ModifyingStream {
 
   virtual Stream *getStream() { return p_stream; }
 
-  size_t readBytes(uint8_t *data, size_t size) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    LOGD("ReformatBaseStream::readBytes: %d", (int)size);
+    LOGD("ReformatBaseStream::readBytes: %d", (int)len);
-    return reader.readBytes(data, size);
+    return reader.readBytes(data, len);
   }
 
   int available() override {
@@ -230,8 +230,8 @@ class AdapterPrintToAudioOutput : public AudioOutputAdapter {
  public:
   AdapterPrintToAudioOutput(Print &print) { p_print = &print; }
   void setAudioInfo(AudioInfo info) {}
-  size_t write(const uint8_t *buffer, size_t size) {
+  size_t write(const uint8_t *data, size_t len) {
-    return p_print->write(buffer, size);
+    return p_print->write(data, len);
   }
   /// If true we need to release the related memory in the destructor
   virtual bool isDeletable() { return true; }
@@ -254,8 +254,8 @@ class AdapterAudioStreamToAudioOutput : public AudioOutputAdapter {
 
   void setAudioInfo(AudioInfo info) override { p_stream->setAudioInfo(info); }
 
-  size_t write(const uint8_t *buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    return p_stream->write(buffer, size);
+    return p_stream->write(data, len);
   }
 
   int availableForWrite() override { return p_stream->availableForWrite(); }
@@ -284,8 +284,8 @@ class AdapterAudioOutputToAudioStream : public AudioStream {
   void setOutput(AudioOutput &stream) { p_stream = &stream; }
 
   void setAudioInfo(AudioInfo info) { p_stream->setAudioInfo(info); }
-  size_t write(const uint8_t *buffer, size_t size) {
+  size_t write(const uint8_t *data, size_t len) {
-    return p_stream->write(buffer, size);
+    return p_stream->write(data, len);
   }
 
   /// If true we need to release the related memory in the destructor
@@ -367,17 +367,17 @@ class MultiOutput : public ModifyingOutput {
     }
   }
 
-  size_t write(const uint8_t *buffer, size_t size) {
+  size_t write(const uint8_t *data, size_t len) {
     for (int j = 0; j < vector.size(); j++) {
-      int open = size;
+      int open = len;
       int start = 0;
       while (open > 0) {
-        int written = vector[j]->write(buffer + start, open);
+        int written = vector[j]->write(data + start, open);
         open -= written;
         start += written;
       }
     }
-    return size;
+    return len;
   }
 
   size_t write(uint8_t ch) {
@@ -479,7 +479,7 @@ class TimedStream : public ModifyingStream {
   /// Provides only data for the indicated start and end time. Only supported
   /// for data which does not contain any heder information: so PCM, mp3 should
   /// work!
-  size_t readBytes(uint8_t *buffer, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     // if reading is not supported we stop
     if (p_stream == nullptr) return 0;
     // Positioin to start
@@ -491,19 +491,19 @@ class TimedStream : public ModifyingStream {
     // read the data now
     size_t result = 0;
     do {
-      result = p_stream->readBytes(buffer, length);
+      result = p_stream->readBytes(data, len);
-      current_bytes += length;
+      current_bytes += len;
       // ignore data before start time
     } while (result > 0 && current_bytes < start_bytes);
     return isPlaying() ? result : 0;
   }
 
   /// Plays only data for the indiated start and end time
-  size_t write(const uint8_t *buffer, size_t length) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (current_bytes >= end_bytes) return 0; 
-    current_bytes += length;
+    current_bytes += len;
-    if (current_bytes < start_bytes) return length;
+    if (current_bytes < start_bytes) return len;
-    return p_print->write(buffer, length);
+    return p_print->write(data, len);
   }
 
   /// Provides the available bytes until the end time has reached
@@ -698,16 +698,16 @@ class ChannelsSelectOutput : public AudioOutput {
     out_channels.push_back(def);
   }
 
-  size_t write(const uint8_t *buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (!is_active) return false;
-    LOGD("write %d", (int)size);
+    LOGD("write %d", (int)len);
     switch (cfg.bits_per_sample) {
       case 16:
-        return writeT<int16_t>(buffer, size);
+        return writeT<int16_t>(data, len);
       case 24:
-        return writeT<int24_t>(buffer, size);
+        return writeT<int24_t>(data, len);
       case 32:
-        return writeT<int32_t>(buffer, size);
+        return writeT<int32_t>(data, len);
       default:
         return 0;
     }

src/AudioTools/AudioOutput.h

@@ -23,7 +23,7 @@ class AudioOutput : public Print,
 public:
   virtual ~AudioOutput() = default;
 
-  virtual size_t write(const uint8_t *buffer, size_t size) override = 0;
+  virtual size_t write(const uint8_t *data, size_t len) override = 0;
 
   virtual size_t write(uint8_t ch) override {
     if (tmp.isFull()) {
@@ -364,8 +364,8 @@ public:
 
   /// Write the data from a simgle stream which will be mixed together (the
   /// stream idx is increased)
-  size_t write(const uint8_t *buffer_c, size_t bytes) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    size_t result = write(stream_idx, buffer_c, bytes);
+    size_t result = write(stream_idx, data, len);
     // after writing the last stream we flush
     if (is_auto_index) {
       stream_idx++;
@@ -569,23 +569,23 @@ public:
     }
   }
 
-  size_t write(const uint8_t *buffer, size_t size) {
+  size_t write(const uint8_t *data, size_t len) {
     clear();
     switch (info.bits_per_sample) {
     case 16:
-      updateVolumes<int16_t>(buffer, size);
+      updateVolumes<int16_t>(data, len);
       break;
     case 24:
-      updateVolumes<int24_t>(buffer, size);
+      updateVolumes<int24_t>(data, len);
       break;
     case 32:
-      updateVolumes<int32_t>(buffer, size);
+      updateVolumes<int32_t>(data, len);
       break;
     default:
       LOGE("Unsupported bits_per_sample: %d", info.bits_per_sample);
       break;
     }
-    return size;
+    return len;
   }
 
   /// Determines the volume (max amplitude). The range depends on the
@@ -677,11 +677,11 @@ public:
     return true;
   }
 
-  size_t write(const uint8_t *buffer, size_t len) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (p_next == nullptr)
       return 0;
     if (pos + len <= max_size) {
-      memcpy(p_next, buffer, len);
+      memcpy(p_next, data, len);
       pos += len;
       p_next += len;
       return len;
@@ -728,14 +728,14 @@ public:
     out_channels.push_back(def);
   }
 
-  size_t write(const uint8_t *buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     switch(cfg.bits_per_sample){
       case 16:
-        return writeT<int16_t>(buffer, size);
+        return writeT<int16_t>(data, len);
       case 24:
-        return writeT<int24_t>(buffer, size);
+        return writeT<int24_t>(data, len);
       case 32:
-        return writeT<int32_t>(buffer, size);
+        return writeT<int32_t>(data, len);
       default:
         return 0;
     }

src/AudioTools/AudioSPDIF.h

@@ -214,12 +214,12 @@ class SPDIFOutput : public AudioStream {
   }
 
   /// Writes the audio data as SPDIF to the defined output pin
-  size_t write(const uint8_t *src, size_t size) {
+  size_t write(const uint8_t *data, size_t len) {
     if (!i2sOn) return 0;
-    const uint8_t *p = src;
+    const uint8_t *p = data;
     size_t result = 0;
 
-    while (p < (uint8_t *)src + size) {
+    while (p < (uint8_t *)data + len) {
       // convert PCM 16bit data to BMC 32bit pulse pattern
       if (cfg.channels == 2) {
         *(spdif_ptr + 1) =

src/AudioTools/AudioStreams.h

@@ -31,10 +31,10 @@ class AudioStreamWrapper : public AudioStream {
   virtual bool begin(){return true;}
   virtual void end(){}
 
-  virtual size_t readBytes(uint8_t *buffer, size_t length) {
+  virtual size_t readBytes(uint8_t *data, size_t len) {
       //Serial.print("Timeout audiostream: ");
       //Serial.println(p_stream->getTimeout());
-    return p_stream->readBytes(buffer, length);
+    return p_stream->readBytes(data, len);
   }
 
   int read() { return p_stream->read(); }
@@ -45,8 +45,8 @@ class AudioStreamWrapper : public AudioStream {
 
   virtual size_t write(uint8_t c) { return p_stream->write(c); }
 
-  virtual size_t write(const uint8_t *buffer, size_t size) {
+  virtual size_t write(const uint8_t *data, size_t len) {
-    return p_stream->write(buffer, size);
+    return p_stream->write(data, len);
   }
 
   virtual int availableForWrite() { return p_stream->availableForWrite(); }
@@ -156,12 +156,12 @@ class MemoryStream : public AudioStream {
     return result;
   }
 
-  virtual size_t write(const uint8_t *buffer, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     if (!is_active) return 0;
     if (memory_type == FLASH_RAM) return 0;
     size_t result = 0;
-    for (size_t j = 0; j < size; j++) {
+    for (size_t j = 0; j < len; j++) {
-      if (!write(buffer[j])) {
+      if (!write(data[j])) {
         break;
       }
       result = j + 1;
@@ -197,13 +197,13 @@ class MemoryStream : public AudioStream {
     return result;
   }
 
-  virtual size_t readBytes(uint8_t *buffer, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
     if (!is_active) return 0;
     size_t count = 0;
-    while (count < length) {
+    while (count < len) {
       int c = read();
       if (c < 0) break;
-      *buffer++ = (char)c;
+      *data++ = (char)c;
       count++;
     }
     return count;
@@ -347,8 +347,8 @@ class RingBufferStream : public AudioStream {
   virtual int peek() override { return buffer.peek(); }
   virtual int read() override { return buffer.read(); }
 
-  virtual size_t readBytes(uint8_t *data, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
-    return buffer.readArray(data, length);
+    return buffer.readArray(data, len);
   }
 
   virtual size_t write(const uint8_t *data, size_t len) override {
@@ -441,10 +441,10 @@ class GeneratedSoundStream : public AudioStream {
   virtual int available() override { return active ? DEFAULT_BUFFER_SIZE*2 : 0; }
 
   /// privide the data as byte stream
-  size_t readBytes(uint8_t *buffer, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (!active) return 0;
-    LOGD("GeneratedSoundStream::readBytes: %u", (unsigned int)length);
+    LOGD("GeneratedSoundStream::readBytes: %u", (unsigned int)len);
-    return generator_ptr->readBytes(buffer, length);
+    return generator_ptr->readBytes(data, len);
   }
 
   bool isActive() {return active && generator_ptr->isActive();}
@@ -542,12 +542,12 @@ class BufferedStream : public ModifyingStream {
   };
 
   /// Use this method !!
-  size_t readBytes(uint8_t *data, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (buffer.isEmpty()) {
-      return readExt(data, length);
+      return readExt(data, len);
     } else {
       refill();
-      return buffer.readArray(data, length);
+      return buffer.readArray(data, len);
     }
   }
 
@@ -627,18 +627,18 @@ class ConverterStream : public ModifyingStream {
 
         virtual int availableForWrite() { return p_out->availableForWrite(); }
 
-        virtual size_t write(const uint8_t *buffer, size_t size) { 
+        virtual size_t write(const uint8_t *data, size_t len) { 
-          size_t result = p_converter->convert((uint8_t *)buffer, size); 
+          size_t result = p_converter->convert((uint8_t *)data, len); 
           if (result>0) {
-            size_t result_written = p_out->write(buffer, result);
+            size_t result_written = p_out->write(data, result);
-            return size * result_written / result;
+            return len * result_written / result;
           }
           return 0;
         }
 
-        size_t readBytes(uint8_t *data, size_t length) override {
+        size_t readBytes(uint8_t *data, size_t len) override {
           if (p_stream==nullptr) return 0;
-          size_t result = p_stream->readBytes(data, length);
+          size_t result = p_stream->readBytes(data, len);
           return p_converter->convert(data, result); 
         }
 
@@ -710,8 +710,8 @@ class MeasuringStream : public ModifyingStream {
     }
 
     /// Writes raw PCM audio data, which will be the input for the volume control 
-    virtual size_t write(const uint8_t *buffer, size_t size) override {
+    virtual size_t write(const uint8_t *data, size_t len) override {
-      return measure(p_print->write(buffer, size));
+      return measure(p_print->write(data, len));
     }
 
     /// Provides the nubmer of bytes we can write
@@ -916,9 +916,9 @@ class ProgressStream : public ModifyingStream {
     }
 
     /// Writes raw PCM audio data, which will be the input for the volume control 
-    virtual size_t write(const uint8_t *buffer, size_t size) override {
+    virtual size_t write(const uint8_t *data, size_t len) override {
       if (p_print==nullptr) return 0;
-      return measure(p_print->write(buffer, size));
+      return measure(p_print->write(data, len));
     }
 
     /// Provides the nubmer of bytes we can write
@@ -1037,7 +1037,7 @@ class Throttle : public ModifyingStream {
     return p_in->available();
   }
 
-  size_t readBytes(uint8_t* data, size_t len){
+  size_t readBytes(uint8_t* data, size_t len) override{
     if (p_in==nullptr) {
       delayBytes(len);
       return 0;
@@ -1547,16 +1547,16 @@ class FilteredStream : public ModifyingStream {
           return AudioStream::begin();
         }
 
-        virtual size_t write(const uint8_t *buffer, size_t size) override { 
+        virtual size_t write(const uint8_t *data, size_t len) override { 
            if (p_converter==nullptr) return 0;
-           size_t result = p_converter->convert((uint8_t *)buffer, size); 
+           size_t result = p_converter->convert((uint8_t *)data, len); 
-           return p_print->write(buffer, result);
+           return p_print->write(data, result);
         }
 
-        size_t readBytes(uint8_t *data, size_t length) override {
+        size_t readBytes(uint8_t *data, size_t len) override {
            if (p_converter==nullptr) return 0;
            if (p_stream==nullptr) return 0;
-           size_t result = p_stream->readBytes(data, length);
+           size_t result = p_stream->readBytes(data, len);
            result = p_converter->convert(data, result); 
            return result;
         }

src/AudioTools/AudioStreamsConverter.h

@@ -37,32 +37,32 @@ class ChannelFormatConverterStreamT : public ReformatBaseStream {
 
   void setToChannels(uint16_t channels) { to_channels = channels; }
 
-  virtual size_t write(const uint8_t *data, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     if (p_print == nullptr) return 0;
     addNotifyOnFirstWrite();
     if (from_channels == to_channels) {
-      return p_print->write(data, size);
+      return p_print->write(data, len);
     }
-    size_t resultBytes = convert(data, size);
+    size_t resultBytes = convert(data, len);
-    assert(resultBytes = factor * size);
+    assert(resultBytes = factor * len);
     p_print->write((uint8_t *)buffer.data(), resultBytes);
-    return size;
+    return len;
   }
 
-  size_t readBytes(uint8_t *data, size_t size) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
     if (p_stream == nullptr) return 0;
     if (from_channels == to_channels) {
-      return p_stream->readBytes(data, size);
+      return p_stream->readBytes(data, len);
     }
-    size_t in_bytes = 1.0f / factor * size;
+    size_t in_bytes = 1.0f / factor * len;
     bufferTmp.resize(in_bytes);
     p_stream->readBytes(bufferTmp.data(), in_bytes);
     size_t resultBytes = convert(bufferTmp.data(), in_bytes);
-    assert(size == resultBytes);
+    assert(len == resultBytes);
-    memcpy(data, (uint8_t *)buffer.data(), size);
+    memcpy(data, (uint8_t *)buffer.data(), len);
-    return size;
+    return len;
   }
 
   void setAudioInfo(AudioInfo cfg) override {
@@ -187,35 +187,35 @@ class ChannelFormatConverterStream : public ReformatBaseStream {
 
   void setToChannels(uint16_t channels) { to_channels = channels; }
 
-  virtual size_t write(const uint8_t *data, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    LOGD("ChannelFormatConverterStream::write: %d", (int)size);
+    LOGD("ChannelFormatConverterStream::write: %d", (int)len);
     if (p_print == nullptr) return 0;
     addNotifyOnFirstWrite();
     switch (bits_per_sample) {
       case 8:
-        return getConverter<int8_t>()->write(data, size);
+        return getConverter<int8_t>()->write(data, len);
       case 16:
-        return getConverter<int16_t>()->write(data, size);
+        return getConverter<int16_t>()->write(data, len);
       case 24:
-        return getConverter<int24_t>()->write(data, size);
+        return getConverter<int24_t>()->write(data, len);
       case 32:
-        return getConverter<int32_t>()->write(data, size);
+        return getConverter<int32_t>()->write(data, len);
       default:
         return 0;
     }
   }
 
-  size_t readBytes(uint8_t *data, size_t size) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    LOGD("ChannelFormatConverterStream::readBytes: %d", (int)size);
+    LOGD("ChannelFormatConverterStream::readBytes: %d", (int)len);
     switch (bits_per_sample) {
       case 8:
-        return getConverter<int8_t>()->readBytes(data, size);
+        return getConverter<int8_t>()->readBytes(data, len);
       case 16:
-        return getConverter<int16_t>()->readBytes(data, size);
+        return getConverter<int16_t>()->readBytes(data, len);
       case 24:
-        return getConverter<int24_t>()->readBytes(data, size);
+        return getConverter<int24_t>()->readBytes(data, len);
       case 32:
-        return getConverter<int32_t>()->readBytes(data, size);
+        return getConverter<int32_t>()->readBytes(data, len);
       default:
         return 0;
     }
@@ -358,12 +358,12 @@ class NumberFormatConverterStreamT : public ReformatBaseStream {
     return true;
   }
 
-  virtual size_t write(const uint8_t *data, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     if (p_print == nullptr) return 0;
     addNotifyOnFirstWrite();
-    if (sizeof(TFrom) == sizeof(TTo)) return p_print->write(data, size);
+    if (sizeof(TFrom) == sizeof(TTo)) return p_print->write(data, len);
-    size_t samples = size / sizeof(TFrom);
+    size_t samples = len / sizeof(TFrom);
     size_t result_size = 0;
     TFrom *data_source = (TFrom *)data;
 
@@ -381,13 +381,13 @@ class NumberFormatConverterStreamT : public ReformatBaseStream {
       buffer.reset();
     }
 
-    return size;
+    return len;
   }
 
-  size_t readBytes(uint8_t *data, size_t size) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    LOGD("NumberFormatConverterStreamT::readBytes: %d", (int)size);
+    LOGD("NumberFormatConverterStreamT::readBytes: %d", (int)len);
     if (p_stream == nullptr) return 0;
-    size_t samples = size / sizeof(TTo);
+    size_t samples = len / sizeof(TTo);
     TTo *data_target = (TTo *)data;
     TFrom source;
     if (!is_buffered) {
@@ -404,7 +404,7 @@ class NumberFormatConverterStreamT : public ReformatBaseStream {
                                                 gain);
       buffer.reset();
     }
-    return size;
+    return len;
   }
 
   virtual int available() override {
@@ -523,25 +523,25 @@ class NumberFormatConverterStream : public ReformatBaseStream {
     return result;
   }
 
-  virtual size_t write(const uint8_t *data, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    LOGD("NumberFormatConverterStream::write: %d", (int)size);
+    LOGD("NumberFormatConverterStream::write: %d", (int)len);
     if (p_print == nullptr) return 0;
     if (from_bit_per_samples == to_bit_per_samples) {
-      return p_print->write(data, size);
+      return p_print->write(data, len);
     }
 
     if (from_bit_per_samples == 8 && to_bit_per_samples == 16) {
-      return getConverter<int8_t, int16_t>()->write(data, size);
+      return getConverter<int8_t, int16_t>()->write(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 8) {
-      return getConverter<int16_t, int8_t>()->write(data, size);
+      return getConverter<int16_t, int8_t>()->write(data, len);
     } else if (from_bit_per_samples == 24 && to_bit_per_samples == 16) {
-      return getConverter<int24_t, int16_t>()->write(data, size);
+      return getConverter<int24_t, int16_t>()->write(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 24) {
-      return getConverter<int16_t, int24_t>()->write(data, size);
+      return getConverter<int16_t, int24_t>()->write(data, len);
     } else if (from_bit_per_samples == 32 && to_bit_per_samples == 16) {
-      return getConverter<int32_t, int16_t>()->write(data, size);
+      return getConverter<int32_t, int16_t>()->write(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 32) {
-      return getConverter<int16_t, int32_t>()->write(data, size);
+      return getConverter<int16_t, int32_t>()->write(data, len);
     } else {
       LOGE("bit combination not supported %d -> %d", from_bit_per_samples,
            to_bit_per_samples);
@@ -549,23 +549,23 @@ class NumberFormatConverterStream : public ReformatBaseStream {
     }
   }
 
-  size_t readBytes(uint8_t *data, size_t size) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    LOGD("NumberFormatConverterStream::readBytes: %d", (int)size);
+    LOGD("NumberFormatConverterStream::readBytes: %d", (int)len);
     if (from_bit_per_samples == to_bit_per_samples) {
-      return p_stream->readBytes(data, size);
+      return p_stream->readBytes(data, len);
     }
     if (from_bit_per_samples == 8 && to_bit_per_samples == 16) {
-      return getConverter<int8_t, int16_t>()->readBytes(data, size);
+      return getConverter<int8_t, int16_t>()->readBytes(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 8) {
-      return getConverter<int16_t, int8_t>()->readBytes(data, size);
+      return getConverter<int16_t, int8_t>()->readBytes(data, len);
     } else if (from_bit_per_samples == 24 && to_bit_per_samples == 16) {
-      return getConverter<int24_t, int16_t>()->readBytes(data, size);
+      return getConverter<int24_t, int16_t>()->readBytes(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 24) {
-      return getConverter<int16_t, int24_t>()->readBytes(data, size);
+      return getConverter<int16_t, int24_t>()->readBytes(data, len);
     } else if (from_bit_per_samples == 32 && to_bit_per_samples == 16) {
-      return getConverter<int32_t, int16_t>()->readBytes(data, size);
+      return getConverter<int32_t, int16_t>()->readBytes(data, len);
     } else if (from_bit_per_samples == 16 && to_bit_per_samples == 32) {
-      return getConverter<int16_t, int32_t>()->readBytes(data, size);
+      return getConverter<int16_t, int32_t>()->readBytes(data, len);
     } else {
       TRACEE();
       return 0;
@@ -788,10 +788,10 @@ class FormatConverterStream : public ReformatBaseStream {
     return result;
   }
 
-  virtual size_t write(const uint8_t *data, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    LOGD("FormatConverterStream::write: %d", (int)size);
+    LOGD("FormatConverterStream::write: %d", (int)len);
     addNotifyOnFirstWrite();
-    return channelFormatConverter.write(data, size);
+    return channelFormatConverter.write(data, len);
   }
 
   /// Buffering is active by default to minimize the number of output calls

src/AudioTools/AudioTypes.h

@@ -227,7 +227,7 @@ class VolumeSupport {
  */
 class AudioWriter : public AudioInfoSupport {
     public: 
-        virtual size_t write(const void *in_ptr, size_t in_size) = 0;
+        virtual size_t write(const uint8_t *data, size_t len) = 0;
         virtual void setAudioInfo(AudioInfo from) = 0;
         virtual void setOutput(Print &out_stream) = 0;
         virtual operator bool() = 0;

src/AudioTools/BaseStream.h

@@ -41,9 +41,9 @@ class BaseStream : public Stream {
   virtual bool begin(){return true;}
   virtual void end(){}
 
-  virtual size_t readBytes(uint8_t *buffer,
+  virtual size_t readBytes(uint8_t *data,
-                           size_t length) STREAM_READ_OVERRIDE = 0;
+                           size_t len) STREAM_READ_OVERRIDE = 0;
-  virtual size_t write(const uint8_t *buffer, size_t size) override = 0;
+  virtual size_t write(const uint8_t *data, size_t len) override = 0;
 
   virtual size_t write(uint8_t ch) override {
     tmp_out.resize(MAX_SINGLE_CHARS);
@@ -66,9 +66,8 @@ class BaseStream : public Stream {
 // Methods which should be suppressed in the documentation
 #ifndef DOXYGEN
 
-  virtual size_t readBytes(char *buffer,
+  virtual size_t readBytes(char *data, size_t len) STREAM_READCHAR_OVERRIDE {
-                           size_t length) STREAM_READCHAR_OVERRIDE {
+    return readBytes((uint8_t *)data, len);
-    return readBytes((uint8_t *)buffer, length);
   }
 
   virtual int read() override {
@@ -131,9 +130,9 @@ class AudioStream : public BaseStream, public AudioInfoSupport, public AudioInfo
 
   }
 
-  virtual size_t readBytes(uint8_t *buffer, size_t length) override { return not_supported(0, "readBytes"); }
+  virtual size_t readBytes(uint8_t *data, size_t len) override { return not_supported(0, "readBytes"); }
 
-  virtual size_t write(const uint8_t *buffer, size_t size) override{ return not_supported(0,"write"); }
+  virtual size_t write(const uint8_t *data, size_t len) override{ return not_supported(0,"write"); }
 
 
   virtual operator bool() { return info && available() > 0; }
@@ -222,7 +221,7 @@ class CatStream : public BaseStream {
   void setTimeout(uint32_t t) { _timeout = t; }
 
   /// not supported
-  size_t write(const uint8_t *buffer, size_t size) override { return 0;};
+  size_t write(const uint8_t *data, size_t size) override { return 0;};
 
  protected:
   Vector<Stream *> input_streams;
@@ -277,10 +276,10 @@ class CatStream : public BaseStream {
  */
 class NullStream : public BaseStream {
  public:
-  size_t write(const uint8_t *buffer, size_t len) override { return len; }
+  size_t write(const uint8_t *data, size_t len) override { return len; }
 
-  size_t readBytes(uint8_t *buffer, size_t len) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
-    memset(buffer, 0, len);
+    memset(data, 0, len);
     return len;
   }
 };
@@ -477,11 +476,11 @@ public:
     it = audio_list.begin();
   }
 
-  virtual size_t write(const uint8_t *buffer, size_t size) override {
+  virtual size_t write(const uint8_t *data, size_t len) override {
-    DataNode *p_node = new DataNode((void*)buffer, size);
+    DataNode *p_node = new DataNode((void*)data, len);
     if (p_node->data){
       alloc_failed = false;
-      total_available += size;
+      total_available += len;
       audio_list.push_back(p_node);
 
       // setup interator to point to first record
@@ -489,7 +488,7 @@ public:
         it = audio_list.begin();
       }
 
-      return size;
+      return len;
     } 
     alloc_failed = true;
     return 0;
@@ -509,10 +508,10 @@ public:
     return (*it)->len;
   }
 
-  virtual size_t readBytes(uint8_t *buffer, size_t length) override {
+  virtual size_t readBytes(uint8_t *data, size_t len) override {
     // provide unprocessed data
     if (temp_audio.available()>0){
-      return temp_audio.readArray(buffer, length);
+      return temp_audio.readArray(data, len);
     }
 
     // We have no more data
@@ -527,12 +526,12 @@ public:
 
     // provide data from next node
     DataNode *p_node = *it;
-    int result_len = min(length, (size_t) p_node->len);
+    int result_len = min(len, (size_t) p_node->len);
-    memcpy(buffer, &p_node->data[0], result_len);
+    memcpy(data, &p_node->data[0], result_len);
     // save unprocessed data to temp buffer
-    if (p_node->len>length){
+    if (p_node->len>len){
       uint8_t *start = &p_node->data[result_len];
-      int uprocessed_len = p_node->len - length; 
+      int uprocessed_len = p_node->len - len; 
       temp_audio.writeArray(start, uprocessed_len);
     }
     //move to next pos

src/AudioTools/Fade.h

@@ -270,31 +270,31 @@ public:
     active = true;
   }
 
-  size_t readBytes(uint8_t *buffer, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     if (!active) {
       LOGE("%s", error_msg);
       return 0;
     }
-    fade.convert(buffer, length, info.channels, info.bits_per_sample);
+    fade.convert(data, len, info.channels, info.bits_per_sample);
-    fade_last.write(buffer, length);
+    fade_last.write(data, len);
-    return p_io->readBytes(buffer, length);
+    return p_io->readBytes(data, len);
   }
 
   int available() override { return p_io == nullptr ? 0 : p_io->available(); }
 
-  size_t write(const uint8_t *buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     if (p_out==nullptr) return 0;
     if (!active) {
       LOGE("%s", error_msg);
       return 0;
     }
     if (fade.isFadeInActive() || fade.isFadeOutActive()){
-      fade.convert((uint8_t *)buffer, size, info.channels, info.bits_per_sample);
+      fade.convert((uint8_t *)data, len, info.channels, info.bits_per_sample);
     }
     // update last information
-    fade_last.write((uint8_t *)buffer, size);
+    fade_last.write((uint8_t *)data, len);
     // write faded data
-    return p_out->write(buffer, size);
+    return p_out->write(data, len);
   }
 
   int availableForWrite() override {

src/AudioTools/Pipeline.h

@@ -139,14 +139,14 @@ class Pipeline : public AudioStream {
     return components[0]->availableForWrite();
   }
 
-  size_t write(const uint8_t* data, size_t bytes) override {
+  size_t write(const uint8_t* data, size_t len) override {
     if (!is_active) return 0;
     if (size() == 0) {
-      if (p_print != nullptr) return p_print->write(data, bytes);
+      if (p_print != nullptr) return p_print->write(data, len);
       return 0;
     }
-    LOGD("write: %u", (unsigned)bytes);
+    LOGD("write: %u", (unsigned)len);
-    return components[0]->write(data, bytes);
+    return components[0]->write(data, len);
   }
 
   int available() override {
@@ -156,11 +156,11 @@ class Pipeline : public AudioStream {
     return in->available();
   }
 
-  size_t readBytes(uint8_t* data, size_t bytes) override {
+  size_t readBytes(uint8_t* data, size_t len) override {
     if (!is_active) return 0;
     Stream* in = getInput();
     if (in == nullptr) return 0;
-    return in->readBytes(data, bytes);
+    return in->readBytes(data, len);
   }
 
   /// Optional method: Calls begin on all components and setAudioInfo on first

src/AudioTools/ResampleStream.h

@@ -159,17 +159,17 @@ class ResampleStream : public ReformatBaseStream {
 
   // int availableForWrite() override { return p_print->availableForWrite(); }
 
-  size_t write(const uint8_t *buffer, size_t bytes) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("ResampleStream::write: %d", (int)bytes);
+    LOGD("ResampleStream::write: %d", (int)len);
     addNotifyOnFirstWrite();
     size_t written = 0;
     switch (info.bits_per_sample) {
       case 16:
-        return write<int16_t>(p_print, buffer, bytes, written);
+        return write<int16_t>(p_print, data, len, written);
       case 24:
-        return write<int24_t>(p_print, buffer, bytes, written);
+        return write<int24_t>(p_print, data, len, written);
       case 32:
-        return write<int32_t>(p_print, buffer, bytes, written);
+        return write<int32_t>(p_print, data, len, written);
       default:
         TRACEE();
     }

src/AudioTools/VolumeStream.h

@@ -129,26 +129,26 @@ class VolumeStream : public ModifyingStream, public VolumeSupport {
         }
 
         /// Read raw PCM audio data, which will be the input for the volume control 
-        virtual size_t readBytes(uint8_t *buffer, size_t length) override { 
+        virtual size_t readBytes(uint8_t *data, size_t len) override { 
             TRACED();
-            if (buffer==nullptr || p_in==nullptr){
+            if (data==nullptr || p_in==nullptr){
                 LOGE("NPE");
                 return 0;
             }
-            size_t result = p_in->readBytes(buffer, length);
+            size_t result = p_in->readBytes(data, len);
-            if (isVolumeUpdate()) applyVolume(buffer, result);
+            if (isVolumeUpdate()) applyVolume(data, result);
             return result;
         }
 
         /// Writes raw PCM audio data, which will be the input for the volume control 
-        virtual size_t write(const uint8_t *buffer, size_t size) override {
+        virtual size_t write(const uint8_t *data, size_t len) override {
-            LOGD("VolumeStream::write: %zu", size);
+            LOGD("VolumeStream::write: %zu", len);
-            if (buffer==nullptr || p_out==nullptr){
+            if (data==nullptr || p_out==nullptr){
                 LOGE("NPE");
                 return 0;
             }
-            if (isVolumeUpdate()) applyVolume(buffer,size);
+            if (isVolumeUpdate()) applyVolume(data,len);
-            return p_out->write(buffer, size);
+            return p_out->write(data, len);
         }
 
         /// Provides the nubmer of bytes we can write

src/Communication/UDPStream.h

@@ -98,22 +98,22 @@ public:
   }
 
   /// Replys will be sent to the initial remote caller
-  size_t write(const uint8_t *buffer, size_t size) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     p_udp->beginPacket(remoteIP(), remotePort());
-    size_t result = p_udp->write(buffer, size);
+    size_t result = p_udp->write(data, len);
     p_udp->endPacket();
     return result;
   }
 
   /// Reads bytes using WiFi::readBytes
-  size_t readBytes(uint8_t *buffer, size_t length) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
     size_t len = available();
     size_t bytes_read = 0;
     if (len > 0) {
       // get the data now
-      bytes_read = p_udp->readBytes((uint8_t *)buffer, length);
+      bytes_read = p_udp->readBytes((uint8_t *)data, len);
     }
     return bytes_read;
   }

src/Sandbox/AudioDAC.h

@@ -154,16 +154,16 @@ class OversamplingDAC : public AudioOutput {
         }
 
         /// Writes the audio data to the output buffer
-        virtual size_t write(const uint8_t *data, size_t size){
+        virtual size_t write(const uint8_t *data, size_t len){
             TRACED();
-            if (size==0) return 0;
+            if (len==0) return 0;
             int16_t *ptr = (int16_t *)data;
 
             // fill buffer with delta sigma data
-            int frames = std::min(size/(bytes_per_sample*info.channels), (size_t) availableFramesToWrite());
+            int frames = std::min(len/(bytes_per_sample*info.channels), (size_t) availableFramesToWrite());
             while(is_blocking && frames==0){
                 delay(10);
-                frames = std::min(size/(bytes_per_sample*info.channels), (size_t) availableFramesToWrite());
+                frames = std::min(len/(bytes_per_sample*info.channels), (size_t) availableFramesToWrite());
             }
             int samples = frames * info.channels;
             for (int j=0; j<samples; j++){
@@ -469,9 +469,9 @@ class SerialDAC : public OversamplingDAC32 {
         }
 
         /// just write the data to the UART w/o buffering
-        virtual size_t write(const uint8_t *data, size_t size) override {
+        virtual size_t write(const uint8_t *data, size_t len) override {
             TRACED();
-            return serial->write(data, size);
+            return serial->write(data, len);
         }
 
         virtual uint32_t outputRate() override {

src/Sandbox/BLE/AudioBLEClient.h

@@ -40,7 +40,7 @@ public:
     BLE.end();
   }
 
-  size_t readBytes(uint8_t *data, size_t dataSize) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
     if (!setupBLEClient()) {
       return 0;
@@ -49,12 +49,12 @@ public:
     if (!ch01_char.canRead())
       return 0;
 
-    return ch01_char.readValue(data, dataSize);
+    return ch01_char.readValue(data, len);
   }
 
   int available() override { return BLE_MTU - BLE_MTU_OVERHEAD; }
 
-  size_t write(const uint8_t *data, size_t dataSize) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     if (!setupBLEClient()) {
       return 0;
@@ -65,11 +65,11 @@ public:
     }
 
     if (is_framed) {
-      writeChannel2Characteristic(data, dataSize);
+      writeChannel2Characteristic(data, len);
       delay(1);
     } else {
       // send only data with max mtu
-      for (int j = 0; j < dataSize; j++) {
+      for (int j = 0; j < len; j++) {
         write_buffer.write(data[j]);
         if (write_buffer.isFull()) {
           writeChannel2Characteristic(write_buffer.data(),
@@ -78,7 +78,7 @@ public:
         }
       }
     }
-    return dataSize;
+    return len;
   }
 
   int availableForWrite() override {

src/Sandbox/BLE/AudioBLEClientESP32.h

@@ -50,7 +50,7 @@ public:
     BLEDevice::deinit();
   }
 
-  size_t readBytes(uint8_t *data, size_t dataSize) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
     setupBLEClient();
     if (!is_client_connected || !is_client_set_up)
@@ -68,7 +68,7 @@ public:
 
   int available() override { return BLE_MTU - BLE_MTU_OVERHEAD; }
 
-  size_t write(const uint8_t *data, size_t dataSize) override {
+  size_t write(const uint8_t *data, size_t len) override {
     TRACED();
     setupBLEClient();
     if (!is_client_connected || !is_client_set_up)
@@ -78,11 +78,11 @@ public:
     }
 
     if (is_framed){
-      writeChannel2Characteristic(data, dataSize);
+      writeChannel2Characteristic(data, len);
       delay(1);
     } else {
       // send only data with max mtu
-      for (int j=0; j<dataSize; j++){
+      for (int j=0; j<len; j++){
         write_buffer.write(data[j]);
         if (write_buffer.isFull()){
           writeChannel2Characteristic(write_buffer.data(), write_buffer.available());
@@ -90,7 +90,7 @@ public:
         }
       }
     }
-    return dataSize;
+    return len;
   }
 
   int availableForWrite() override { 

src/Sandbox/BLE/AudioBLEServer.h

@@ -59,11 +59,11 @@ public:
     BLE.end();
   }
 
-  size_t readBytes(uint8_t *data, size_t dataSize) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
     if (!checkCentralConnected())
       return 0;
-    size_t read_size = getReadSize(dataSize);
+    size_t read_size = getReadSize(len);
     return receive_buffer.readArray(data, read_size);
   }
 
@@ -75,14 +75,14 @@ public:
     return this->receive_buffer.available();
   }
 
-  size_t write(const uint8_t *data, size_t dataSize) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    LOGD("AudioBLEStream::write: %d", dataSize);
+    LOGD("AudioBLEStream::write: %d", len);
     if (!checkCentralConnected())
       return 0;
-    if (is_framed && availableForWrite() < dataSize) {
+    if (is_framed && availableForWrite() < len) {
       return 0;
     }
-    return transmit_buffer.writeArray(data, dataSize);
+    return transmit_buffer.writeArray(data, len);
   }
 
   int availableForWrite() override {

src/Sandbox/BLE/AudioBLEServerESP32.h

@@ -44,9 +44,9 @@ public:
     BLEDevice::deinit();
   }
 
-  size_t readBytes(uint8_t *data, size_t dataSize) override {
+  size_t readBytes(uint8_t *data, size_t len) override {
     TRACED();
-    size_t read_size = getReadSize(dataSize);
+    size_t read_size = getReadSize(len);
     return receive_buffer.readArray(data, read_size);
   }
 

src/Sandbox/CodecGGWave.h

@@ -120,16 +120,16 @@ public:
     active = false;
   }
 
-  size_t write(const void *sampleBufferRaw, size_t bytes_read) { 
+  size_t write(const uint8_t *data, size_t len) { 
     if (!active) return 0;
-    uint8_t *p_byte = (uint8_t *)sampleBufferRaw;
+    uint8_t *p_byte = (uint8_t *)data;
-    for (int j=0;j<bytes_read;j++){
+    for (int j=0;j<len;j++){
         receive_buffer.write(p_byte[j]);
         if (receive_buffer.availableForWrite()==0){
           decode();
         }
     }
-    return bytes_read;
+    return len;
    }
 
   operator bool() { return active; }
@@ -249,7 +249,7 @@ public:
     active = false;
   }
 
-  size_t write(const void *data, size_t len) { 
+  size_t write(const uint8_t *data, size_t len) { 
     if (!active) return 0;
 
     if (!ggwave.init(len, (const char*)data, protocolId)){

src/Sandbox/FrequencyDetection.h

@@ -37,37 +37,37 @@ class FrequncyAutoCorrelationStream : public AudioStream {
       return DEFAULT_BUFFER_SIZE;
     }
 
-    size_t readBytes(uint8_t *data, size_t size) override {
+    size_t readBytes(uint8_t *data, size_t len) override {
-      size_t result = p_in->readBytes(data, size);
+      size_t result = p_in->readBytes(data, len);
       switch(info.bits_per_sample){
         case 16:
-          detect<int16_t>((int16_t*)data, size/sizeof(int16_t));
+          detect<int16_t>((int16_t*)data, len/sizeof(int16_t));
           break;
         case 24:
-          detect<int24_t>((int24_t*)data, size/sizeof(int24_t));
+          detect<int24_t>((int24_t*)data, len/sizeof(int24_t));
           break;
         case 32:
-          detect<int32_t>((int32_t*)data, size/sizeof(int32_t));
+          detect<int32_t>((int32_t*)data, len/sizeof(int32_t));
           break;
       }
       return result;
     }
 
-    virtual size_t write(const uint8_t *buffer, size_t size) override { 
+    virtual size_t write(const uint8_t *data, size_t len) override { 
       switch(info.bits_per_sample){
         case 16:
-          detect<int16_t>((int16_t*)buffer, size/sizeof(int16_t));
+          detect<int16_t>((int16_t*)data, len/sizeof(int16_t));
           break;
         case 24:
-          detect<int24_t>((int24_t*)buffer, size/sizeof(int24_t));
+          detect<int24_t>((int24_t*)data, len/sizeof(int24_t));
           break;
         case 32:
-          detect<int32_t>((int32_t*)buffer, size/sizeof(int32_t));
+          detect<int32_t>((int32_t*)data, len/sizeof(int32_t));
           break;
       }
 
-      size_t result = size;
+      size_t result = len;
-      if (p_out!=nullptr) result = p_out->write(buffer, size);
+      if (p_out!=nullptr) result = p_out->write(data, len);
       return result;
     }
 
@@ -161,37 +161,37 @@ class FrequncyZeroCrossingStream : public AudioStream {
       return DEFAULT_BUFFER_SIZE;
     }
 
-    size_t readBytes(uint8_t *data, size_t size) override {
+    size_t readBytes(uint8_t *data, size_t len) override {
-      size_t result = p_in->readBytes(data, size);
+      size_t result = p_in->readBytes(data, len);
       switch(info.bits_per_sample){
         case 16:
-          detect<int16_t>((int16_t*)data, size/sizeof(int16_t));
+          detect<int16_t>((int16_t*)data, len/sizeof(int16_t));
           break;
         case 24:
-          detect<int24_t>((int24_t*)data, size/sizeof(int24_t));
+          detect<int24_t>((int24_t*)data, len/sizeof(int24_t));
           break;
         case 32:
-          detect<int32_t>((int32_t*)data, size/sizeof(int32_t));
+          detect<int32_t>((int32_t*)data, len/sizeof(int32_t));
           break;
       }
       return result;
     }
 
-    virtual size_t write(const uint8_t *buffer, size_t size) override { 
+    virtual size_t write(const uint8_t *data, size_t len) override { 
       switch(info.bits_per_sample){
         case 16:
-          detect<int16_t>((int16_t*)buffer, size/sizeof(int16_t));
+          detect<int16_t>((int16_t*)data, len/sizeof(int16_t));
           break;
         case 24:
-          detect<int24_t>((int24_t*)buffer, size/sizeof(int24_t));
+          detect<int24_t>((int24_t*)data, len/sizeof(int24_t));
           break;
         case 32:
-          detect<int32_t>((int32_t*)buffer, size/sizeof(int32_t));
+          detect<int32_t>((int32_t*)data, len/sizeof(int32_t));
           break;
       }
 
-      size_t result = size;
+      size_t result = len;
-      if (p_out!=nullptr) result = p_out->write(buffer, size);
+      if (p_out!=nullptr) result = p_out->write(data, len);
       return result;
     }
 

src/Sandbox/PDMStream.h

@@ -31,11 +31,11 @@ class DecimationStreamExt : public AudioStream {
   // defines the decimation factor: as multiple of bits_per sample
   void setDecimationFactor(int factor) { dec_factor = factor; }
 
-  size_t readBytes(uint8_t *buffer, size_t byteCount) {
+  size_t readBytes(uint8_t *data, size_t len) {
-    LOGD("readBytes:%d", byteCount);
+    LOGD("readBytes:%d", len);
-    assert(buffer != nullptr);
+    assert(data != nullptr);
     // make sure that we read full samples
-    int samples = byteCount / sizeof(T);
+    int samples = len / sizeof(T);
     int result_bytes = samples * sizeof(T);
 
     // calculated scaling factor and offset for unsigned to signed conversion
@@ -45,7 +45,7 @@ class DecimationStreamExt : public AudioStream {
     int unsigned_to_signed = scaled_max / 2;     // e.g. 32768
 
     // provide subsequent samples
-    T *data = (T *)buffer;
+    T *data_typed = (T *)data;
     T tmp_in;
     for (int idx = 0; idx < samples; idx++) {
       // decimate subsequent samples
@@ -60,7 +60,7 @@ class DecimationStreamExt : public AudioStream {
       }
       // store scaled decimated as singned value
       //data[idx] = (decimated * factor) - unsigned_to_signed;
-      data[idx] = decimated;
+      data_typed[idx] = decimated;
     }
 
     return result_bytes;
@@ -122,11 +122,11 @@ public:
     return true;
   }
 
-  size_t readBytes(uint8_t *buffer, size_t byteCount) {
+  size_t readBytes(uint8_t *data, size_t len) {
-    LOGD("readBytes:%d", byteCount);
+    LOGD("readBytes:%d", len);
-    assert(buffer != nullptr);
+    assert(data != nullptr);
     // make sure that we read full samples
-    int samples = byteCount / sizeof(T);
+    int samples = len / sizeof(T);
     int result_bytes = samples * sizeof(T);
 
     // calculated scaling factor and offset for unsigned to signed conversion
@@ -136,7 +136,7 @@ public:
     int unsigned_to_signed = scaled_max / 2;     // e.g. 32768
 
     // provide subsequent samples
-    T *data = (T *)buffer;
+    T *data_typed = (T *)data;
     T tmp_in;
     for (int idx = 0; idx < samples; idx++) {
       // decimate subsequent samples
@@ -153,7 +153,7 @@ public:
       }
       // store scaled decimated as singned value
       //data[idx] = (decimated * factor) - unsigned_to_signed;
-      data[idx] = decimated;
+      data_typed[idx] = decimated;
     }
 
     return result_bytes;
@@ -216,15 +216,15 @@ class PDMMonoStreamT : public AudioStream {
     return rc;
   }
 
-  size_t readBytes(uint8_t *buffer, size_t byteCount) {
+  size_t readBytes(uint8_t *data, size_t len) {
-    LOGD("readBytes:%d", byteCount);
+    LOGD("readBytes:%d", len);
-    assert(buffer != nullptr);
+    assert(data != nullptr);
     // make sure that we read full samples
-    int samples = byteCount / sizeof(T);
+    int samples = len / sizeof(T);
     int result_bytes = samples * sizeof(T);
-    assert(result_bytes <= byteCount);
+    assert(result_bytes <= len);
 
-    if (in_filtered.readBytes(buffer, result_bytes) != result_bytes) {
+    if (in_filtered.readBytes(data, result_bytes) != result_bytes) {
       LOGE("readBytes failed");
     }
 

src/Video/JpegOpenCV.h

@@ -44,11 +44,11 @@ public:
   }
 
   // Add some more data to the image vector
-  size_t write(const uint8_t *buffer, size_t byteCount) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    memcpy(&img_vector[pos], buffer, byteCount);
+    memcpy(&img_vector[pos], data, len);
-    pos += byteCount;
+    pos += len;
-    open -= byteCount;
+    open -= len;
-    return byteCount;
+    return len;
   }
 
 protected:

src/Video/JpegTFT.h

@@ -42,11 +42,11 @@ public:
   }
 
   // Add some more data to the image vector
-  size_t write(const uint8_t *buffer, size_t byteCount) override {
+  size_t write(const uint8_t *data, size_t len) override {
-    memcpy(&img_vector[pos], buffer, byteCount);
+    memcpy(&img_vector[pos], data, len);
-    pos += byteCount;
+    pos += len;
-    open -= byteCount;
+    open -= len;
-    return byteCount;
+    return len;
   }
 
 protected:

src/Video/Video.h

@@ -21,7 +21,7 @@ namespace audio_tools {
 class VideoOutput {
  public:
   virtual void beginFrame(size_t size) = 0;
-  virtual size_t write(const uint8_t *data, size_t byteCount) = 0;
+  virtual size_t write(const uint8_t *data, size_t len) = 0;
   virtual uint32_t endFrame() = 0;
 };