ReaderBase.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_READER_BASE_H
#define OPENSHOT_READER_BASE_H
 
#include <map>
#include <memory>
#include <mutex>
#include <iostream>
#include <string>
#include <vector>
 
#include "ChannelLayouts.h"
#include "Fraction.h"
#include "Json.h"
 
namespace openshot
{
    class CacheBase;
    class ClipBase;
    class Frame;
    struct ReaderInfo
    {
        bool has_video;             
        bool has_audio;             
        bool has_single_image;      
        float duration;             
        int64_t file_size;      
        int height;                 
        int width;                  
        int pixel_format;           
        openshot::Fraction fps;             
        int video_bit_rate;         
        openshot::Fraction pixel_ratio;     
        openshot::Fraction display_ratio;       
        std::string vcodec;             
        int64_t video_length;       
        int video_stream_index;     
        openshot::Fraction video_timebase;  
        bool interlaced_frame;      // Are the contents of this frame interlaced
        bool top_field_first;       // Which interlaced field should be displayed first
        std::string acodec;             
        int audio_bit_rate;         
        int sample_rate;            
        int channels;               
        openshot::ChannelLayout channel_layout; 
        int audio_stream_index;     
        openshot::Fraction audio_timebase;  
        std::map<std::string, std::string> metadata;    
    };
 
    class ReaderBase
    {
    protected:
        std::recursive_mutex getFrameMutex;
        openshot::ClipBase* clip; 
        int max_decode_width; 
        int max_decode_height; 
        bool apply_orientation_metadata; 
 
    public:
 
        ReaderBase();
 
        openshot::ReaderInfo info;
 
        openshot::ClipBase* ParentClip();
 
        void ParentClip(openshot::ClipBase* new_clip);
 
        void SetMaxDecodeSize(int width, int height);
 
        int MaxDecodeWidth() const;
 
        int MaxDecodeHeight() const;
 
        bool HasMaxDecodeSize() const;
 
        void ApplyOrientationMetadata(bool value);
 
        bool ApplyOrientationMetadata() const;
 
        virtual void Close() = 0;
 
        void DisplayInfo(std::ostream* out=&std::cout);
 
        virtual openshot::CacheBase* GetCache() = 0;
 
        virtual std::shared_ptr<openshot::Frame> GetFrame(int64_t number) = 0;
 
        virtual bool IsOpen() = 0;
 
        virtual bool HardwareDecodeSuccessful() const { return false; }
 
        virtual std::string Name() = 0;
 
        // Get and Set JSON methods
        virtual std::string Json() const = 0; 
        virtual void SetJson(const std::string value) = 0; 
        virtual Json::Value JsonValue() const = 0; 
        virtual void SetJsonValue(const Json::Value root) = 0; 
 
        virtual void Open() = 0;
 
        virtual ~ReaderBase() = default;
    };
 
}
 
#endif