/*

 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>

 * Copyright (c) 2021, kleines Filmröllchen <filmroellchen@serenityos.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#pragma once

#include <AK/Format.h>

#include <AK/Math/Constants.h>

#include <AK/Math/Exponentials.h>

#include <AK/Math/Sqrt.h>

#include <AK/Math/Trigonometry.h>

namespace Audio {

using AK::Exponentials::exp;

using AK::Exponentials::log;

// Constants for logarithmic volume. See Sample::linear_to_log

// Corresponds to 60dB

constexpr float DYNAMIC_RANGE = 1000;

constexpr float VOLUME_A = 1 / DYNAMIC_RANGE;

float const VOLUME_B = log(DYNAMIC_RANGE);

// A single sample in an audio buffer.

// Values are floating point, and should range from -1.0 to +1.0

struct Sample {

    constexpr Sample() = default;

    // For mono

    constexpr explicit Sample(float left)

        : left(left)

        , right(left)

    {

    }

    // For stereo

    constexpr Sample(float left, float right)

        : left(left)

        , right(right)

    {

    }

    // Returns the absolute maximum range (separate per channel) of the given sample buffer.

    // For example { 0.8, 0 } means that samples on the left channel occupy the range { -0.8, 0.8 },

    // while all samples on the right channel are 0.

    static Sample max_range(ReadonlySpan<Sample> span)

    {

        Sample result { NumericLimits<float>::min_normal(), NumericLimits<float>::min_normal() };

        for (Sample sample : span) {

            result.left = max(result.left, AK::fabs(sample.left));

            result.right = max(result.right, AK::fabs(sample.right));

        }

        return result;

    }

    void clip()

    {

        left = clamp(left, -1, 1);

        right = clamp(right, -1, 1);

    }

    // Logarithmic scaling, as audio should ALWAYS do.

    // Reference: https://www.dr-lex.be/info-stuff/volumecontrols.html

    // We use the curve `factor = a * exp(b * change)`,

    // where change is the input fraction we want to change by,

    // a = 1/1000, b = ln(1000) = 6.908 and factor is the multiplier used.

    // The value 1000 represents the dynamic range in sound pressure, which corresponds to 60 dB(A).

    // This is a good dynamic range because it can represent all loudness values from

    // 30 dB(A) (barely hearable with background noise)

    // to 90 dB(A) (almost too loud to hear and about the reasonable limit of actual sound equipment).

    //

    // Format ranges:

    // - Linear:        0.0 to 1.0

    // - Logarithmic:   0.0 to 1.0

    ALWAYS_INLINE float linear_to_log(float const change) const

    {

        // TODO: Add linear slope around 0

        return VOLUME_A * exp(VOLUME_B * change);

    }

    ALWAYS_INLINE float log_to_linear(float const val) const

    {

        // TODO: Add linear slope around 0

        return log(val / VOLUME_A) / VOLUME_B;

    }

    ALWAYS_INLINE Sample& log_multiply(float const change)

    {

        float factor = linear_to_log(change);

        left *= factor;

        right *= factor;

        return *this;

    }

    ALWAYS_INLINE Sample log_multiplied(float const volume_change) const

    {

        Sample new_frame { left, right };

        new_frame.log_multiply(volume_change);

        return new_frame;

    }

    // Constant power panning

    ALWAYS_INLINE Sample& pan(float const position)

    {

        float const pi_over_2 = AK::Pi<float> * 0.5f;

        float const root_over_2 = AK::sqrt<float>(2.0) * 0.5f;

        float const angle = position * pi_over_2 * 0.5f;

        float s, c;

        AK::sincos<float>(angle, s, c);

        left *= root_over_2 * (c - s);

        right *= root_over_2 * (c + s);

        return *this;

    }

    ALWAYS_INLINE Sample panned(float const position) const

    {

        Sample new_sample { left, right };

        new_sample.pan(position);

        return new_sample;

    }

    constexpr Sample& operator*=(float const mult)

    {

        left *= mult;

        right *= mult;

        return *this;

    }

    constexpr Sample operator*(float const mult) const

    {

        return { left * mult, right * mult };

    }

    constexpr Sample& operator+=(Sample const& other)

    {

        left += other.left;

        right += other.right;

        return *this;

    }

    constexpr Sample& operator+=(float other)

    {

        left += other;

        right += other;

        return *this;

    }

    constexpr Sample operator+(Sample const& other) const

    {

        return { left + other.left, right + other.right };

    }

    float left { 0 };

    float right { 0 };

};

}

namespace AK {

template<>

struct Formatter<Audio::Sample> : Formatter<FormatString> {

    ErrorOr<void> format(FormatBuilder& builder, Audio::Sample const& value)

    {

        return Formatter<FormatString>::format(builder, "[{}, {}]"sv, value.left, value.right);

    }

};

}