FFmpegWriter.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_WRITER_H
#define OPENSHOT_FFMPEG_WRITER_H
 
#include "ReaderBase.h"
#include "WriterBase.h"
 
// Include FFmpeg headers and macros
#include "FFmpegUtilities.h"
 
namespace openshot {
 
    enum StreamType {
        VIDEO_STREAM,   
        AUDIO_STREAM    
    };
 
    class FFmpegWriter : public WriterBase {
    private:
        std::string path;
        bool is_writing;
        bool is_open;
        int64_t video_timestamp;
        int64_t audio_timestamp;
 
        bool prepare_streams;
        bool write_header;
        bool write_trailer;
        bool allow_b_frames;
        bool testing;
 
        AVFormatContext* oc;
        AVStream *audio_st, *video_st;
        AVCodecContext *video_codec_ctx;
        AVCodecContext *audio_codec_ctx;
        SwsContext *img_convert_ctx;
        int16_t *samples;
        uint8_t *audio_outbuf;
        uint8_t *audio_encoder_buffer;
 
        AVFrame *persistent_src_frame = nullptr;
        AVFrame *persistent_dst_frame = nullptr;
        uint8_t *persistent_dst_buffer = nullptr;
        int persistent_dst_size = 0;
 
        int audio_outbuf_size;
        int audio_input_frame_size;
        int initial_audio_input_frame_size;
        int audio_input_position;
        int audio_encoder_buffer_size;
        SWRCONTEXT *avr;
        SWRCONTEXT *avr_planar;
 
        /* Resample options */
        int original_sample_rate;
        int original_channels;
 
        std::shared_ptr<openshot::Frame> last_frame;
        std::map<std::shared_ptr<openshot::Frame>, AVFrame *> av_frames;
 
        void add_avframe(std::shared_ptr<openshot::Frame> frame, AVFrame *av_frame);
 
        AVStream *add_audio_stream();
 
        AVStream *add_video_stream();
 
        AVFrame *allocate_avframe(PixelFormat pix_fmt, int width, int height, int *buffer_size, uint8_t *new_buffer);
 
        void auto_detect_format();
 
        void close_audio(AVFormatContext *oc, AVStream *st);
 
        void close_video(AVFormatContext *oc, AVStream *st);
 
        void flush_encoders();
 
        void initialize_streams();
 
        void open_audio(AVFormatContext *oc, AVStream *st);
 
        void open_video(AVFormatContext *oc, AVStream *st);
 
        void process_video_packet(std::shared_ptr<openshot::Frame> frame);
 
        void write_audio_packets(bool is_final, std::shared_ptr<openshot::Frame> frame);
 
        bool write_video_packet(std::shared_ptr<openshot::Frame> frame, AVFrame *frame_final);
 
        void write_frame(std::shared_ptr<Frame> frame);
 
    public:
 
        FFmpegWriter(const std::string& path);
 
        void Close();
 
        bool IsOpen() { return is_open; };
 
        static bool IsValidCodec(std::string codec_name);
 
        static std::string GetEncoderInfo(std::string codec_name);
 
        static std::string GetFormatInfo(std::string format_name);
 
        static std::string GetFormats();
 
        static std::string GetEncoders(std::string media_type, std::string format_name = "");
 
        static int IsCodecSupportedByFormat(std::string format_name, std::string codec_name);
 
        void Open();
 
        std::string Test();
 
        void OutputStreamInfo();
 
        void PrepareStreams();
 
        void ResampleAudio(int sample_rate, int channels);
 
        void SetAudioOptions(bool has_audio, std::string codec, int sample_rate, int channels, openshot::ChannelLayout channel_layout, int bit_rate);
 
        void SetAudioOptions(std::string codec, int sample_rate, int bit_rate);
 
        void SetVideoOptions(bool has_video, std::string codec, openshot::Fraction fps, int width, int height, openshot::Fraction pixel_ratio, bool interlaced, bool top_field_first, int bit_rate);
 
        void SetVideoOptions(std::string codec, int width, int height,  openshot::Fraction fps, int bit_rate);
 
        void SetOption(openshot::StreamType stream, std::string name, std::string value);
 
        void WriteHeader();
 
        void WriteFrame(std::shared_ptr<openshot::Frame> frame);
 
        void WriteFrameAt(std::shared_ptr<openshot::Frame> frame, int64_t frame_number);
 
        void WriteFrame(openshot::ReaderBase *reader, int64_t start, int64_t length);
 
        void WriteTrailer();
 
        void AddSphericalMetadata(const std::string& projection="equirectangular", float yaw_deg=0.0f, float pitch_deg=0.0f, float roll_deg=0.0f);
 
    };
 
} // namespace openshot
 
#endif