/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#if !defined(AudioConverter_h)

#define AudioConverter_h

#include "MediaInfo.h"

// Forward declaration

typedef struct SpeexResamplerState_ SpeexResamplerState;

namespace mozilla {

template <AudioConfig::SampleFormat T> struct AudioDataBufferTypeChooser;

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_U8>

{ typedef uint8_t Type; };

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S16>

{ typedef int16_t Type; };

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S24LSB>

{ typedef int32_t Type; };

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S24>

{ typedef int32_t Type; };

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_S32>

{ typedef int32_t Type; };

template <> struct AudioDataBufferTypeChooser<AudioConfig::FORMAT_FLT>

{ typedef float Type; };

// 'Value' is the type used externally to deal with stored value.

// AudioDataBuffer can perform conversion between different SampleFormat content.

template <AudioConfig::SampleFormat Format, typename Value = typename AudioDataBufferTypeChooser<Format>::Type>

class AudioDataBuffer

{

public:

  AudioDataBuffer() {}

  AudioDataBuffer(Value* aBuffer, size_t aLength)

    : mBuffer(aBuffer, aLength)

  {}

  explicit AudioDataBuffer(const AudioDataBuffer& aOther)

    : mBuffer(aOther.mBuffer)

  {}

  AudioDataBuffer(AudioDataBuffer&& aOther)

    : mBuffer(std::move(aOther.mBuffer))

  {}

  template <AudioConfig::SampleFormat OtherFormat, typename OtherValue>

  explicit AudioDataBuffer(const AudioDataBuffer<OtherFormat, OtherValue>& other)

  {

    // TODO: Convert from different type, may use asm routines.

    MOZ_CRASH("Conversion not implemented yet");

  }

  // A u8, s16 and float aligned buffer can only be treated as

  // FORMAT_U8, FORMAT_S16 and FORMAT_FLT respectively.

  // So allow them as copy and move constructors.

  explicit AudioDataBuffer(const AlignedByteBuffer& aBuffer)

    : mBuffer(aBuffer)

  {

    static_assert(Format == AudioConfig::FORMAT_U8,

                  "Conversion not implemented yet");

  }

  explicit AudioDataBuffer(const AlignedShortBuffer& aBuffer)

    : mBuffer(aBuffer)

  {

    static_assert(Format == AudioConfig::FORMAT_S16,

                  "Conversion not implemented yet");

  }

  explicit AudioDataBuffer(const AlignedFloatBuffer& aBuffer)

    : mBuffer(aBuffer)

  {

    static_assert(Format == AudioConfig::FORMAT_FLT,

                  "Conversion not implemented yet");

  }

  explicit AudioDataBuffer(AlignedByteBuffer&& aBuffer)

    : mBuffer(std::move(aBuffer))

  {

    static_assert(Format == AudioConfig::FORMAT_U8,

                  "Conversion not implemented yet");

  }

  explicit AudioDataBuffer(AlignedShortBuffer&& aBuffer)

    : mBuffer(std::move(aBuffer))

  {

    static_assert(Format == AudioConfig::FORMAT_S16,

                  "Conversion not implemented yet");

  }

  explicit AudioDataBuffer(AlignedFloatBuffer&& aBuffer)

    : mBuffer(std::move(aBuffer))

  {

    static_assert(Format == AudioConfig::FORMAT_FLT,

                  "Conversion not implemented yet");

  }

  AudioDataBuffer& operator=(AudioDataBuffer&& aOther)

  {

    mBuffer = std::move(aOther.mBuffer);

    return *this;

  }

  AudioDataBuffer& operator=(const AudioDataBuffer& aOther)

  {

    mBuffer = aOther.mBuffer;

    return *this;

  }

  Value* Data() const { return mBuffer.Data(); }

  size_t Length() const { return mBuffer.Length(); }

  size_t Size() const { return mBuffer.Size(); }

  AlignedBuffer<Value> Forget()

  {

    // Correct type -> Just give values as-is.

    return std::move(mBuffer);

  }

private:

  AlignedBuffer<Value> mBuffer;

};

typedef AudioDataBuffer<AudioConfig::FORMAT_DEFAULT> AudioSampleBuffer;

class AudioConverter {

public:

  AudioConverter(const AudioConfig& aIn, const AudioConfig& aOut);

  ~AudioConverter();

  // Convert the AudioDataBuffer.

  // Conversion will be done in place if possible. Otherwise a new buffer will

  // be returned.

  // Providing an empty buffer and resampling is expected, the resampler

  // will be drained.

  template <AudioConfig::SampleFormat Format, typename Value>

  AudioDataBuffer<Format, Value> Process(AudioDataBuffer<Format, Value>&& aBuffer)

  {

    MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() && mIn.Format() == Format);

    AudioDataBuffer<Format, Value> buffer = std::move(aBuffer);

    if (CanWorkInPlace()) {

      AlignedBuffer<Value> temp = buffer.Forget();

      Process(temp, temp.Data(), SamplesInToFrames(temp.Length()));

      return AudioDataBuffer<Format, Value>(std::move(temp));;

    }

    return Process(buffer);

  }

  template <AudioConfig::SampleFormat Format, typename Value>

  AudioDataBuffer<Format, Value> Process(const AudioDataBuffer<Format, Value>& aBuffer)

  {

    MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() && mIn.Format() == Format);

    // Perform the downmixing / reordering in temporary buffer.

    size_t frames = SamplesInToFrames(aBuffer.Length());

    AlignedBuffer<Value> temp1;

    if (!temp1.SetLength(FramesOutToSamples(frames))) {

      return AudioDataBuffer<Format, Value>(std::move(temp1));

    }

    frames = ProcessInternal(temp1.Data(), aBuffer.Data(), frames);

    if (mIn.Rate() == mOut.Rate()) {

      MOZ_ALWAYS_TRUE(temp1.SetLength(FramesOutToSamples(frames)));

      return AudioDataBuffer<Format, Value>(std::move(temp1));

    }

    // At this point, temp1 contains the buffer reordered and downmixed.

    // If we are downsampling we can re-use it.

    AlignedBuffer<Value>* outputBuffer = &temp1;

    AlignedBuffer<Value> temp2;

    if (!frames || mOut.Rate() > mIn.Rate()) {

      // We are upsampling or about to drain, we can't work in place.

      // Allocate another temporary buffer where the upsampling will occur.

      if (!temp2.SetLength(FramesOutToSamples(ResampleRecipientFrames(frames)))) {

        return AudioDataBuffer<Format, Value>(std::move(temp2));

      }

      outputBuffer = &temp2;

    }

    if (!frames) {

      frames = DrainResampler(outputBuffer->Data());

    } else {

      frames = ResampleAudio(outputBuffer->Data(), temp1.Data(), frames);

    }

    MOZ_ALWAYS_TRUE(outputBuffer->SetLength(FramesOutToSamples(frames)));

    return AudioDataBuffer<Format, Value>(std::move(*outputBuffer));

  }

  // Attempt to convert the AudioDataBuffer in place.

  // Will return 0 if the conversion wasn't possible.

  template <typename Value>

  size_t Process(Value* aBuffer, size_t aFrames)

  {

    MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format());

    if (!CanWorkInPlace()) {

      return 0;

    }

    size_t frames = ProcessInternal(aBuffer, aBuffer, aFrames);

    if (frames && mIn.Rate() != mOut.Rate()) {

      frames = ResampleAudio(aBuffer, aBuffer, aFrames);

    }

    return frames;

  }

  template <typename Value>

  size_t Process(AlignedBuffer<Value>& aOutBuffer, const Value* aInBuffer, size_t aFrames)

  {

    MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format());

    MOZ_ASSERT((aFrames && aInBuffer) || !aFrames);

    // Up/down mixing first

    if (!aOutBuffer.SetLength(FramesOutToSamples(aFrames))) {

      MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(0));

      return 0;

    }

    size_t frames = ProcessInternal(aOutBuffer.Data(), aInBuffer, aFrames);

    MOZ_ASSERT(frames == aFrames);

    // Check if resampling is needed

    if (mIn.Rate() == mOut.Rate()) {

      return frames;

    }

    // Prepare output in cases of drain or up-sampling

    if ((!frames || mOut.Rate() > mIn.Rate()) &&

        !aOutBuffer.SetLength(FramesOutToSamples(ResampleRecipientFrames(frames)))) {

      MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(0));

      return 0;

    }

    if (!frames) {

      frames = DrainResampler(aOutBuffer.Data());

    } else {

      frames = ResampleAudio(aOutBuffer.Data(), aInBuffer, frames);

    }

    // Update with the actual buffer length

    MOZ_ALWAYS_TRUE(aOutBuffer.SetLength(FramesOutToSamples(frames)));

    return frames;

  }

  bool CanWorkInPlace() const;

  bool CanReorderAudio() const

  {

    return mIn.Layout().MappingTable(mOut.Layout());

  }

  const AudioConfig& InputConfig() const { return mIn; }

  const AudioConfig& OutputConfig() const { return mOut; }

private:

  const AudioConfig mIn;

  const AudioConfig mOut;

  // mChannelOrderMap will be empty if we do not know how to proceed with this

  // channel layout.

  AutoTArray<uint8_t, AudioConfig::ChannelLayout::MAX_CHANNELS> mChannelOrderMap;

  /**

   * ProcessInternal

   * Parameters:

   * aOut  : destination buffer where converted samples will be copied

   * aIn   : source buffer

   * aSamples: number of frames in source buffer

   *

   * Return Value: number of frames converted or 0 if error

   */

  size_t ProcessInternal(void* aOut, const void* aIn, size_t aFrames);

  void ReOrderInterleavedChannels(void* aOut, const void* aIn, size_t aFrames) const;

  size_t DownmixAudio(void* aOut, const void* aIn, size_t aFrames) const;

  size_t UpmixAudio(void* aOut, const void* aIn, size_t aFrames) const;

  size_t FramesOutToSamples(size_t aFrames) const;

  size_t SamplesInToFrames(size_t aSamples) const;

  size_t FramesOutToBytes(size_t aFrames) const;

  // Resampler context.

  SpeexResamplerState* mResampler;

  size_t ResampleAudio(void* aOut, const void* aIn, size_t aFrames);

  size_t ResampleRecipientFrames(size_t aFrames) const;

  void RecreateResampler();

  size_t DrainResampler(void* aOut);

};

} // namespace mozilla

#endif /* AudioConverter_h */