SampleThumbnail.h

Go to the documentation of this file.

/*
 * SampleThumbnail.h
 *
 * Copyright (c) 2024 Khoi Dau <casboi86@gmail.com>
 * Copyright (c) 2024 Sotonye Atemie <sakertooth@gmail.com>
 *
 * 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_SAMPLE_THUMBNAIL_H
#define LMMS_SAMPLE_THUMBNAIL_H
 
#include <QDateTime>
#include <QRect>
#include <memory>
 
#include "lmms_export.h"
#include "SampleBuffer.h"
#include "SampleFrame.h"
 
class QPainter;
 
namespace lmms {
class Sample;
}
 
namespace lmms::gui {

class LMMS_EXPORT SampleThumbnail
{
public:
    struct VisualizeParameters
    {
        QRect sampleRect; 

        QRect viewportRect;
 
        float amplification = 1.0f; 
        float sampleStart = 0.0f;   
        float sampleEnd = 1.0f;     
        bool reversed = false;      
    };
 
    SampleThumbnail() = default;
    SampleThumbnail(const Sample& sample);
    void visualize(VisualizeParameters parameters, QPainter& painter) const;
 
private:
    class Thumbnail
    {
    public:
        struct Peak
        {
            Peak() = default;
 
            Peak(float min, float max)
                : min(min)
                , max(max)
            {
            }
 
            Peak(const SampleFrame& frame)
                : min(std::min(frame.left(), frame.right()))
                , max(std::max(frame.left(), frame.right()))
            {
            }
 
            Peak operator+(const Peak& other) const { return Peak(std::min(min, other.min), std::max(max, other.max)); }
            Peak operator+(const SampleFrame& frame) const { return *this + Peak{frame}; }
 
            float min = std::numeric_limits<float>::infinity();
            float max = -std::numeric_limits<float>::infinity();
        };
 
        Thumbnail() = default;
        Thumbnail(std::vector<Peak> peaks, double samplesPerPeak);
        Thumbnail(const float* buffer, size_t size, size_t width);
 
        Thumbnail zoomOut(float factor) const;
 
        Peak* data() { return m_peaks.data(); }
        Peak& operator[](size_t index) { return m_peaks[index]; }
        const Peak& operator[](size_t index) const { return m_peaks[index]; }
 
        int width() const { return m_peaks.size(); }
        double samplesPerPeak() const { return m_samplesPerPeak; }
 
    private:
        std::vector<Peak> m_peaks;
        double m_samplesPerPeak = 0.0;
    };
 
    struct SampleThumbnailEntry
    {
        QString filePath;
        QDateTime lastModified;
 
        friend bool operator==(const SampleThumbnailEntry& first, const SampleThumbnailEntry& second)
        {
            return first.filePath == second.filePath && first.lastModified == second.lastModified;
        }
    };
 
    struct Hash
    {
        std::size_t operator()(const SampleThumbnailEntry& entry) const noexcept { return qHash(entry.filePath); }
    };
 
    using ThumbnailCache = std::vector<Thumbnail>;
    std::shared_ptr<ThumbnailCache> m_thumbnailCache = std::make_shared<ThumbnailCache>();
    std::shared_ptr<const SampleBuffer> m_buffer = SampleBuffer::emptyBuffer();
    inline static std::unordered_map<SampleThumbnailEntry, std::shared_ptr<ThumbnailCache>, Hash> s_sampleThumbnailCacheMap;
};
 
} // namespace lmms::gui
 
#endif // LMMS_SAMPLE_THUMBNAIL_H