third_party/WebKit/Source/platform/audio/StereoPanner.cpp

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "platform/audio/StereoPanner.h"
#include "platform/audio/AudioBus.h"
#include "platform/audio/AudioUtilities.h"
#include "wtf/MathExtras.h"
#include <algorithm>

// Use a 50ms smoothing / de-zippering time-constant.
const float SmoothingTimeConstant = 0.050f;

namespace blink {

// Implement equal-power panning algorithm for mono or stereo input.
// See: http://webaudio.github.io/web-audio-api/#panning-algorithm

std::unique_ptr<StereoPanner> StereoPanner::create(float sampleRate) {
  return WTF::wrapUnique(new StereoPanner(sampleRate));
}

StereoPanner::StereoPanner(float sampleRate)
    : m_isFirstRender(true), m_pan(0.0) {
  // Convert smoothing time (50ms) to a per-sample time value.
  m_smoothingConstant = AudioUtilities::discreteTimeConstantForSampleRate(
      SmoothingTimeConstant, sampleRate);
}

void StereoPanner::panWithSampleAccurateValues(const AudioBus* inputBus,
                                               AudioBus* outputBus,
                                               const float* panValues,
                                               size_t framesToProcess) {
  bool isInputSafe = inputBus && (inputBus->numberOfChannels() == 1 ||
                                  inputBus->numberOfChannels() == 2) &&
                     framesToProcess <= inputBus->length();
  ASSERT(isInputSafe);
  if (!isInputSafe)
    return;

  unsigned numberOfInputChannels = inputBus->numberOfChannels();

  bool isOutputSafe = outputBus && outputBus->numberOfChannels() == 2 &&
                      framesToProcess <= outputBus->length();
  ASSERT(isOutputSafe);
  if (!isOutputSafe)
    return;

  const float* sourceL = inputBus->channel(0)->data();
  const float* sourceR =
      numberOfInputChannels > 1 ? inputBus->channel(1)->data() : sourceL;
  float* destinationL =
      outputBus->channelByType(AudioBus::ChannelLeft)->mutableData();
  float* destinationR =
      outputBus->channelByType(AudioBus::ChannelRight)->mutableData();

  if (!sourceL || !sourceR || !destinationL || !destinationR)
    return;

  double gainL, gainR, panRadian;

  int n = framesToProcess;

  if (numberOfInputChannels == 1) {  // For mono source case.
    while (n--) {
      float inputL = *sourceL++;
      m_pan = clampTo(*panValues++, -1.0, 1.0);
      // Pan from left to right [-1; 1] will be normalized as [0; 1].
      panRadian = (m_pan * 0.5 + 0.5) * piOverTwoDouble;
      gainL = std::cos(panRadian);
      gainR = std::sin(panRadian);
      *destinationL++ = static_cast<float>(inputL * gainL);
      *destinationR++ = static_cast<float>(inputL * gainR);
    }
  } else {  // For stereo source case.
    while (n--) {
      float inputL = *sourceL++;
      float inputR = *sourceR++;
      m_pan = clampTo(*panValues++, -1.0, 1.0);
      // Normalize [-1; 0] to [0; 1]. Do nothing when [0; 1].
      panRadian = (m_pan <= 0 ? m_pan + 1 : m_pan) * piOverTwoDouble;
      gainL = std::cos(panRadian);
      gainR = std::sin(panRadian);
      if (m_pan <= 0) {
        *destinationL++ = static_cast<float>(inputL + inputR * gainL);
        *destinationR++ = static_cast<float>(inputR * gainR);
      } else {
        *destinationL++ = static_cast<float>(inputL * gainL);
        *destinationR++ = static_cast<float>(inputR + inputL * gainR);
      }
    }
  }
}

void StereoPanner::panToTargetValue(const AudioBus* inputBus,
                                    AudioBus* outputBus,
                                    float panValue,
                                    size_t framesToProcess) {
  bool isInputSafe = inputBus && (inputBus->numberOfChannels() == 1 ||
                                  inputBus->numberOfChannels() == 2) &&
                     framesToProcess <= inputBus->length();
  ASSERT(isInputSafe);
  if (!isInputSafe)
    return;

  unsigned numberOfInputChannels = inputBus->numberOfChannels();

  bool isOutputSafe = outputBus && outputBus->numberOfChannels() == 2 &&
                      framesToProcess <= outputBus->length();
  ASSERT(isOutputSafe);
  if (!isOutputSafe)
    return;

  const float* sourceL = inputBus->channel(0)->data();
  const float* sourceR =
      numberOfInputChannels > 1 ? inputBus->channel(1)->data() : sourceL;
  float* destinationL =
      outputBus->channelByType(AudioBus::ChannelLeft)->mutableData();
  float* destinationR =
      outputBus->channelByType(AudioBus::ChannelRight)->mutableData();

  if (!sourceL || !sourceR || !destinationL || !destinationR)
    return;

  float targetPan = clampTo(panValue, -1.0, 1.0);

  // Don't de-zipper on first render call.
  if (m_isFirstRender) {
    m_isFirstRender = false;
    m_pan = targetPan;
  }

  double gainL, gainR, panRadian;
  const double smoothingConstant = m_smoothingConstant;

  int n = framesToProcess;

  if (numberOfInputChannels == 1) {  // For mono source case.
    while (n--) {
      float inputL = *sourceL++;
      m_pan += (targetPan - m_pan) * smoothingConstant;

      // Pan from left to right [-1; 1] will be normalized as [0; 1].
      panRadian = (m_pan * 0.5 + 0.5) * piOverTwoDouble;

      gainL = std::cos(panRadian);
      gainR = std::sin(panRadian);
      *destinationL++ = static_cast<float>(inputL * gainL);
      *destinationR++ = static_cast<float>(inputL * gainR);
    }
  } else {  // For stereo source case.
    while (n--) {
      float inputL = *sourceL++;
      float inputR = *sourceR++;
      m_pan += (targetPan - m_pan) * smoothingConstant;

      // Normalize [-1; 0] to [0; 1] for the left pan position (<= 0), and
      // do nothing when [0; 1].
      panRadian = (m_pan <= 0 ? m_pan + 1 : m_pan) * piOverTwoDouble;

      gainL = std::cos(panRadian);
      gainR = std::sin(panRadian);

      // The pan value should be checked every sample when de-zippering.
      // See crbug.com/470559.
      if (m_pan <= 0) {
        // When [-1; 0], keep left channel intact and equal-power pan the
        // right channel only.
        *destinationL++ = static_cast<float>(inputL + inputR * gainL);
        *destinationR++ = static_cast<float>(inputR * gainR);
      } else {
        // When [0; 1], keep right channel intact and equal-power pan the
        // left channel only.
        *destinationL++ = static_cast<float>(inputL * gainL);
        *destinationR++ = static_cast<float>(inputR + inputL * gainR);
      }
    }
  }
}

}  // namespace blink