6 files changed, 30 insertions(+), 12 deletions(-)

M module-audio/Audio/StreamFactory.cpp
M module-audio/Audio/StreamFactory.hpp
M module-audio/Audio/test/unittest_transcode.cpp
M module-audio/Audio/transcode/BasicInterpolator.hpp
M module-audio/Audio/transcode/InputTranscodeProxy.cpp
M module-bluetooth/Bluetooth/audio/BluetoothAudioDevice.cpp

@@ 84,7 84,7 @@ auto StreamFactory::makeStream(Source &source, Sink &sink, AudioFormat streamFor
 auto StreamFactory::makeInputTranscodingStream(Source &source,
                                                Sink &sink,
                                                AudioFormat streamFormat,
-                                               std::shared_ptr<Transform>(transform))
+                                               std::shared_ptr<Transform> transform)
     -> std::unique_ptr<InputTranscodeProxy>
 {
     auto sourceTraits = source.getTraits();

@@ 26,7 26,7 @@ namespace audio
         auto makeInputTranscodingStream(Source &source,
                                         Sink &sink,
                                         AudioFormat streamFormat,
-                                        std::shared_ptr<transcode::Transform>(transform))
+                                        std::shared_ptr<transcode::Transform> transform)
             -> std::unique_ptr<transcode::InputTranscodeProxy>;
 
       private:

@@ 347,9 347,11 @@ TEST(Transform, BasicInterpolator)
 
     std::uint16_t inputBuffer[8]          = {1, 2, 3, 4, 0, 0, 0, 0};
     static const uint16_t expectBuffer[8] = {1, 2, 1, 2, 3, 4, 3, 4};
-    auto inputSpan  = ::audio::AbstractStream::Span{.data     = reinterpret_cast<uint8_t *>(inputBuffer),
+    auto inputSpan      = ::audio::AbstractStream::Span{.data     = reinterpret_cast<uint8_t *>(inputBuffer),
                                                    .dataSize = 4 * sizeof(std::uint16_t)};
-    auto outputSpan = interp2.transform(inputSpan, inputSpan);
+    auto transformSpace = ::audio::AbstractStream::Span{.data     = reinterpret_cast<uint8_t *>(inputBuffer),
+                                                        .dataSize = 8 * sizeof(std::uint16_t)};
+    auto outputSpan     = interp2.transform(inputSpan, transformSpace);
 
     EXPECT_EQ(outputSpan.dataSize, sizeof(uint16_t) * 8);
     EXPECT_EQ(memcmp(outputSpan.data, expectBuffer, outputSpan.dataSize), 0);

@@ 9,6 9,7 @@
 
 #include <type_traits>
 
+#include <cassert>
 #include <cstdint>
 
 namespace audio::transcode


@@ 33,8 34,9 @@ namespace audio::transcode
         /**
          * @brief Integer type to be used to read and write data from/to a buffer.
          */
-        using IntegerType = typename decltype(
-            utils::integer::getIntegerType<sizeof(SampleType) * utils::integer::BitsInByte * Channels>())::type;
+        using IntegerType =
+            typename decltype(utils::integer::getIntegerType<sizeof(SampleType) * utils::integer::BitsInByte *
+                                                             Channels>())::type;
 
       public:
         auto transformBlockSize(std::size_t blockSize) const noexcept -> std::size_t override


@@ 64,6 66,8 @@ namespace audio::transcode
             IntegerType *input  = reinterpret_cast<IntegerType *>(inputSpan.data);
             IntegerType *output = reinterpret_cast<IntegerType *>(outputSpan.data);
 
+            assert(outputSpan.dataSize <= transformSpace.dataSize);
+
             for (unsigned i = inputSpan.dataSize / sizeof(IntegerType); i > 0; i--) {
                 for (unsigned j = 1; j <= Ratio; j++) {
                     output[i * Ratio - j] = input[i - 1];

@@ 20,7 20,16 @@ InputTranscodeProxy::InputTranscodeProxy(std::shared_ptr<AbstractStream> wrapped
 
 bool InputTranscodeProxy::push(const Span &span)
 {
-    return getWrappedStream().push(transform->transform(span, transcodingSpaceSpan));
+    Span outputSpan;
+
+    if (!getWrappedStream().reserve(outputSpan)) {
+        return false;
+    }
+
+    transform->transform(span, outputSpan);
+    getWrappedStream().commit();
+
+    return true;
 }
 
 bool InputTranscodeProxy::push(void *data, std::size_t dataSize)


@@ 38,13 47,16 @@ void InputTranscodeProxy::commit()
     }
 }
 
-bool InputTranscodeProxy::reserve(Span &span)
+bool InputTranscodeProxy::reserve(Span &inputSpan)
 {
+    Span span;
     auto result = getWrappedStream().reserve(span);
 
-    reservedSpan = span;
-    span         = transcodingSpaceSpan;
-    isReserved   = true;
+    if (result) {
+        reservedSpan = span;
+        inputSpan    = transcodingSpaceSpan;
+        isReserved   = true;
+    }
 
     return result;
 }

@@ 266,7 266,7 @@ auto A2DPAudioDevice::getTraits() const -> ::audio::Endpoint::Traits
 
 auto CVSDAudioDevice::getTraits() const -> ::audio::Endpoint::Traits
 {
-    return Traits{.usesDMA = false, .blockSizeConstraint = 32U, .timeConstraint = 16ms};
+    return Traits{.usesDMA = false, .blockSizeConstraint = 128U, .timeConstraint = 16ms};
 }
 
 auto A2DPAudioDevice::getSourceFormat() -> ::audio::AudioFormat