FFmpegReader.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC, Fabrice Bellard
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_FFMPEG_READER_H
#define OPENSHOT_FFMPEG_READER_H
 
#include "ReaderBase.h"
#include "Enums.h"
 
// Include FFmpeg headers and macros
#include "FFmpegUtilities.h"
 
#include <cmath>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <memory>
#include "AudioLocation.h"
#include "CacheMemory.h"
#include "Clip.h"
#include "OpenMPUtilities.h"
#include "Settings.h"
#include <cstdlib>
 
 
namespace openshot {
    struct PacketStatus {
        // Track counts of video and audio packets read & decoded
        int64_t video_read = 0;
        int64_t video_decoded = 0;
        int64_t audio_read = 0;
        int64_t audio_decoded = 0;
 
        // Track end-of-file detection on video/audio and overall
        bool video_eof = true;
        bool audio_eof = true;
        bool packets_eof = true;
        bool end_of_file = true;
 
        int64_t packets_read() {
            // Return total packets read
            return video_read + audio_read;
        }
 
        int64_t packets_decoded() {
            // Return total packets decoded
            return video_decoded + audio_decoded;
        }
 
        void reset(bool eof) {
            // Reset counts and EOF detection for packets
            video_read = 0; video_decoded = 0; audio_read = 0; audio_decoded = 0;
            video_eof = eof; audio_eof = eof; packets_eof = eof; end_of_file = eof;
        }
    };
 
    class FFmpegReader : public ReaderBase {
    private:
        std::string path;
 
        AVFormatContext *pFormatCtx;
        int videoStream, audioStream;
        AVCodecContext *pCodecCtx, *aCodecCtx;
#if USE_HW_ACCEL
        AVBufferRef *hw_device_ctx = NULL; //PM
#endif
        AVStream *pStream, *aStream;
        AVPacket *packet;
        AVFrame *pFrame;
        bool is_open;
        bool is_duration_known;
        bool check_interlace;
        bool check_fps;
        DurationStrategy duration_strategy;
 
        CacheMemory working_cache;
        AudioLocation previous_packet_location;
 
        // DEBUG VARIABLES (FOR AUDIO ISSUES)
        int prev_samples;
        int64_t prev_pts;
        int64_t pts_total;
        int64_t pts_counter;
        std::shared_ptr<openshot::Frame> last_video_frame;
 
        bool is_seeking;
        int64_t seeking_pts;
        int64_t seeking_frame;
        bool is_video_seek;
        int seek_count;
        int64_t seek_audio_frame_found;
        int64_t seek_video_frame_found;
 
        int64_t last_frame;
        int64_t largest_frame_processed;
        int64_t current_video_frame;
 
        int64_t audio_pts;
        int64_t video_pts;
        bool hold_packet;
        double pts_offset_seconds;
        double audio_pts_seconds;
        double video_pts_seconds;
        int64_t NO_PTS_OFFSET;
        PacketStatus packet_status;
 
        // Duration bookkeeping
        double video_stream_duration_seconds = 0.0;
        double audio_stream_duration_seconds = 0.0;
        double format_duration_seconds = 0.0;
        double inferred_duration_seconds = 0.0;
 
        // Cached conversion contexts and frames for performance
        SwsContext *img_convert_ctx = nullptr;        
        SWRCONTEXT *avr_ctx = nullptr;                
        AVFrame *pFrameRGB_cached = nullptr;          
 
        int hw_de_supported = 0;    // Is set by FFmpegReader
#if USE_HW_ACCEL
        AVPixelFormat hw_de_av_pix_fmt = AV_PIX_FMT_NONE;
        AVHWDeviceType hw_de_av_device_type = AV_HWDEVICE_TYPE_NONE;
        int IsHardwareDecodeSupported(int codecid);
#endif
 
        void CheckFPS();
 
        bool CheckSeek(bool is_video);
 
        void CheckWorkingFrames(int64_t requested_frame);
 
        int64_t ConvertFrameToAudioPTS(int64_t frame_number);
 
        int64_t ConvertFrameToVideoPTS(int64_t frame_number);
 
        int64_t ConvertVideoPTStoFrame(int64_t pts);
 
        std::shared_ptr<openshot::Frame> CreateFrame(int64_t requested_frame);
 
        AudioLocation GetAudioPTSLocation(int64_t pts);
 
        bool GetAVFrame();
 
        int GetNextPacket();
 
        int64_t GetPacketPTS();
 
        bool HasAlbumArt();
 
        double PickDurationSeconds() const;
 
        void ApplyDurationStrategy();
 
        bool IsPartialFrame(int64_t requested_frame);
 
        void ProcessVideoPacket(int64_t requested_frame);
 
        void ProcessAudioPacket(int64_t requested_frame);
 
        std::shared_ptr<openshot::Frame> ReadStream(int64_t requested_frame);
 
        void RemoveAVFrame(AVFrame *);
 
        void RemoveAVPacket(AVPacket *);
 
        void Seek(int64_t requested_frame);
 
        void UpdatePTSOffset();
 
        void UpdateAudioInfo();
 
        void UpdateVideoInfo();
 
    public:
        CacheMemory final_cache;
 
        bool enable_seek;
 
        FFmpegReader(const std::string& path, bool inspect_reader=true);
        FFmpegReader(const std::string& path, DurationStrategy duration_strategy, bool inspect_reader=true);
 
        virtual ~FFmpegReader();
 
        void Close() override;
 
        CacheMemory *GetCache() override { return &final_cache; };
 
        std::shared_ptr<openshot::Frame> GetFrame(int64_t requested_frame) override;
 
        bool IsOpen() override { return is_open; };
 
        std::string Name() override { return "FFmpegReader"; };
 
        // Get and Set JSON methods
        std::string Json() const override; 
        void SetJson(const std::string value) override; 
        Json::Value JsonValue() const override; 
        void SetJsonValue(const Json::Value root) override; 
 
        void Open() override;
 
        bool GetIsDurationKnown();
    };
 
}
 
#endif