FrameScope.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2026 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_FRAMESCOPE_H
#define OPENSHOT_FRAMESCOPE_H
 
#include "Frame.h"
#include "Json.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace openshot {
 
    class FrameScope {
    private:
        std::shared_ptr<Frame> frame;
        int waveform_columns;
        int audio_buckets;
        int vectorscope_size;
        bool roi_enabled;
        float roi_x;
        float roi_y;
        float roi_width;
        float roi_height;
 
        bool video_present;
        int video_width;
        int video_height;
        int waveform_bins;
        std::vector<int> waveform_column_map;
        int waveform_column_map_width;
        int waveform_column_map_columns;
        double avg_luma;
        int clipped_shadows;
        int clipped_highlights;
        int clipped_red;
        int clipped_green;
        int clipped_blue;
        std::vector<uint32_t> histogram_luma;
        std::vector<uint32_t> histogram_red;
        std::vector<uint32_t> histogram_green;
        std::vector<uint32_t> histogram_blue;
        std::vector<uint32_t> waveform_luma;
        std::vector<uint32_t> waveform_red;
        std::vector<uint32_t> waveform_green;
        std::vector<uint32_t> waveform_blue;
        std::vector<uint32_t> vectorscope;
 
        bool audio_present;
        int audio_channels;
        int audio_samples;
        int audio_sample_rate;
        std::vector<float> audio_peak;
        std::vector<float> audio_rms;
        std::vector<uint32_t> audio_clipped_samples;
        std::vector<std::vector<float>> audio_waveform_min;
        std::vector<std::vector<float>> audio_waveform_max;
        mutable Json::Value scope_data;
        mutable bool json_dirty;
 
        void reset();
        void reset_video();
        void reset_audio();
        void ensure_video_buffers();
        void ensure_audio_buffers();
        void rebuild_waveform_column_map(int width);
        void analyze_video();
        void analyze_audio();
        void analyze();
        void rebuild_json() const;
        static std::vector<int> copy_to_int_vector(const std::vector<uint32_t>& values);
 
    public:
        FrameScope();
 
        FrameScope(std::shared_ptr<Frame> frame, int waveform_columns = 256, int audio_buckets = 256, int vectorscope_size = 256);
 
        void SetFrame(std::shared_ptr<Frame> new_frame);
 
        std::shared_ptr<Frame> GetFrame() const { return frame; }
 
        void SetWaveformColumns(int columns);
 
        void SetAudioBuckets(int buckets);
 
        void SetVectorscopeSize(int size);
 
        void SetVideoRegionNormalized(float x, float y, float width, float height);
 
        void ClearVideoRegion();
 
        bool HasVideoRegion() const { return roi_enabled; }
 
        bool HasVideo() const { return video_present; }
 
        bool HasAudio() const { return audio_present; }
 
        int GetVideoWidth() const { return video_width; }
 
        int GetVideoHeight() const { return video_height; }
 
        int GetWaveformColumns() const { return waveform_columns; }
 
        int GetWaveformBins() const { return waveform_bins; }
 
        int GetVectorscopeSize() const { return vectorscope_size; }
 
        const std::vector<uint32_t>& GetVideoHistogramLumaBins() const { return histogram_luma; }
 
        const std::vector<uint32_t>& GetVideoHistogramRedBins() const { return histogram_red; }
 
        const std::vector<uint32_t>& GetVideoHistogramGreenBins() const { return histogram_green; }
 
        const std::vector<uint32_t>& GetVideoHistogramBlueBins() const { return histogram_blue; }
 
        const std::vector<uint32_t>& GetVideoWaveformLumaBins() const { return waveform_luma; }
 
        const std::vector<uint32_t>& GetVideoWaveformRedBins() const { return waveform_red; }
 
        const std::vector<uint32_t>& GetVideoWaveformGreenBins() const { return waveform_green; }
 
        const std::vector<uint32_t>& GetVideoWaveformBlueBins() const { return waveform_blue; }
 
        const std::vector<uint32_t>& GetVideoVectorscopeBins() const { return vectorscope; }
 
        std::vector<int> GetVideoVectorscope() const { return copy_to_int_vector(vectorscope); }
 
        std::vector<int> GetVideoHistogramLuma() const { return copy_to_int_vector(histogram_luma); }
 
        std::vector<int> GetVideoHistogramRed() const { return copy_to_int_vector(histogram_red); }
 
        std::vector<int> GetVideoHistogramGreen() const { return copy_to_int_vector(histogram_green); }
 
        std::vector<int> GetVideoHistogramBlue() const { return copy_to_int_vector(histogram_blue); }
 
        std::vector<int> GetVideoWaveformLuma() const { return copy_to_int_vector(waveform_luma); }
 
        std::vector<int> GetVideoWaveformRed() const { return copy_to_int_vector(waveform_red); }
 
        std::vector<int> GetVideoWaveformGreen() const { return copy_to_int_vector(waveform_green); }
 
        std::vector<int> GetVideoWaveformBlue() const { return copy_to_int_vector(waveform_blue); }
 
        double GetVideoAverageLuma() const { return avg_luma; }
 
        int GetVideoClippedShadows() const { return clipped_shadows; }
 
        int GetVideoClippedHighlights() const { return clipped_highlights; }
 
        int GetVideoClippedRed() const { return clipped_red; }
 
        int GetVideoClippedGreen() const { return clipped_green; }
 
        int GetVideoClippedBlue() const { return clipped_blue; }
 
        int GetAudioChannels() const { return audio_channels; }
 
        int GetAudioSamples() const { return audio_samples; }
 
        int GetAudioSampleRate() const { return audio_sample_rate; }
 
        int GetAudioBuckets() const { return audio_buckets; }
 
        const std::vector<float>& GetAudioPeakLevelsRef() const { return audio_peak; }
 
        const std::vector<float>& GetAudioRmsLevelsRef() const { return audio_rms; }
 
        const std::vector<uint32_t>& GetAudioClippedSamplesRef() const { return audio_clipped_samples; }
 
        std::vector<float> GetAudioPeakLevels() const { return audio_peak; }
 
        std::vector<float> GetAudioRmsLevels() const { return audio_rms; }
 
        std::vector<int> GetAudioClippedSamples() const { return copy_to_int_vector(audio_clipped_samples); }
 
        std::vector<float> GetAudioWaveformMin(int channel) const;
 
        std::vector<float> GetAudioWaveformMax(int channel) const;
 
        Json::Value JsonValue() const;
 
        std::string Json() const;
    };
 
}
 
#endif