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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include <arm_neon.h>

#include <algorithm>

#include "build/build_config.h"
#include "third_party/blink/renderer/platform/audio/delay.h"

namespace blink {

#if defined(CPU_ARM_NEON)
ALWAYS_INLINE static int32x4_t WrapIndexVector(int32x4_t v_write_index,
                                               int32x4_t v_buffer_length) {
  // Wrap the write_index if any index is past the end of the buffer.
  // This implements
  //
  //   if (write_index >= buffer_length)
  //     write_index -= buffer_length

  // If write_index >= buffer_length, cmp = 0xffffffff.  Otherwise 0.
  int32x4_t cmp =
      reinterpret_cast<int32x4_t>(vcgeq_s32(v_write_index, v_buffer_length));

  // Bitwise-and cmp with buffer length to get buffer length or 0 depending on
  // whether write_index >= buffer_length or not.  Subtract this from the index
  // to wrap the index appropriately.
  return vsubq_s32(v_write_index, vandq_s32(cmp, v_buffer_length));
}

ALWAYS_INLINE static float32x4_t WrapPositionVector(
    float32x4_t v_position,
    float32x4_t v_buffer_length) {
  // Wrap the read position if it exceed the buffer length.
  // This implements
  //
  //   if (position >= buffer_length)
  //     read_position -= buffer_length

  // If position >= buffer length, set cmp = 0xffffffff.  Otherwise 0.
  uint32x4_t cmp = vcgeq_f32(v_position, v_buffer_length);

  // Bitwise-and buffer_length with cmp to get buffer_length or 0 depending on
  // whether read_position >= buffer length or not.  Then subtract from the
  // position to wrap it around if needed.
  return vsubq_f32(v_position,
                   reinterpret_cast<float32x4_t>(vandq_u32(
                       reinterpret_cast<uint32x4_t>(v_buffer_length), cmp)));
}

std::tuple<unsigned, int> Delay::ProcessARateVector(
    float* destination,
    uint32_t frames_to_process) const {
  const int buffer_length = buffer_.size();
  const float* buffer = buffer_.Data();

  const float sample_rate = sample_rate_;
  const float* delay_times = delay_times_.Data();

  int w_index = write_index_;

  const float32x4_t v_sample_rate = vdupq_n_f32(sample_rate);
  const float32x4_t v_all_zeros = vdupq_n_f32(0);

  // The buffer length as a float and as an int so we don't need to constant
  // convert from one to the other.
  const float32x4_t v_buffer_length_float = vdupq_n_f32(buffer_length);
  const int32x4_t v_buffer_length_int = vdupq_n_s32(buffer_length);

  // How much to increment the write index each time through the loop.
  const int32x4_t v_incr = vdupq_n_s32(4);

  // Temp arrays for storing the samples needed for interpolation
  float sample1[4] __attribute((aligned(16)));
  float sample2[4] __attribute((aligned(16)));

  // Temp array for holding the indices so we can access them
  // individually.
  int read_index1[4] __attribute((aligned(16)));
  int read_index2[4] __attribute((aligned(16)));

  // Initialize the write index vector, and  wrap the values if needed.
  int32x4_t v_write_index = {w_index + 0, w_index + 1, w_index + 2,
                             w_index + 3};
  v_write_index = WrapIndexVector(v_write_index, v_buffer_length_int);

  int number_of_loops = frames_to_process / 4;
  int k = 0;

  for (int n = 0; n < number_of_loops; ++n, k += 4) {
    const float32x4_t v_delay_time = vmaxq_f32(vld1q_f32(delay_times + k),
                                               v_all_zeros);
    const float32x4_t v_desired_delay_frames =
        vmulq_f32(v_delay_time, v_sample_rate);

    // read_position = write_index + buffer_length - desired_delay_frames.  Wrap
    // the position if needed.
    float32x4_t v_read_position =
        vaddq_f32(vcvtq_f32_s32(v_write_index),
                  vsubq_f32(v_buffer_length_float, v_desired_delay_frames));
    v_read_position =
        WrapPositionVector(v_read_position, v_buffer_length_float);

    // Get indices into the buffer for the samples we need for interpolation.
    const int32x4_t v_read_index1 = WrapIndexVector(
        vcvtq_s32_f32(v_read_position), v_buffer_length_int);
    const int32x4_t v_read_index2 = WrapIndexVector(
        vaddq_s32(v_read_index1, vdupq_n_s32(1)), v_buffer_length_int);

    const float32x4_t interpolation_factor =
        vsubq_f32(v_read_position, vcvtq_f32_s32(v_read_index1));

    // Save indices so we can access the components individually for
    // getting the aamples from the buffer.
    vst1q_s32(read_index1, v_read_index1);
    vst1q_s32(read_index2, v_read_index2);

    for (int m = 0; m < 4; ++m) {
      sample1[m] = buffer[read_index1[m]];
      sample2[m] = buffer[read_index2[m]];
    }

    const float32x4_t v_sample1 = vld1q_f32(sample1);
    const float32x4_t v_sample2 = vld1q_f32(sample2);

    v_write_index = vaddq_s32(v_write_index, v_incr);
    v_write_index = WrapIndexVector(v_write_index, v_buffer_length_int);

    // Linear interpolation between samples.
    const float32x4_t sample = vaddq_f32(
        v_sample1,
        vmulq_f32(interpolation_factor, vsubq_f32(v_sample2, v_sample1)));
    vst1q_f32(destination + k, sample);
  }

  // Update |w_index| based on how many frames we processed here, wrapping
  // around if needed.
  w_index = write_index_ + k;
  if (w_index >= buffer_length) {
    w_index -= buffer_length;
  }

  return std::make_tuple(k, w_index);
}

void Delay::HandleNaN(float* delay_times,
                      uint32_t frames_to_process,
                      float max_time) {
  unsigned k = 0;
  int number_of_loops = frames_to_process / 4;

  float32x4_t v_max_time = vdupq_n_f32(max_time);

  // This is approximately 4 times faster than the scalar version.
  for (int loop = 0; loop < number_of_loops; ++loop, k += 4) {
    float32x4_t x = vld1q_f32(delay_times + k);
    // x == x only fails when x is NaN.  Then cmp is set to 0. Otherwise
    // 0xffffffff
    uint32x4_t cmp = vceqq_f32(x, x);

    // Use cmp as a mask to set a component of x to 0 if x is NaN.
    // Otherwise, preserve x.  We pun the types here so we can apply
    // the  mask to the floating point numbers.  A integer value of
    // 0 corresponds to a floating-point +0.0, which is what we want.
    uint32x4_t xint = vandq_u32(cmp, reinterpret_cast<uint32x4_t>(x));

    // Invert the mask.
    cmp = vmvnq_u32(cmp);

    // More punning of the types so we can apply the complement mask
    // to set cmp to either max_time (if NaN) or 0 (otherwise)
    cmp = vandq_u32(cmp, reinterpret_cast<uint32x4_t>(v_max_time));

    // Merge i (bitwise or) x and cmp.  This makes x = max_time if x was NaN and
    // preserves x if not.  More type punning to do bitwise or the results
    // together.
    xint = vorrq_u32(xint, cmp);

    // Finally, save the float result.
    vst1q_f32(delay_times + k, reinterpret_cast<float32x4_t>(xint));
  }

  // Handle any frames not done in the loop above.
  for (; k < frames_to_process; ++k) {
    if (std::isnan(delay_times[k])) {
      delay_times[k] = max_time;
    }
  }
}
#endif

}  // namespace blink