/*
 * Brickworks
 *
 * Copyright (C) 2023, 2024 Orastron Srl unipersonale
 *
 * Brickworks is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3 of the License.
 *
 * Brickworks is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Brickworks.  If not, see <http://www.gnu.org/licenses/>.
 *
 * File author: Stefano D'Angelo
 */

/*!
 *  module_type {{{ utility }}}
 *  version {{{ 1.1.1 }}}
 *  requires {{{ bw_common }}}
 *  description {{{
 *    Common operations on buffers.
 *  }}}
 *  changelog {{{
 *    <ul>
 *      <li>Version <strong>1.1.1</strong>:
 *        <ul>
 *          <li>Added debugging check in
 *              <code>bw_buf_{neg,add,scale,mix,mul}_multi()</code> to ensure
 *              that buffers used for both input and output appear at the same
 *              channel indices.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>1.1.0</strong>:
 *        <ul>
 *          <li>Now using <code>BW_NULL</code> and
 *              <code>BW_CXX_NO_ARRAY</code>.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>1.0.0</strong>:
 *        <ul>
 *          <li>Now using <code>size_t</code> instead of
 *              <code>BW_SIZE_T</code>.</li>
 *          <li>C++ API now uses <code>size_t</code> to count samples.</li>
 *          <li>Changed order of arguments to improve consistency.</li>
 *          <li>Added more <code>const</code> and <code>BW_RESTRICT</code>
 *              specifiers to input arguments.</li>
 *          <li>Moved C++ code to C header.</li>
 *          <li>Added overloaded C++ functions taking C-style arrays as
 *              arguments.</li>
 *          <li>Removed usage of reserved identifiers.</li>
 *          <li>Now checking that buffers are never <code>NULL</code> and that
 *              output buffers are different in debugging code.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>0.6.0</strong>:
 *        <ul>
 *          <li>Added debugging code.</li>
 *          <li>Removed dependency on bw_config.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>0.5.0</strong>:
 *        <ul>
 *          <li>Added <code>bw_buf_*_multi()</code>.</li>
 *          <li>Added <code>bw_buf_neg()</code>.</li>
 *          <li>Added C++ wrapper.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>0.4.0</strong>:
 *        <ul>
 *          <li>Added <code>bw_buf_fill()</code> and
 *              <code>bw_buf_add()</code>.</li>
 *        </ul>
 *      </li>
 *      <li>Version <strong>0.3.0</strong>:
 *        <ul>
 *          <li>First release.</li>
 *        </ul>
 *      </li>
 *    </ul>
 *  }}}
 */

#ifndef BW_BUF_H
#define BW_BUF_H

#include <bw_common.h>

#ifdef __cplusplus
extern "C" {
#endif

/*** Public API ***/

/*! api {{{
 *    #### bw_buf_fill()
 *  ```>>> */
static inline void bw_buf_fill(
	float               k,
	float * BW_RESTRICT dest,
	size_t              n_elems);
/*! <<<```
 *    Sets the first `n_elems` in `dest` to `k`.
 *
 *    #### bw_buf_neg()
 *  ```>>> */
static inline void bw_buf_neg(
	const float * src,
	float *       dest,
	size_t        n_elems);
/*! <<<```
 *    Inverts the sign of the first `n_elems` in `src` and stores the results in
 *    the first `n_elems` of `dest`.
 *
 *    #### bw_buf_add()
 *  ```>>> */
static inline void bw_buf_add(
	const float * src,
	float         k,
	float *       dest,
	size_t        n_elems);
/*! <<<```
 *    Adds `k` to the first `n_elems` in `src` and stores the results in the
 *    first `n_elems` of `dest`.
 *
 *    #### bw_buf_scale()
 *  ```>>> */
static inline void bw_buf_scale(
	const float * src,
	float         k,
	float *       dest,
	size_t        n_elems);
/*! <<<```
 *    Multiplies the first `n_elems` in `src` by `k` and stores the results in
 *    the first `n_elems` of `dest`.
 *
 *    #### bw_buf_mix()
 *  ```>>> */
static inline void bw_buf_mix(
	const float * src1,
	const float * src2,
	float *       dest,
	size_t        n_elems);
/*! <<<```
 *    Adds the first `n_elems` of `src1` and `src2` and stores the results in
 *    the first `n_elems` of `dest`.
 *
 *    #### bw_buf_mul()
 *  ```>>> */
static inline void bw_buf_mul(
	const float * src1,
	const float * src2,
	float *       dest,
	size_t        n_elems);
/*! <<<```
 *    Multiplies the first `n_elems` of `src1` and `src2` and stores the results
 *    in the first `n_elems` of `dest`.
 *
 *    #### bw_buf_fill_multi()
 *  ```>>> */
static inline void bw_buf_fill_multi(
	float                                   k,
	float * BW_RESTRICT const * BW_RESTRICT dest,
	size_t                                  n_channels,
	size_t                                  n_elems);
/*! <<<```
 *    Sets the first `n_elems` in each of the `n_channels` buffers `dest` to
 *    `k`.
 *
 *    #### bw_buf_neg_multi()
 *  ```>>> */
static inline void bw_buf_neg_multi(
	const float * const * src,
	float * const *       dest,
	size_t                n_channels,
	size_t                n_elems);
/*! <<<```
 *    Inverts the sign of the first `n_elems` in each of the `n_channels`
 *    buffers `src` and stores the results in the first `n_elems` in each of the
 *    `n_channels` buffers `dest`.
 *
 *    #### bw_buf_add_multi()
 *  ```>>> */
static inline void bw_buf_add_multi(
	const float * const * src,
	float                 k,
	float * const *       dest,
	size_t                n_channels,
	size_t                n_elems);
/*! <<<```
 *    Adds `k` to the first `n_elems` in each of the `n_channels` buffers `src`
 *    and stores the results in the first `n_elems` in each of the `n_channels`
 *    buffers `dest`.
 *
 *    #### bw_buf_scale_multi()
 *  ```>>> */
static inline void bw_buf_scale_multi(
	const float * const * src,
	float                 k,
	float * const *       dest,
	size_t                n_channels,
	size_t                n_elems);
/*! <<<```
 *    Multiplies the first `n_elems` in each of the `n_channels` buffers `src`
 *    by `k` and stores the results in the first `n_elems` in each of the
 *    `n_channels` buffers `dest`.
 *
 *    #### bw_buf_mix_multi()
 *  ```>>> */
static inline void bw_buf_mix_multi(
	const float * const * src1,
	const float * const * src2,
	float * const *       dest,
	size_t                n_channels,
	size_t                n_elems);
/*! <<<```
 *    Adds the first `n_elems` in each of the `n_channels` buffers `src1` and
 *    `src2` and stores the results in the first `n_elems` in each of the
 *    `n_channels` buffers `dest`.
 *
 *    #### bw_buf_mul_multi()
 *  ```>>> */
static inline void bw_buf_mul_multi(
	const float * const * src1,
	const float * const * src2,
	float * const *       dest,
	size_t                n_channels,
	size_t                n_elems);
/*! <<<```
 *    Multiplies the first `n_elems` in each of the `n_channels` buffers `src1`
 *    and `src2` and stores the results in the first `n_elems` in each of the
 *    `n_channels` buffers `dest`.
 *  }}} */

#ifdef __cplusplus
}
#endif

/*** Implementation ***/

/* WARNING: This part of the file is not part of the public API. Its content may
 * change at any time in future versions. Please, do not use it directly. */

#ifdef __cplusplus
extern "C" {
#endif

static inline void bw_buf_fill(
		float               k,
		float * BW_RESTRICT dest,
		size_t              n_elems) {
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = k;

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_neg(
		const float * src,
		float *       dest,
		size_t        n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src, n_elems));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = -src[i];

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_add(
		const float * src,
		float         k,
		float *       dest,
		size_t        n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src, n_elems));
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = k + src[i];

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_scale(
		const float * src,
		float         k,
		float *       dest,
		size_t        n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src, n_elems));
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = k * src[i];

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_mix(
		const float * src1,
		const float * src2,
		float *       dest,
		size_t        n_elems) {
	BW_ASSERT(src1 != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src1, n_elems));
	BW_ASSERT(src2 != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src2, n_elems));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = src1[i] + src2[i];

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_mul(
		const float * src1,
		const float * src2,
		float *       dest,
		size_t        n_elems) {
	BW_ASSERT(src1 != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src1, n_elems));
	BW_ASSERT(src2 != BW_NULL);
	BW_ASSERT_DEEP(!bw_has_nan(src2, n_elems));
	BW_ASSERT(dest != BW_NULL);

	for (size_t i = 0; i < n_elems; i++)
		dest[i] = src1[i] * src2[i];

	BW_ASSERT_DEEP(!bw_has_nan(dest, n_elems));
}

static inline void bw_buf_fill_multi(
		float                                   k,
		float * BW_RESTRICT const * BW_RESTRICT dest,
		size_t                                  n_channels,
		size_t                                  n_elems) {
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_fill(k, dest[i], n_elems);
}

static inline void bw_buf_neg_multi(
		const float * const * src,
		float * const *       dest,
		size_t                n_channels,
		size_t                n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = 0; j < n_channels; j++)
			BW_ASSERT(i == j || src[i] != dest[j]);
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_neg(src[i], dest[i], n_elems);
}

static inline void bw_buf_add_multi(
		const float * const * src,
		float                 k,
		float * const *       dest,
		size_t                n_channels,
		size_t                n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = 0; j < n_channels; j++)
			BW_ASSERT(i == j || src[i] != dest[j]);
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_add(src[i], k, dest[i], n_elems);
}

static inline void bw_buf_scale_multi(
		const float * const * src,
		float                 k,
		float * const *       dest,
		size_t                n_channels,
		size_t                n_elems) {
	BW_ASSERT(src != BW_NULL);
	BW_ASSERT(!bw_is_nan(k));
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = 0; j < n_channels; j++)
			BW_ASSERT(i == j || src[i] != dest[j]);
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_scale(src[i], k, dest[i], n_elems);
}

static inline void bw_buf_mix_multi(
		const float * const * src1,
		const float * const * src2,
		float * const *       dest,
		size_t                n_channels,
		size_t                n_elems) {
	BW_ASSERT(src1 != BW_NULL);
	BW_ASSERT(src2 != BW_NULL);
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = 0; j < n_channels; j++) {
			BW_ASSERT(i == j || src1[i] != dest[j]);
			BW_ASSERT(i == j || src2[i] != dest[j]);
		}
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_mix(src1[i], src2[i], dest[i], n_elems);
}

static inline void bw_buf_mul_multi(
		const float * const * src1,
		const float * const * src2,
		float * const *       dest,
		size_t                n_channels,
		size_t                n_elems) {
	BW_ASSERT(src1 != BW_NULL);
	BW_ASSERT(src2 != BW_NULL);
	BW_ASSERT(dest != BW_NULL);
#ifndef BW_NO_DEBUG
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = i + 1; j < n_channels; j++)
			BW_ASSERT(dest[i] != dest[j]);
	for (size_t i = 0; i < n_channels; i++)
		for (size_t j = 0; j < n_channels; j++) {
			BW_ASSERT(i == j || src1[i] != dest[j]);
			BW_ASSERT(i == j || src2[i] != dest[j]);
		}
#endif

	for (size_t i = 0; i < n_channels; i++)
		bw_buf_mul(src1[i], src2[i], dest[i], n_elems);
}

#ifdef __cplusplus
}

#ifndef BW_CXX_NO_ARRAY
# include <array>
#endif

namespace Brickworks {

/*** Public C++ API ***/

/*! api_cpp {{{
 *    ##### Brickworks::bufFill
 *  ```>>> */
template<size_t N_CHANNELS>
inline void bufFill(
	float                                   k,
	float * BW_RESTRICT const * BW_RESTRICT dest,
	size_t                                  nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufFill(
	float                                       k,
	std::array<float * BW_RESTRICT, N_CHANNELS> dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *
 *    ##### Brickworks::bufNeg
 *  ```>>> */
template<size_t N_CHANNELS>
inline void bufNeg(
	const float * const * src,
	float * const *       dest,
	size_t                nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufNeg(
	const std::array<const float *, N_CHANNELS> src,
	const std::array<float *, N_CHANNELS>       dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *
 *    ##### Brickworks::bufAdd
 *  ```>>> */		
template<size_t N_CHANNELS>
inline void bufAdd(
	const float * const * src,
	float                 k,
	float * const *       dest,
	size_t                nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufAdd(
	const std::array<const float *, N_CHANNELS> src,
	float                                       k,
	const std::array<float *, N_CHANNELS>       dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *
 *    ##### Brickworks::bufScale
 *  ```>>> */
template<size_t N_CHANNELS>
inline void bufScale(
	const float * const * src,
	float                 k,
	float * const *       dest,
	size_t                nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufScale(
	const std::array<const float *, N_CHANNELS> src,
	float                                       k,
	const std::array<float *, N_CHANNELS>       dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *
 *    ##### Brickworks::bufMix
 *  ```>>> */
template<size_t N_CHANNELS>
inline void bufMix(
	const float * const * src1,
	const float * const * src2,
	float * const *       dest,
	size_t                nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufMix(
	const std::array<const float *, N_CHANNELS> src1,
	const std::array<const float *, N_CHANNELS> src2,
	const std::array<float *, N_CHANNELS>       dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *
 *    ##### Brickworks::bufMul
 *  ```>>> */
template<size_t N_CHANNELS>
inline void bufMul(
	const float * const * src1,
	const float * const * src2,
	float * const *       dest,
	size_t                nSamples);

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufMul(
	const std::array<const float *, N_CHANNELS> src1,
	const std::array<const float *, N_CHANNELS> src2,
	const std::array<float *, N_CHANNELS>       dest,
	size_t                                      nSamples);
#endif
/*! <<<```
 *  }}} */

/*** Implementation ***/

/* WARNING: This part of the file is not part of the public API. Its content may
 * change at any time in future versions. Please, do not use it directly. */

template<size_t N_CHANNELS>
inline void bufFill(
		float                                   k,
		float * BW_RESTRICT const * BW_RESTRICT dest,
		size_t                                  nSamples) {
	bw_buf_fill_multi(k, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufFill(
		float                                             k,
		const std::array<float * BW_RESTRICT, N_CHANNELS> dest,
		size_t                                            nSamples) {
	bufFill<N_CHANNELS>(k, dest.data(), nSamples);
}
#endif

template<size_t N_CHANNELS>
inline void bufNeg(
		const float * const * src,
		float * const *       dest,
		size_t                nSamples) {
	bw_buf_neg_multi(src, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufNeg(
		const std::array<const float *, N_CHANNELS> src,
		const std::array<float *, N_CHANNELS>       dest,
		size_t                                      nSamples) {
	bufNeg<N_CHANNELS>(src.data(), dest.data(), nSamples);
}
#endif

template<size_t N_CHANNELS>
inline void bufAdd(
		const float * const * src,
		float                 k,
		float * const *       dest,
		size_t                nSamples) {
	bw_buf_add_multi(src, k, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufAdd(
		const std::array<const float *, N_CHANNELS> src,
		float                                       k,
		const std::array<float *, N_CHANNELS>       dest,
		size_t                                      nSamples) {
	bufAdd<N_CHANNELS>(src.data(), k, dest.data(), nSamples);
}
#endif

template<size_t N_CHANNELS>
inline void bufScale(
		const float * const * src,
		float                 k,
		float * const *       dest,
		size_t                nSamples) {
	bw_buf_scale_multi(src, k, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufScale(
		const std::array<const float *, N_CHANNELS> src,
		float                                       k,
		const std::array<float *, N_CHANNELS>       dest,
		size_t                                      nSamples) {
	bufScale<N_CHANNELS>(src.data(), k, dest.data(), nSamples);
}
#endif

template<size_t N_CHANNELS>
inline void bufMix(
		const float * const * src1,
		const float * const * src2,
		float * const *       dest,
		size_t                nSamples) {
	bw_buf_mix_multi(src1, src2, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufMix(
		const std::array<const float *, N_CHANNELS> src1,
		const std::array<const float *, N_CHANNELS> src2,
		const std::array<float *, N_CHANNELS>       dest,
		size_t                                      nSamples) {
	bufMix<N_CHANNELS>(src1.data(), src2.data(), dest.data(), nSamples);
}
#endif

template<size_t N_CHANNELS>
inline void bufMul(
		const float * const * src1,
		const float * const * src2,
		float * const *       dest,
		size_t                nSamples) {
	bw_buf_mul_multi(src1, src2, dest, N_CHANNELS, nSamples);
}

#ifndef BW_CXX_NO_ARRAY
template<size_t N_CHANNELS>
inline void bufMul(
		const std::array<const float *, N_CHANNELS> src1,
		const std::array<const float *, N_CHANNELS> src2,
		const std::array<float *, N_CHANNELS>       dest,
		size_t                                      nSamples) {
	bufMul<N_CHANNELS>(src1.data(), src2.data(), dest.data(), nSamples);
}
#endif

}
#endif

#endif