dom/media/AudioConverter.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #if !defined(AudioConverter_h)
   8 #  define AudioConverter_h
   9
  10 #  include "MediaInfo.h"
  11
  12 // Forward declaration
  13 typedef struct SpeexResamplerState_ SpeexResamplerState;
  14
  15 namespace mozilla {
  16
  17 template <AudioConfig::SampleFormat T>
  18 struct AudioDataBufferTypeChooser;
  19 template <>
  20 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_U8> {
  21   typedef uint8_t Type;
  22 };
  23 template <>
  24 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S16> {
  25   typedef int16_t Type;
  26 };
  27 template <>
  28 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S24LSB> {
  29   typedef int32_t Type;
  30 };
  31 template <>
  32 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S24> {
  33   typedef int32_t Type;
  34 };
  35 template <>
  36 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S32> {
  37   typedef int32_t Type;
  38 };
  39 template <>
  40 struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_FLT> {
  41   typedef float Type;
  42 };
  43
  44 // 'Value' is the type used externally to deal with stored value.
  45 // AudioDataBuffer can perform conversion between different SampleFormat
  46 // content.
  47 template <AudioConfig::SampleFormat Format,
  48           typename Value = typename AudioDataBufferTypeChooser<Format>::Type>
  49 class AudioDataBuffer {
  50  public:
  51   AudioDataBuffer() = default;
  52   AudioDataBuffer(Value* aBuffer, size_t aLength) : mBuffer(aBuffer, aLength) {}
  53   explicit AudioDataBuffer(const AudioDataBuffer& aOther)
  54       : mBuffer(aOther.mBuffer) {}
  55   AudioDataBuffer(AudioDataBuffer&& aOther)
  56       : mBuffer(std::move(aOther.mBuffer)) {}
  57   template <AudioConfig::SampleFormat OtherFormat, typename OtherValue>
  58   explicit AudioDataBuffer(
  59       const AudioDataBuffer<OtherFormat, OtherValue>& other) {
  60     // TODO: Convert from different type, may use asm routines.
  61     MOZ_CRASH("Conversion not implemented yet");
  62   }
  63
  64   // A u8, s16 and float aligned buffer can only be treated as
  65   // FORMAT_U8, FORMAT_S16 and FORMAT_FLT respectively.
  66   // So allow them as copy and move constructors.
  67   explicit AudioDataBuffer(const AlignedByteBuffer& aBuffer)
  68       : mBuffer(aBuffer) {
  69     static_assert(Format == AudioConfig::FORMAT_U8,
  70                   "Conversion not implemented yet");
  71   }
  72   explicit AudioDataBuffer(const AlignedShortBuffer& aBuffer)
  73       : mBuffer(aBuffer) {
  74     static_assert(Format == AudioConfig::FORMAT_S16,
  75                   "Conversion not implemented yet");
  76   }
  77   explicit AudioDataBuffer(const AlignedFloatBuffer& aBuffer)
  78       : mBuffer(aBuffer) {
  79     static_assert(Format == AudioConfig::FORMAT_FLT,
  80                   "Conversion not implemented yet");
  81   }
  82   explicit AudioDataBuffer(AlignedByteBuffer&& aBuffer)
  83       : mBuffer(std::move(aBuffer)) {
  84     static_assert(Format == AudioConfig::FORMAT_U8,
  85                   "Conversion not implemented yet");
  86   }
  87   explicit AudioDataBuffer(AlignedShortBuffer&& aBuffer)
  88       : mBuffer(std::move(aBuffer)) {
  89     static_assert(Format == AudioConfig::FORMAT_S16,
  90                   "Conversion not implemented yet");
  91   }
  92   explicit AudioDataBuffer(AlignedFloatBuffer&& aBuffer)
  93       : mBuffer(std::move(aBuffer)) {
  94     static_assert(Format == AudioConfig::FORMAT_FLT,
  95                   "Conversion not implemented yet");
  96   }
  97   AudioDataBuffer& operator=(AudioDataBuffer&& aOther) {
  98     mBuffer = std::move(aOther.mBuffer);
  99     return *this;
 100   }
 101   AudioDataBuffer& operator=(const AudioDataBuffer& aOther) {
 102     mBuffer = aOther.mBuffer;
 103     return *this;
 104   }
 105
 106   Value* Data() const { return mBuffer.Data(); }
 107   size_t Length() const { return mBuffer.Length(); }
 108   size_t Size() const { return mBuffer.Size(); }
 109   AlignedBuffer<Value> Forget() {
 110     // Correct type -> Just give values as-is.
 111     return std::move(mBuffer);
 112   }
 113
 114  private:
 115   AlignedBuffer<Value> mBuffer;
 116 };
 117
 118 typedef AudioDataBuffer<AudioConfig::FORMAT_DEFAULT> AudioSampleBuffer;
 119
 120 class AudioConverter {
 121  public:
 122   AudioConverter(const AudioConfig& aIn, const AudioConfig& aOut);
 123   ~AudioConverter();
 124
 125   // Convert the AudioDataBuffer.
 126   // Conversion will be done in place if possible. Otherwise a new buffer will
 127   // be returned.
 128   // Providing an empty buffer and resampling is expected, the resampler
 129   // will be drained.
 130   template <AudioConfig::SampleFormat Format, typename Value>
 131   AudioDataBuffer<Format, Value> Process(
 132       AudioDataBuffer<Format, Value>&& aBuffer) {
 133     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() &&
 134                           mIn.Format() == Format);
 135     AudioDataBuffer<Format, Value> buffer = std::move(aBuffer);
 136     if (CanWorkInPlace()) {
 137       AlignedBuffer<Value> temp = buffer.Forget();
 138       Process(temp, temp.Data(), SamplesInToFrames(temp.Length()));
 139       return AudioDataBuffer<Format, Value>(std::move(temp));
 140       ;
 141     }
 142     return Process(buffer);
 143   }
 144
 145   template <AudioConfig::SampleFormat Format, typename Value>
 146   AudioDataBuffer<Format, Value> Process(
 147       const AudioDataBuffer<Format, Value>& aBuffer) {
 148     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() &&
 149                           mIn.Format() == Format);
 150     // Perform the downmixing / reordering in temporary buffer.
 151     size_t frames = SamplesInToFrames(aBuffer.Length());
 152     AlignedBuffer<Value> temp1;
 153     if (!temp1.SetLength(FramesOutToSamples(frames))) {
 154       return AudioDataBuffer<Format, Value>(std::move(temp1));
 155     }
 156     frames = ProcessInternal(temp1.Data(), aBuffer.Data(), frames);
 157     if (mIn.Rate() == mOut.Rate()) {
 158       MOZ_ALWAYS_TRUE(temp1.SetLength(FramesOutToSamples(frames)));
 159       return AudioDataBuffer<Format, Value>(std::move(temp1));
 160     }
 161
 162     // At this point, temp1 contains the buffer reordered and downmixed.
 163     // If we are downsampling we can re-use it.
 164     AlignedBuffer<Value>* outputBuffer = &temp1;
 165     AlignedBuffer<Value> temp2;
 166     if (!frames || mOut.Rate() > mIn.Rate()) {
 167       // We are upsampling or about to drain, we can't work in place.
 168       // Allocate another temporary buffer where the upsampling will occur.
 169       if (!temp2.SetLength(
 170               FramesOutToSamples(ResampleRecipientFrames(frames)))) {
 171         return AudioDataBuffer<Format, Value>(std::move(temp2));
 172       }
 173       outputBuffer = &temp2;
 174     }
 175     if (!frames) {
 176       frames = DrainResampler(outputBuffer->Data());
 177     } else {
 178       frames = ResampleAudio(outputBuffer->Data(), temp1.Data(), frames);
 179     }
 180     MOZ_ALWAYS_TRUE(outputBuffer->SetLength(FramesOutToSamples(frames)));
 181     return AudioDataBuffer<Format, Value>(std::move(*outputBuffer));
 182   }
 183
 184   // Attempt to convert the AudioDataBuffer in place.
 185   // Will return 0 if the conversion wasn't possible.
 186   template <typename Value>
 187   size_t Process(Value* aBuffer, size_t aFrames) {
 188     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format());
 189     if (!CanWorkInPlace()) {
 190       return 0;
 191     }
 192     size_t frames = ProcessInternal(aBuffer, aBuffer, aFrames);
 193     if (frames && mIn.Rate() != mOut.Rate()) {
 194       frames = ResampleAudio(aBuffer, aBuffer, aFrames);
 195     }
 196     return frames;
 197   }
 198
 199   template <typename Value>
 200   size_t Process(AlignedBuffer<Value>& aOutBuffer, const Value* aInBuffer,
 201                  size_t aFrames) {
 202     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format());
 203     MOZ_ASSERT((aFrames && aInBuffer) || !aFrames);
 204     // Up/down mixing first
 205     if (!aOutBuffer.SetLength(FramesOutToSamples(aFrames))) {
 206       MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(0));
 207       return 0;
 208     }
 209     size_t frames = ProcessInternal(aOutBuffer.Data(), aInBuffer, aFrames);
 210     MOZ_ASSERT(frames == aFrames);
 211     // Check if resampling is needed
 212     if (mIn.Rate() == mOut.Rate()) {
 213       return frames;
 214     }
 215     // Prepare output in cases of drain or up-sampling
 216     if ((!frames || mOut.Rate() > mIn.Rate()) &&
 217         !aOutBuffer.SetLength(
 218             FramesOutToSamples(ResampleRecipientFrames(frames)))) {
 219       MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(0));
 220       return 0;
 221     }
 222     if (!frames) {
 223       frames = DrainResampler(aOutBuffer.Data());
 224     } else {
 225       frames = ResampleAudio(aOutBuffer.Data(), aInBuffer, frames);
 226     }
 227     // Update with the actual buffer length
 228     MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(FramesOutToSamples(frames)));
 229     return frames;
 230   }
 231
 232   bool CanWorkInPlace() const;
 233   bool CanReorderAudio() const {
 234     return mIn.Layout().MappingTable(mOut.Layout());
 235   }
 236   static bool CanConvert(const AudioConfig& aIn, const AudioConfig& aOut);
 237
 238   const AudioConfig& InputConfig() const { return mIn; }
 239   const AudioConfig& OutputConfig() const { return mOut; }
 240
 241  private:
 242   const AudioConfig mIn;
 243   const AudioConfig mOut;
 244   // mChannelOrderMap will be empty if we do not know how to proceed with this
 245   // channel layout.
 246   AutoTArray<uint8_t, AudioConfig::ChannelLayout::MAX_CHANNELS>
 247       mChannelOrderMap;
 248   /**
 249    * ProcessInternal
 250    * Parameters:
 251    * aOut  : destination buffer where converted samples will be copied
 252    * aIn   : source buffer
 253    * aSamples: number of frames in source buffer
 254    *
 255    * Return Value: number of frames converted or 0 if error
 256    */
 257   size_t ProcessInternal(void* aOut, const void* aIn, size_t aFrames);
 258   void ReOrderInterleavedChannels(void* aOut, const void* aIn,
 259                                   size_t aFrames) const;
 260   size_t DownmixAudio(void* aOut, const void* aIn, size_t aFrames) const;
 261   size_t UpmixAudio(void* aOut, const void* aIn, size_t aFrames) const;
 262
 263   size_t FramesOutToSamples(size_t aFrames) const;
 264   size_t SamplesInToFrames(size_t aSamples) const;
 265   size_t FramesOutToBytes(size_t aFrames) const;
 266
 267   // Resampler context.
 268   SpeexResamplerState* mResampler;
 269   size_t ResampleAudio(void* aOut, const void* aIn, size_t aFrames);
 270   size_t ResampleRecipientFrames(size_t aFrames) const;
 271   void RecreateResampler();
 272   size_t DrainResampler(void* aOut);
 273 };
 274
 275 }  // namespace mozilla
 276
 277 #endif /* AudioConverter_h */