#include "audio_buffer.h"

#include <cstring>

void audio_buffer::resize(uint32_t channel_num, uint32_t block_size) {
    std::scoped_lock lock(lock_);
    buffer_.resize(channel_num);
    headers_.resize(channel_num);
    for (uint32_t i = 0; i < channel_num; i++) {
        buffer_[i].resize(block_size);
        headers_[i] = buffer_[i].data();
    }
}

void audio_buffer::clear() {
    std::scoped_lock lock(lock_);
    for (auto& channel : buffer_) {
        std::memset(channel.data(), 0, channel.size() * sizeof(float));
    }
}

void audio_buffer::mix(audio_buffer& in_buffer, float percent) {
    std::scoped_lock lock(lock_);
    // will be optimized by compiler
    for (uint32_t channel_index = 0; channel_index < buffer_.size(); channel_index++) {
        auto& channel = buffer_[channel_index];
        auto& in_channel = in_buffer.buffer_[channel_index];
        for (uint32_t sample_index = 0; sample_index < channel.size(); sample_index++) {
            channel[sample_index] += in_channel[sample_index] * percent;
        }
    }
}

void audio_buffer::multiple(float percent) {
    std::scoped_lock lock(lock_);
    // will be optimized by compiler
    for (auto& channel : buffer_) {
        for (auto& sample : channel) {
            sample *= percent;
        }
    }
}

std::vector<float> audio_buffer::get_interleaved_buffer() {
    std::scoped_lock lock(lock_);
    std::vector<float> result;
    result.reserve(buffer_[0].size() * buffer_.size());
    for (uint32_t sample_index = 0; sample_index < buffer_[0].size(); sample_index++) {
        for (uint32_t channel_index = 0; channel_index < buffer_.size(); channel_index++) {
            result.push_back(buffer_[channel_index][sample_index]);
        }
    }
    return result;
}