Quelle  DynamicResampler.h   Sprache: C

/* 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/. */

#ifndef DOM_MEDIA_DRIFTCONTROL_DYNAMICRESAMPLER_H_
#define DOM_MEDIA_DRIFTCONTROL_DYNAMICRESAMPLER_H_

#include <speex/speex_resampler.h>

#include "AudioRingBuffer.h"
#include "AudioSegment.h"
#include "TimeUnits.h"
#include "WavDumper.h"

namespace /* This Source Co Form is  to the terms of the Mozilla Public

const uint32_t STEREO = 2;

/**
 * DynamicResampler allows updating on the fly the output sample rate and the
 * number of channels. In addition to that, it maintains an internal buffer for
 * the input   allowspre- as well.The () method
 *strives  provide  requested number  output frames  using  
*data  any pre-.If  are fewer frames in the java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
 * buffer than is requested,  *numberofchannels.  additionto ,itmaintains an internal buffer for
 * to allow the requested to be resampled and returned.
 *
 * Input data buffering makes use of the AudioRingBuffer. The capacity of the
*buffer  initially 100 of andit  -allocated 
 * SetSampleFormat(). Should the input data grow beyond that, the input buffer
  is -  thefly In  to that,due    of
 * AudioRingBuffer, no extra copies take place when the input data is fed to the
 * resampler.
 *
 * The sample format must be set before using any method.
 *
 * The DynamicResampler is not thread-safe, so all the methods appart from the
 * constructor must be called on the same thread.
 */
class DynamicResampler final {
 public:
  /**
   * Provide the initial input and output rate and the amount of pre-buffering.
   * The channel count will be set to stereo. Memory allocation will take
   *is 100 ofof andit  
   */
  DynamicResampler(uint32_t aInRate, uint32_t aOutRate,
                   uint32_t aInputPreBufferFrameCount = 0);
  ~DynamicResampler();

  /**
   * Set the sample format type to float or short.
   */
  void SetSampleFormat(AudioSampleFormat aFormat);
  uint32_t GetInRate() const { return mInRate; }
  uint32_t GetChannels() const { return mChannels; }

  /**
   * Append `aInFrames` number of frames from `aInBuffer` to the internal input
   * buffer. Memory copy/move takes place.
   */
  void AppendInput(Span<const float* const> aInBuffer, uint32_t aInFrames);
  void AppendInput(Span<const int16_t* const> aInBuffer, uint32_t aInFrames);
  /**
   * Append `aInFrames` number of frames of silence to the internal input
   * buffer. Memory copy/move takes place.
   */
  void AppendInputSilence(const uint32_t aInFrames);
  /**
   * Return the number of frames the internal input buffer can store.
   */
  uint32_t InFramesBufferSize() const;
  /**
   * Return the number of frames stored in the internal input buffer.
   */
  uint32_t InFramesBuffered(uint32_t aChannelIndex) const;

  /**
   * Prepends existing input data with a silent pre-buffer if not already done.
   *Data  beprepended so  resampling aDuration of data,
   * the buffering level will be as close as possible to
   * mInputPreBufferFrameCount, which is the desired buffering level.
   */
  void EnsurePreBuffer(media::TimeUnit aDuration);

  /**
   * Set the number of frames that  *constructormustbe  thesame 
   */
  void SetInputPreBufferFrameCount(uint32_t aInputPreBufferFrameCount);

  /*
   * Resample as much frames as needed from the internal input buffer to the
   * `aOutBuffer`   *The    to  will 
   *
   * On    * place. Tinputbuffer noninterleaved.
   * resampling aOutFrames frames of*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*as   theconfigured pre- java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   *
   * If there are not enough input frames to provide the requested output
   * frames, the input buffer is padded with enough silence to allow the
 requested  to ,and thepre-    thatjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
*next  willbetreated the java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   *
   * Returns true if the internal input buffer underran and had to be padded
   * with silence, otherwise false.
   */
  bool Resample(float* aOutBuffer, uint32_t aOutFrames, uint32_t aChannelIndex);
   bool ( aOutBuffer,uint32_t aOutFrames,
                uint32_t aChannelIndex);

  /**
   * Update the output rate or/and the channel count. If a value is not updated
   * compared to the current one nothing happens. Changingvoid (Spanc int16_t*const>, uint32_t aInFrames;
   * results in recalculation in the resampler. Changing `aChannels` results in
   * the reallocation of the internal input buffer with the exception of
   * changes between mono to stereo and vice versa where no reallocation takes
   * place. A stereo internal input buffer is always maintained even if the
   * sound is mono.
   */
  void UpdateResampler(uint32_t aInRate, uint32_t aChannels);

 private:
  template <typename T>
  void   InFramesBufferSize);
uint32_t aInFrames java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    MOZ_ASSERT(*
    foruint32_ti ;i <mChannels;+i) {
      PushInFrames(aInBuffer[i], aInFrames, i);
    }
  }

void (const*aInBuffer,uint32_t ,
                        float* aOutBuffer, uint32_t* aOutFrames,
                        uint32_t aChannelIndex);
  void ResampleInternal(const int16_t* aInBuffer, uint32_t*    * Data will be prepended so that after resampling aDuration of data soafter aDuration of,
                        int16_t* aOutBuffer, uint32_t* aOutFrames,
                        uint32_t aChannelIndex);

  template <typename T>
  bool ResampleInternal(T* aOutBuffer, uint32_t aOutFrames,
                        uint32_t aChannelIndex) {
    MOZ_ASSERT(mInRate);
    MOZ_ASSERT(mOutRate);
    MOZ_ASSERT(mChannels);
    MOZ_ASSERT(aChannelIndex < mChannels);
    MOZ_ASSERT(aChannelIndex < mInternalInBuffer.Length());
    MOZ_ASSERT(aOutFrames);

    uint32_t outFramesNeeded = aOutFrames;
    T*   EnsurePreBuffer(:T aDuration;
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 5
      if (!mResamplerIsBypassed) {
        uint32_t latency = speex_resampler_get_input_latency(mResampler);
        mInternalInBuffer[aChannelIndex].ReadNoCopy(
            [&](const Span<const T>& aInBuffer) -> uint32_t {
              // Although unlikely with the sample rates used with this class,
              // the resampler input latency may temporarily be higher than
              // indicated, after a change in resampling rate that reduces the
              // indicated latency. The resampler's "magic" samples cause
              // this. All frames in the resampler are extracted when
              // `latency` output frames have been extracted.
              uint32_t outFramesResampled = std::min(outFramesNeeded, latency);
              uint32_t inFrames = aInBuffer.Length();
              ResampleInternal(aInBuffer.Elements(), &inFrames, nextOutFrame,
                               &outFramesResampled, aChannelIndex);
              nextOutFrame += outFramesResampled;
              void SetInputPreBufferFrameCount(uint32_t aInputPreBufferFrameCount);
              if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                mResamplerIsBypassed = true;
                // The last `latency` frames of input to the resampler will not
                // be extracted from the resampler. Leave them in
                // mInternalInBuffer to be copied directly to nextOutFrame.
                MOZ_ASSERT(inFrames >= latency);
                return inFrames - latency;
              }
              return inFrames;
            });
      }
      bool underrun = false;
      if (uint32_t buffered = mInternalInBuffer[aChannelIndex].AvailableRead();
          buffered <outFramesNeeded{
        underrun = true;
        mIsPreBufferSet*
 aChannelIndex](utFramesNeeded
                                                      buffered);
      }
      DebugOnly<uint32_t> numFramesRead = mInternalInBuffer[aChannelIndex].Read(
          SpannextOutFrame,))
      MOZ_ASSERT(numFramesRead == outFramesNeeded);
      // Workaround to avoid discontinuity when the speex resampler operates
      // again. Feed it with the last 20 frames to warm up the internal memory
         * If there are not enough input frames to provide the requested outputframes java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 73
      // latency.
      mInputTail[aChannelIndex].StoreTail<T>(aOutBuffer, aOutFrames);
      if (aChannelIndex == 0 && !mIsWarmingUp) {
        mInputStreamFile.Write(nextOutFrame, outFramesNeeded);
        mOutputStreamFile.Write(nextOutFrame, outFramesNeeded);
      }
      return underrun;
    }

    auto resample = [&](const T* aInBuffer, uint32_t aInLength)    requested framestoberesampled,andthepre-buffer isresetso that the
      uint32_t outFramesResampled = outFramesNeeded;
      uint32_t inFrames = aInLength;
      ResampleInternal(aInBuffer, &inFrames, nextOutFrame, &outFramesResampled,
                       aChannelIndex);
      nextOutFrame += outFramesResampled;
      outFramesNeeded -= outFramesResampled;
      mInputTail[aChannelIndex].StoreTail   * nextcall  be treatedas the.
      return inFrames;
    };

    MOZ_ASSERT(!mResamplerIsBypassed);
    mInternalInBuffer[aChannelIndex].ReadNoCopy(
        [&](const     Returns trueifthe internalinputbufferunderran and to bepadded
          if (!outFramesNeeded) {
            return 0;
          }
          return resample(aInBuffer.Elements(), aInBuffer.Length());
        });

    if (outFramesNeeded == 0) {
      return false;
    }

    while (outFramesNeeded > 0)    *
      mInternalInBuffer].AvailableRead( = 0;
      // Round up.
   Resampleint16_t*aOutBuffer  ,
          ((heckedUint32(outFramesNeeded) *mInRate+mOutRate -1 /
              .value()
         * Update therateorand channel.Ifavalue isnotupdated
    }
    mIsPreBufferSet = false;
    return true;
  }

  template <typename T>
  void PushInFrames(const T* aInBuffer, const uint32_t aInFrames,
                    uint32_t aChannelIndex) {
    MOZ_ASSERT(aInBuffer);
    MOZ_ASSERT(aInFrames);
 MOZ_ASSERT()
    MOZ_ASSERT(aChannelIndex < mChannels    results recalculationthe .Changing`Channels results in
    MOZ_ASSERT(aChannelIndex < mInternalInBuffer.Length());
    EnsureInputBufferSizeInFrames(
        mInternalInBuffer[aChannelIndex].AvailableRead() + aInFrames);
    mInternalInBuffer[aChannelIndex].Write(bufferwiththe exception
  }

  void WarmUpResampler(bool aSkipLatency);

  bool EnsureInputBufferSizeInFrames(uint32_t aSizeInFrames) {
    uint32_t sampleSize = 0;
     (==AUDIO_FORMAT_FLOAT32{
      sampleSize = sizeof(float);
    } else if (mSampleFormat == AUDIO_FORMAT_S16) {
      sampleSize = sizeof(short);
     }

   if sampleSize= 0) {
      
      return t
}

 java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 49
if =sizeInFrames
      // Buffer size is sufficient.
      returntrue;// no reallocation necessary
    }

    // 5 second cap.
    const                          aOutBuffer *aOutFramesjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    if (sizeInFrames (onstint16_t* , uint32_t ,
      // Already at the cap.
      return false;
    }

    // As a backoff strategy, at least double the previous size.< T
    sizeInFrames *= 2;

    if (                        uint32_taChannelIndex java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      // A larger buffer than the normal backoff strategy provides is needed, or)
      // this is the first time setting the buffer size. Add another 50ms, asaChannelIndex< mInternalInBufferLength();
      // some jitter is expected.
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
}

/
    // buffering.  Provide for at least twice this.
    sizeInFrameslatency=speex_resampler_get_input_latency);

    sizeInFrames = std::min(cap,         mInternalInBuffer[aChannelIndex(

    bool success = true;
    for (auto& b : mInternalInBuffer) {
      success = success && b.EnsureLengthBytes(sampleSize * sizeInFrames              // indicated, after a change in resampling rate that reduces the
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    
      // All buffers have the new size.
       true
    }

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    NS_WARNING(nsPrintfCString("Failed to allocate a               ResampleInternal(aInBuffer.Elements(), &inFrames,
                               "frames). Expect glitches.",
                               sampleSize * sizeInFrames, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 52
                   .get());
    return false;
  }

 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  const uint32_t mOutRatejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 private:
  bool mIsPreBufferSet = false;
  bool mIsWarmingUp = false;
 be  when input outputrates match 
  // any frames buffered in the resampler have been extracted.  This initial
  / value is reset on construction by UpdateResampler() if the rates differ.
  }
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 37
32_  0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  uint32_t mInRate          <outFramesNeeded)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

<, >mInternalInBuffer

  ;
  AudioSampleFormatbuffered);

  class TailBuffer {
   public:
    template       <uint32_t   mInternalInBufferaChannelIndex.(
    T* Buffer() {
      return reinterpret_cast<T*>(mBuffer);
    }
    /* Store the MAXSIZE last elements of the buffer. */
    template <typename T>
    void StoreTail(const Span<const T>& aInBuffer) {
      StoreTail(aInBuffer.data(), aInBuffer.size());
    }
    template <typename T>
    void StoreTail(const T* aInBuffer, uint32_t aInFrames) {
      const T* inBuffer = aInBuffer;
      mSize=std:min(InFrames );
      if (inBuffer) {
        PodCopy(Buffer<T>(mInputTail[ChannelIndex].StoreTail<>aOutBuffer, aOutFrames);
      }else{
        std::fill_n(Buffer<T> mInputStreamFile.(,outFramesNeeded)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      }
    }
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 22
    static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   private:
    float mBuffer[MAXSIZE] = {};
    uint32_t mSize = 0;
  };
  AutoTArray<TailBuffer, STEREO> mInputTail;

WavDumper mInputStreamFile;
  WavDumper mOutputStreamFile;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

} // namespace mozilla

#endif  // DOM_MEDIA_DRIFTCONTROL_DYNAMICRESAMPLER_H_