Frame.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_FRAME_H
#define OPENSHOT_FRAME_H
 
#ifdef USE_OPENCV
    #define int64 opencv_broken_int
    #define uint64 opencv_broken_uint
    #include <opencv2/imgproc/imgproc.hpp>
    #undef uint64
    #undef int64
#endif
 
#include <memory>
#include <mutex>
 
#include "ChannelLayouts.h"
#include "Fraction.h"
 
#include <QColor>
#include <QImage>
 
class QApplication;
 
namespace juce {
    template <typename Type> class AudioBuffer;
}
 
namespace openshot
{
    class AudioBufferSource;
    class AudioResampler;
    class Frame
    {
    private:
        std::shared_ptr<QImage> image;
        std::shared_ptr<QImage> wave_image;
 
        std::shared_ptr<QApplication> previewApp;
        std::recursive_mutex addingImageMutex;
        std::recursive_mutex addingAudioMutex;
        openshot::Fraction pixel_ratio;
        int channels;
        ChannelLayout channel_layout;
        int width;
        int height;
        int sample_rate;
        std::string color;
        int64_t max_audio_sample; 
        bool audio_is_increasing; 
 
#ifdef USE_OPENCV
        cv::Mat imagecv; 
#endif

        int constrain(int color_value);
 
    public:
        std::shared_ptr<juce::AudioBuffer<float>> audio;
        int64_t number;  
        bool has_audio_data; 
        bool has_image_data; 
 

        Frame();

        Frame(int64_t number, int width, int height, std::string color);

        Frame(int64_t number, int samples, int channels);

        Frame(int64_t number, int width, int height, std::string color, int samples, int channels);

        Frame ( const Frame &other );

        Frame& operator= (const Frame& other);

        virtual ~Frame();

        void AddColor(int new_width, int new_height, std::string new_color);

        void AddColor(const QColor& new_color);

        void AddImage(int new_width, int new_height, int bytes_per_pixel, QImage::Format type, const unsigned char *pixels_);

        void AddImage(std::shared_ptr<QImage> new_image);

        void AddImage(std::shared_ptr<QImage> new_image, bool only_odd_lines);

        void AddAudio(bool replaceSamples, int destChannel, int destStartSample, const float* source, int numSamples, float gainToApplyToSource);

        void AddAudioSilence(int numSamples);

        void ApplyGainRamp(int destChannel, int destStartSample, int numSamples, float initial_gain, float final_gain);

        openshot::ChannelLayout ChannelsLayout();
 
        // Set the channel layout of audio samples (i.e. mono, stereo, 5 point surround, etc...)
        void ChannelsLayout(openshot::ChannelLayout new_channel_layout) { channel_layout = new_channel_layout; };

        void ClearWaveform();

        void DeepCopy(const Frame& other);

        void Display();

        void DisplayWaveform();

        float GetAudioSample(int channel, int sample, int magnitude_range);

        float* GetAudioSamples(int channel);

        float* GetInterleavedAudioSamples(int* sample_count);

        int GetAudioChannelsCount();

        int GetAudioSamplesCount();
 
        juce::AudioBuffer<float> *GetAudioSampleBuffer();

        int64_t GetBytes();

        std::shared_ptr<QImage> GetImage();

        openshot::Fraction GetPixelRatio() { return pixel_ratio; };

        const unsigned char* GetPixels();

        const unsigned char* GetPixels(int row);

        bool CheckPixel(int row, int col, int red, int green, int blue, int alpha, int threshold);

        int GetHeight();

        int GetSamplesPerFrame(openshot::Fraction fps, int sample_rate, int channels);

        static int GetSamplesPerFrame(int64_t frame_number, openshot::Fraction fps, int sample_rate, int channels);

        std::shared_ptr<QImage> GetWaveform(int width, int height, int Red, int Green, int Blue, int Alpha);

        const unsigned char* GetWaveformPixels(int width, int height, int Red, int Green, int Blue, int Alpha);

        int GetWidth();

        void ResizeAudio(int channels, int length, int sample_rate, openshot::ChannelLayout channel_layout);

        int SampleRate();

        void SampleRate(int orig_sample_rate) { sample_rate = orig_sample_rate; };

        void SetAudioDirection(bool is_increasing);

        void Save(std::string path, float scale, std::string format="PNG", int quality=100);

        void SetFrameNumber(int64_t number);

        void SetPixelRatio(int num, int den);

        void Thumbnail(std::string path, int new_width, int new_height, std::string mask_path, std::string overlay_path,
                std::string background_color, bool ignore_aspect, std::string format="png", int quality=100, float rotate=0.0);

        void Play();
 
#ifdef USE_OPENCV
        cv::Mat Qimage2mat( std::shared_ptr<QImage>& qimage);

        std::shared_ptr<QImage> Mat2Qimage(cv::Mat img);

        cv::Mat GetImageCV();

        void SetImageCV(cv::Mat _image);
#endif
    };
 
}
 
#endif