audio_buffer_view.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
#include "ravennakit/core/assert.hpp"
 
namespace rav {

template<class T>
class AudioBufferView {
  public:
    AudioBufferView(T* const* channels, const size_t num_channels, const size_t num_frames) :
        channels_(channels), num_channels_(num_channels), num_frames_(num_frames) {}

    friend bool operator==(const AudioBufferView& lhs, const AudioBufferView& rhs) {
        if (lhs.num_channels_ != rhs.num_channels_ || lhs.num_frames_ != rhs.num_frames_) {
            return false;
        }
        for (size_t ch = 0; ch < lhs.num_channels_; ++ch) {
            if (!std::equal(lhs.channels_[ch], lhs.channels_[ch] + lhs.num_frames_, rhs.channels_[ch])) {
                return false;
            }
        }
        return true;
    }

    friend bool operator!=(const AudioBufferView& lhs, const AudioBufferView& rhs) {
        return !(lhs == rhs);
    }

    [[nodiscard]] size_t num_channels() const {
        return num_channels_;
    }

    [[nodiscard]] size_t num_frames() const {
        return num_frames_;
    }

    const T* operator[](size_t channel_index) const {
        RAV_ASSERT_DEBUG(channel_index < AudioBufferView<T>::num_channels(), "Channel index out of bounds");
        return channels_[channel_index];
    }

    T* operator[](size_t channel_index) {
        RAV_ASSERT_DEBUG(channel_index < num_channels_, "Channel index out of bounds");
        return channels_[channel_index];
    }

    const T* const* data() const {
        return channels_;
    }

    T* const* data() {
        return channels_;
    }

    void set_sample(size_t channel_index, size_t frame_index, T value) {
        RAV_ASSERT_DEBUG(channel_index < num_channels_, "Channel index out of bounds");
        RAV_ASSERT_DEBUG(frame_index < num_frames_, "Frame index out of bounds");
        channels_[channel_index][frame_index] = value;
    }

    void clear() const {
        for (size_t i = 0; i < num_channels_; ++i) {
            clear_audio_data(channels_[i], channels_[i] + num_frames_);
        }
    }

    void clear(T value) const {
        if (channels_ == nullptr) {
            return;
        }
        for (size_t i = 0; i < num_channels_; ++i) {
            std::fill(channels_[i], channels_[i] + num_frames_, value);
        }
    }

    void clear(const size_t channel_index, const size_t start_sample, const size_t num_samples_to_clear) {
        RAV_ASSERT_DEBUG(channel_index < num_channels(), "Channel index out of bounds");
        RAV_ASSERT_DEBUG(start_sample + num_samples_to_clear <= num_frames(), "Sample index out of bounds");
        clear_audio_data(channels_[channel_index] + start_sample, channels_[channel_index] + start_sample + num_samples_to_clear);
    }

    void copy_from(
        const size_t dst_start_frame, const size_t num_frames_to_copy, const T* const* src, const size_t src_num_channels,
        const size_t src_start_frame = 0
    ) {
        RAV_ASSERT_DEBUG(src_num_channels == num_channels(), "Number of channels mismatch");
        for (size_t i = 0; i < std::min(src_num_channels, num_channels()); ++i) {
            copy_from(i, dst_start_frame, num_frames_to_copy, src[i] + src_start_frame);
        }
    }

    void copy_from(const size_t dst_channel_index, const size_t dst_start_sample, const size_t num_samples_to_copy, const T* src) {
        RAV_ASSERT_DEBUG(dst_channel_index < num_channels(), "Channel index out of bounds");
        RAV_ASSERT_DEBUG(dst_start_sample + num_samples_to_copy <= num_frames(), "Sample index out of bounds");
 
        if (num_samples_to_copy == 0) {
            return;
        }
 
        std::memcpy(channels_[dst_channel_index] + dst_start_sample, src, num_samples_to_copy * sizeof(T));
    }

    void copy_to(
        const size_t src_start_frame, const size_t num_frames, T* const* dst, const size_t dst_num_channels,
        const size_t dst_start_frame = 0
    ) {
        RAV_ASSERT_DEBUG(dst_num_channels == num_channels(), "Number of channels mismatch");
        for (size_t i = 0; i < std::min(num_channels(), dst_num_channels); ++i) {
            copy_to(i, src_start_frame, num_frames, dst[i] + dst_start_frame);
        }
    }

    void copy_to(const size_t src_channel_index, const size_t src_start_sample, const size_t num_samples_to_copy, T* dst) {
        RAV_ASSERT_DEBUG(src_channel_index < num_channels(), "Channel index out of bounds");
        RAV_ASSERT_DEBUG(src_start_sample + num_samples_to_copy <= num_frames(), "Sample index out of bounds");
 
        if (num_samples_to_copy == 0) {
            return;
        }
 
        std::memcpy(dst, channels_[src_channel_index] + src_start_sample, num_samples_to_copy * sizeof(T));
    }

    [[nodiscard]] bool add(const AudioBufferView& other) {
        static_assert(std::is_floating_point_v<T>, "Not supported for integer types");
 
        if (num_channels_ != other.num_channels_ || num_frames_ != other.num_frames_) {
            return false;
        }
 
        for (size_t ch = 0; ch < num_channels_; ++ch) {
            for (size_t frame = 0; frame < num_frames_; ++frame) {
                channels_[ch][frame] += other.channels_[ch][frame];
            }
        }
 
        return true;
    }

    [[nodiscard]] bool is_valid() const {
        return channels_ != nullptr && num_channels_ > 0 && num_frames_ > 0;
    }

    T find_max_abs() const {
        std::remove_const_t<T> max_value = channels_[0][0];
        for (size_t ch = 0; ch < num_channels_; ++ch) {
            for (size_t frame = 0; frame < num_frames_; ++frame) {
                max_value = std::max(max_value, std::fabs(channels_[ch][frame]));
            }
        }
        return max_value;
    }

    T find_max_abs(const size_t channel_index) const {
        if (channel_index >= num_channels_) {
            return {};
        }
        std::remove_const_t<T> max_value = channels_[channel_index][0];
        for (size_t frame = 0; frame < num_frames_; ++frame) {
            max_value = std::max(max_value, std::fabs(channels_[channel_index][frame]));
        }
        return max_value;
    }

    AudioBufferView with_num_channels(const size_t num_channels) {
        return AudioBufferView(channels_, std::min(num_channels, num_channels_), num_frames_);
    }

    AudioBufferView with_num_frames(const size_t num_frames) {
        return AudioBufferView(channels_, num_channels_, std::min(num_frames, num_frames_));
    }

    AudioBufferView<std::add_const_t<T>> const_view() const {
        return AudioBufferView<std::add_const_t<T>>(channels_, num_channels_, num_frames_);
    }
 
  protected:
    void update(T* const* channels, const size_t num_channels, const size_t num_frames) {
        channels_ = num_channels > 0 && num_frames > 0 ? channels : nullptr;
        num_channels_ = num_channels;
        num_frames_ = num_frames;
    }
 
  private:
    T* const* channels_ {};
    size_t num_channels_ {};
    size_t num_frames_ {};
 
    template<class First, class Last>
    void clear_audio_data(First first, Last last) const {
        if constexpr (std::is_unsigned_v<T>) {
            std::fill(first, last, std::numeric_limits<T>::max() / 2 + 1);
        } else {
            std::fill(first, last, T {});
        }
    }
};
 
}  // namespace rav