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 <sstream>
#include <queue>
 
#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_reversed; 
 
#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 ReverseAudio();
 
        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