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;
 
        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);

        void Open();

        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 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