ChannelFormatConverterStream

src/AudioTools/AudioStreams.h

@@ -1177,6 +1177,10 @@ class ChannelFormatConverterStream : public AudioStreamX {
           from_channels = fromChannels;
           to_channels = toChannels;
           factor = static_cast<float>(toChannels) / static_cast<float>(fromChannels);
+
+          converter.setSourceChannels(from_channels);
+          converter.setTargetChannels(to_channels);
+
           return true;
         }
 
@@ -1220,23 +1224,13 @@ class ChannelFormatConverterStream : public AudioStreamX {
     float factor = 1;
     Vector<T> buffer;
     Vector<uint8_t> bufferTmp;
+    ChannelConverter<T> converter;
 
     size_t convert(const uint8_t *in_data, size_t size){
         size_t result;
         size_t result_samples = size/sizeof(T)*factor;
         buffer.resize(result_samples);
-        memset(buffer.data(),0, size*factor);
-        if (from_channels>to_channels){
-          ChannelReducer<T> reducer;
-          reducer.setSourceChannels(from_channels);
-          reducer.setTargetChannels(to_channels);
-          result = reducer.convert((uint8_t*)buffer.data(),(uint8_t*) in_data, size);
-        } else {
-          ChannelEnhancer<T> enhancer;
-          enhancer.setSourceChannels(from_channels);
-          enhancer.setTargetChannels(to_channels);
-          result = enhancer.convert((uint8_t*)buffer.data(),(uint8_t*) in_data, size);
-        }
+        result = converter.convert((uint8_t*)buffer.data(),(uint8_t*) in_data, size);
         if (result!=result_samples*sizeof(T)){
           LOGE("size %d -> result: %d - expeced: %d", size, result, result_samples*sizeof(T));
         }

src/AudioTools/Converter.h

@@ -407,7 +407,7 @@ class ChannelReducer : public BaseConverter<T> {
  * @tparam T 
  */
 template<typename T>
-class ChannelEnhancer : public BaseConverter<T> {
+class ChannelEnhancer  {
     public:
         ChannelEnhancer() = default;
 
@@ -424,11 +424,6 @@ class ChannelEnhancer : public BaseConverter<T> {
             to_channels = channelCountOfTarget;
         }
 
-        size_t convert(uint8_t*src, size_t size) {
-            // not supported becase the output size is bigger then the input size
-            return 0;
-        }
-
         size_t convert(uint8_t*target, uint8_t*src, size_t size) {
             int frame_count = size/(sizeof(T)*from_channels);
             size_t result_size=0;
@@ -451,11 +446,68 @@ class ChannelEnhancer : public BaseConverter<T> {
             return result_size;
         }
 
+        /// Determine the size of the conversion result
+        size_t resultSize(size_t inSize){
+            return inSize * to_channels / from_channels;
+        }
+
     protected:
         int from_channels;
         int to_channels;
 };
 
+/**
+ * @brief Increasing or decreasing the number of channels
+ * 
+ * @tparam T 
+ */
+template<typename T>
+class ChannelConverter {
+    public:
+        ChannelConverter() = default;
+
+        ChannelConverter(int channelCountOfTarget, int channelCountOfSource){
+            from_channels = channelCountOfSource;
+            to_channels = channelCountOfTarget;
+        }
+
+        void setSourceChannels(int channelCountOfSource) {
+            from_channels = channelCountOfSource;
+        }
+
+        void setTargetChannels(int channelCountOfTarget) {
+            to_channels = channelCountOfTarget;
+        }
+
+        size_t convert(uint8_t*target, uint8_t*src, size_t size) {
+            if (from_channels==to_channels){
+                memcpy(target,src,size);
+                return size;
+            }
+            // setup channels
+            if (from_channels>to_channels){
+                reducer.setSourceChannels(from_channels);
+                reducer.setTargetChannels(to_channels);
+            } else {
+                enhancer.setSourceChannels(from_channels);
+                enhancer.setTargetChannels(to_channels);
+            }
+
+            // execute conversion
+            if (from_channels>to_channels){
+                return reducer.convert(target, src, size);
+            } else {
+                return enhancer.convert(target, src, size);
+            }
+        }
+
+    protected:
+        ChannelEnhancer<T> enhancer;
+        ChannelReducer<T> reducer;
+        int from_channels;
+        int to_channels;
+
+};
 
 /**
  * @brief Combines multiple converters