SampleFrame.h

Go to the documentation of this file.

/*
 * SampleFrame.h - Representation of a stereo sample
 *
 * Copyright (c) 2004-2009 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 * Copyright (c) 2024- Michael Gregorius
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program 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; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program 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 this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_SAMPLEFRAME_H
#define LMMS_SAMPLEFRAME_H
 
#include "LmmsTypes.h"
#include "lmms_constants.h"
 
#include <algorithm>
#include <array>
#include <cmath>
 
 
namespace lmms
{
 
class SampleFrame
{
public:
        SampleFrame() : SampleFrame(0., 0.)
        {
        }
 
        explicit SampleFrame(sample_t value) : SampleFrame(value, value)
        {
        }
 
        SampleFrame(sample_t left, sample_t right) :
                m_samples({ left, right })
        {
        }
 
        sample_t* data()
        {
                return m_samples.data();
        }
 
        const sample_t* data() const
        {
                return m_samples.data();
        }
 
        sample_t& left()
        {
                return m_samples[0];
        }
 
        const sample_t& left() const
        {
                return m_samples[0];
        }
 
        void setLeft(const sample_t& value)
        {
                m_samples[0] = value;
        }
 
        sample_t& right()
        {
                return m_samples[1];
        }
 
        const sample_t& right() const
        {
                return m_samples[1];
        }
 
        void setRight(const sample_t& value)
        {
                m_samples[1] = value;
        }
 
        sample_t& operator[](size_t index)
        {
                return m_samples[index];
        }
 
        const sample_t& operator[](size_t index) const
        {
                return m_samples[index];
        }
 
        SampleFrame operator+(const SampleFrame& other) const
        {
                return SampleFrame(left() + other.left(), right() + other.right());
        }
 
        SampleFrame& operator+=(const SampleFrame& other)
        {
                auto & l = left();
                auto & r = right();
 
                l += other.left();
                r += other.right();
 
                return *this;
        }
 
        SampleFrame operator*(float value) const
        {
                return SampleFrame(left() * value, right() * value);
        }
 
        SampleFrame& operator*=(float value)
        {
                setLeft(left() * value);
                setRight(right() * value);
 
                return *this;
        }
 
        SampleFrame operator*(const SampleFrame& other) const
        {
                return SampleFrame(left() * other.left(), right() * other.right());
        }
 
        void operator*=(const SampleFrame& other)
        {
                left() *= other.left();
                right() *= other.right();
        }
 
        sample_t sumOfSquaredAmplitudes() const
        {
                return left() * left() + right() * right();
        }
 
        SampleFrame abs() const
        {
                return SampleFrame{std::abs(this->left()), std::abs(this->right())};
        }
 
        SampleFrame absMax(const SampleFrame& other)
        {
                const auto a = abs();
                const auto b = other.abs();
 
                return SampleFrame(std::max(a.left(), b.left()), std::max(a.right(), b.right()));
        }
 
        sample_t average() const
        {
                return (left() + right()) / 2;
        }
 
        void clamp(sample_t low, sample_t high)
        {
                auto & l = left();
                l = std::clamp(l, low, high);
 
                auto & r = right();
                r = std::clamp(r, low, high);
        }
 
        bool containsInf() const
        {
                return std::isinf(left()) || std::isinf(right());
        }
 
        bool containsNaN() const
        {
                return std::isnan(left()) || std::isnan(right());
        }
 
private:
        std::array<sample_t, DEFAULT_CHANNELS> m_samples;
};
 
inline void zeroSampleFrames(SampleFrame* buffer, size_t frames)
{
        // The equivalent of the following operation which yields compiler warnings
        // memset(buffer, 0, sizeof(SampleFrame) * frames);
 
        std::fill(buffer, buffer + frames, SampleFrame());
}
 
inline SampleFrame getAbsPeakValues(SampleFrame* buffer, size_t frames)
{
        SampleFrame peaks;
 
        for (f_cnt_t i = 0; i < frames; ++i)
        {
                peaks = peaks.absMax(buffer[i]);
        }
 
        return peaks;
}
 
inline void copyToSampleFrames(SampleFrame* target, const float* source, size_t frames)
{
        for (size_t i = 0; i < frames; ++i)
        {
                target[i].setLeft(source[2*i]);
                target[i].setRight(source[2*i + 1]);
        }
}
 
inline void copyFromSampleFrames(float* target, const SampleFrame* source, size_t frames)
{
        for (size_t i = 0; i < frames; ++i)
        {
                target[2*i] = source[i].left();
                target[2*i + 1] = source[i].right();
        }
}
 
} // namespace lmms
 
#endif // LMMS_SAMPLEFRAME_H