ffmpeg_transcoder.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017-2026 by Norbert Schlia (nschlia@oblivion-software.de)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * On Debian systems, the complete text of the GNU General Public License
 * Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
 */
 
#ifndef FFMPEG_TRANSCODER_H
#define FFMPEG_TRANSCODER_H
 
#pragma once
 
#include "ffmpeg_base.h"
#include "ffmpeg_audiofifo.h"
#include "ffmpeg_frame.h"
#include "ffmpeg_formatcontext.h"
#include "ffmpeg_swrcontext.h"
#include "ffmpeg_swscontext.h"
#include "ffmpeg_packet.h"
#include "ffmpeg_subtitle.h"
#include "id3v1tag.h"
#include "fileio.h"
#include "ffmpeg_profiles.h"
 
#include <queue>
#include <mutex>
#include <variant>
#include <functional>
#include <optional>
#include <atomic>
#include <utility>
 
class Buffer;
struct AVFilterContext;
struct AVFilterGraph;
struct AVCodecContext;
struct AVSubtitle;
 
enum class DECODER_STATUS
{
    DEC_ERROR = -1,                                     
    DEC_SUCCESS = 0,                                    
    DEC_EOF = 1                                         
};
typedef DECODER_STATUS *LPDECODER_STATUS;               
typedef DECODER_STATUS const * LPCDECODER_STATUS;       
class FFmpeg_Transcoder : public FFmpeg_Base, FFmpeg_Profiles
{
protected:
    typedef struct BUFFER_DATA
    {
        uint8_t *   ptr;    
        size_t      size;   
    } BUFFER_DATA;
 
#define MAX_PRORES_FRAMERATE    2                                   
    typedef struct PRORES_BITRATE                                   
    {
        int                     m_width;                            
        int                     m_height;                           
        struct PRORES_FRAMERATE                                     
        {
            int                 m_framerate;                        
            bool                m_interleaved;                      
        }                       m_framerate[MAX_PRORES_FRAMERATE];  
        std::array<int, 6>      m_bitrate;                          
    } PRORES_BITRATE, *LPPRORES_BITRATE;                            
    typedef PRORES_BITRATE const * LPCPRORES_BITRATE;               
    class StreamRef                                                 
    {
    public:
        StreamRef();
        virtual ~StreamRef();
 
        void set_codec_ctx(AVCodecContext *codec_ctx);
 
        void reset();
 
    public:
        std::shared_ptr<AVCodecContext> m_codec_ctx;                
        AVStream *                      m_stream;                   
        int                             m_stream_idx;               
        int64_t                         m_start_time;               
    };
 
    typedef std::map<int, StreamRef> StreamRef_map;                 
    struct INPUTFILE                                                
    {
        INPUTFILE() :
            m_filetype(FILETYPE::UNKNOWN),
            m_format_ctx(FFmpeg_FormatContext::TYPE::INPUT),
            m_pix_fmt(AV_PIX_FMT_NONE)
        {}
 
        FILETYPE                m_filetype;                         
        FFmpeg_FormatContext    m_format_ctx;                       
        StreamRef               m_audio;                            
        StreamRef               m_video;                            
        AVPixelFormat           m_pix_fmt;                          
        StreamRef_map           m_subtitle;                         
        std::vector<StreamRef>  m_album_art;                        
    };
 
    // Output file
    struct OUTPUTFILE : public INPUTFILE                            
    {
        OUTPUTFILE() :
            m_audio_pts(0),
            m_video_pts(0),
            m_last_mux_dts(AV_NOPTS_VALUE)
        {
            std::memset(&m_id3v1, 0, sizeof(m_id3v1));
        }
 
        int64_t                 m_audio_pts;                        
        int64_t                 m_video_pts;                        
        int64_t                 m_last_mux_dts;                     
        ID3v1                   m_id3v1;                            
    };
 
    typedef std::map<AVHWDeviceType, AVPixelFormat> DEVICETYPE_MAP; 
    enum class HWACCELMODE                                          
    {
        NONE,                                                       
        ENABLED,                                                    
        FALLBACK                                                    
    };
 
    typedef std::variant<FFmpeg_Frame, FFmpeg_Subtitle> MULTIFRAME; 
    typedef std::multimap<int64_t, MULTIFRAME>  MULTIFRAME_MAP;     
    typedef std::map<int, int>                  STREAM_MAP;         
public:
    explicit FFmpeg_Transcoder();
    virtual ~FFmpeg_Transcoder();
 
    bool                        is_open() const;
    int                         open_input_file(LPVIRTUALFILE virtualfile, std::shared_ptr<FileIO> fio = nullptr);
    int                         open_output_file(Buffer* buffer);
    int                         process_single_fr(DECODER_STATUS *status);
    int                         encode_finish();
    void                        closeio();
    time_t                      mtime() const;
    int64_t                     duration() const;
    size_t                      predicted_filesize() const;
    uint32_t                    video_frame_count() const;
    uint32_t                    segment_count() const;
    const ID3v1 *               id3v1tag() const;
    virtual const char *        filename() const override;
    virtual const char *        destname() const override;
    virtual const char *        virtname() const override;
    static bool                 audio_size(size_t *filesize, AVCodecID codec_id, BITRATE bit_rate, int64_t duration, int channels, int sample_rate, AVSampleFormat sample_format);
    static bool                 video_size(size_t *filesize, AVCodecID codec_id, BITRATE bit_rate, int64_t duration, int width, int height, bool interleaved, const AVRational & framerate);
    static bool                 total_overhead(size_t *filesize, FILETYPE filetype);
    bool                        close_output_file();
    bool                        close_input_file();
 
    int                         stack_seek_frame(uint32_t frame_no);
    int                         stack_seek_segment(uint32_t segment_no);
    bool                        is_multiformat() const;
    bool                        is_frameset() const;
    bool                        is_hls() const;
    bool                        have_seeked() const;
    void                        flush_buffers();
    int                         flush_delayed_audio();
    int                         flush_delayed_video();
    int                         flush_delayed_subtitles();
 
    int64_t                     pts() const;
 
    uint32_t                    last_seek_frame_no() const;
 
protected:
    int                         copy_audio_to_frame_buffer(int *finished);
    int                         open_bestmatch_decoder(AVFormatContext *format_ctx, AVCodecContext **codec_ctx, int *stream_idx, AVMediaType type);
    int                         open_bestmatch_video();
    int                         open_bestmatch_audio();
    int                         open_subtitles();
    int                         open_albumarts();
#if IF_DECLARED_CONST
    AVPixelFormat               get_hw_pix_fmt(const AVCodec *codec, AVHWDeviceType dev_type, bool use_device_ctx) const;
#else // !IF_DECLARED_CONST
    AVPixelFormat               get_hw_pix_fmt(AVCodec *codec, AVHWDeviceType dev_type, bool use_device_ctx) const;
#endif // !IF_DECLARED_CONST
#if IF_DECLARED_CONST
    int                         open_decoder(AVFormatContext *format_ctx, AVCodecContext **codec_ctx, int stream_idx, const AVCodec *input_codec, AVMediaType mediatype);
#else // !IF_DECLARED_CONST
    int                         open_decoder(AVFormatContext *format_ctx, AVCodecContext **codec_ctx, int stream_idx, AVCodec *input_codec, AVMediaType mediatype);
#endif // !IF_DECLARED_CONST
    int                         open_output_frame_set(Buffer *buffer);
    int                         open_output(Buffer *buffer);
    int                         process_output();
    bool                        is_video() const;
    int                         update_codec(void *opt, const PROFILE_OPTION_VEC & profile_option_vec) const;
    int                         prepare_codec(void *opt, FILETYPE filetype) const;
    int                         add_stream(AVCodecID codec_id);
    int                         add_subtitle_stream(AVCodecID codec_id, StreamRef & input_streamref, const std::optional<std::string> &language = std::nullopt);
    int                         add_stream_copy(AVCodecID codec_id, AVMediaType codec_type);
    int                         add_albumart_stream(const AVCodecContext *input_codec_ctx);
    int                         add_albumart_frame(AVStream *output_stream, AVPacket *pkt_in);
    int                         open_output_filestreams(Buffer *buffer);
    template <size_t size>
    const char *                tagcpy(char (&out) [ size ], const std::string & in) const;
    template <class T>
    const T &                   tagcpy(T & out, const std::string & in) const;
    void                        copy_metadata(AVDictionary **metadata_out, const AVDictionary *metadata_in, bool contentstream = true);
    int                         process_metadata();
    int                         process_albumarts();
    int                         init_resampler();
    int                         init_audio_fifo();
    int                         update_format(AVDictionary** dict, const PROFILE_OPTION_VEC & option_vec) const;
    int                         prepare_format(AVDictionary **dict, FILETYPE filetype) const;
    int                         write_output_file_header();
    int                         store_packet(AVPacket *pkt, AVMediaType mediatype);
    int                         decode_audio_frame(AVPacket *pkt, int *decoded);
    int                         decode_video_frame(AVPacket *pkt, int *decoded);
    int                         decode_subtitle(AVPacket *pkt, int *decoded);
    int                         decode_subtitle(AVCodecContext *codec_ctx, AVPacket *pkt, int *decoded, int out_stream_idx);
    void                        make_pts(AVPacket *pkt, int64_t *cur_ts) const;
    int                         decode_frame(AVPacket *pkt);
    int                         init_converted_samples(uint8_t ***converted_input_samples, int frame_size);
    int                         convert_samples(uint8_t **input_data, int in_samples, uint8_t **converted_data, int *out_samples);
    int                         add_samples_to_fifo(uint8_t **converted_input_samples, int frame_size);
    int                         flush_frames_all(bool use_flush_packet);
    int                         flush_frames_single(int stream_idx, bool use_flush_packet);
    int                         read_decode_convert_and_store(int *finished);
    int                         init_audio_output_frame(AVFrame *frame, int frame_size) const;
    int                         alloc_picture(AVFrame *frame, AVPixelFormat pix_fmt, int width, int height) const;
    void                        produce_audio_dts(AVPacket * pkt);
    int                         decode(AVCodecContext *codec_ctx, AVFrame *frame, int *got_frame, const AVPacket *pkt) const;
    int                         create_audio_frame(int frame_size);
    int                         encode_audio_frame(const AVFrame *frame, int *data_present);
    int                         encode_video_frame(const AVFrame *frame, int *data_present);
    int                         encode_subtitle(const AVSubtitle *sub, int out_stream_idx, int *data_present);
    int                         encode_image_frame(const AVFrame *frame, int *data_present);
    int                         write_output_file_trailer();
    static int                  input_read(void * opaque, unsigned char * data, int size);
#if LAVF_WRITEPACKET_CONST
    static int                  output_write(void * opaque, const uint8_t * data, int size);
#else
    static int                  output_write(void * opaque, unsigned char * data, int size);
#endif
    static int64_t              seek(void * opaque, int64_t offset, int whence);
 
    static BITRATE              get_prores_bitrate(int width, int height, const AVRational &framerate, bool interleaved, PRORESLEVEL profile);
    size_t                      calculate_predicted_filesize() const;
    bool                        get_video_size(int *output_width, int *output_height) const;
    static bool                 get_output_sample_rate(int input_sample_rate, int max_sample_rate, int * output_sample_rate = nullptr);
    static bool                 get_output_bit_rate(BITRATE input_bit_rate, BITRATE max_bit_rate, BITRATE * output_bit_rate = nullptr);
    bool                        get_aspect_ratio(int width, int height, const AVRational & sar, AVRational * ar) const;
 
    int                         init_deinterlace_filters(AVCodecContext *codec_ctx, AVPixelFormat pix_fmt, const AVRational &avg_frame_rate, const AVRational &time_base);
    int                         send_filters(FFmpeg_Frame * srcframe, int &ret);
    void                        free_filters();
    bool                        can_copy_stream(const AVStream *stream) const;
    bool                        close_resample();
    int                         init_rescaler(AVPixelFormat in_pix_fmt, int in_width, int in_height, AVPixelFormat out_pix_fmt, int out_width, int out_height);
    int                         purge_audio_fifo();
    size_t                      purge_multiframe_map();
    size_t                      purge_hls_fifo();
    void                        purge();
    int                         do_seek_frame(uint32_t frame_no);
    int                         skip_decoded_frames(uint32_t frame_no, bool forced_seek);
    void                        get_pix_formats(AVPixelFormat *in_pix_fmt, AVPixelFormat *out_pix_fmt, AVCodecContext* output_codec_ctx = nullptr) const;
 
    // Hardware de/encoding
    static enum AVPixelFormat   get_format_static(AVCodecContext *input_codec_ctx, const enum AVPixelFormat *pix_fmts);
    enum AVPixelFormat          get_format(AVCodecContext *input_codec_ctx, const enum AVPixelFormat *pix_fmts) const;
    int                         hwdevice_ctx_create(AVBufferRef **hwaccel_enc_device_ctx, AVHWDeviceType dev_type, const std::string & device) const;
    int                         hwdevice_ctx_add_ref(AVCodecContext *input_codec_ctx);
    void                        hwdevice_ctx_free(AVBufferRef **hwaccel_device_ctx);
    int                         hwframe_ctx_set(AVCodecContext *output_codec_ctx, AVCodecContext *input_codec_ctx, AVBufferRef *hw_device_ctx) const;
    int                         hwframe_copy_from_hw(AVCodecContext *output_codec_ctx, FFmpeg_Frame *sw_frame, const AVFrame *hw_frame) const;
    int                         hwframe_copy_to_hw(AVCodecContext *output_codec_ctx, FFmpeg_Frame *hw_frame, const AVFrame *sw_frame) const;
    int                         get_hw_decoder_name(AVCodecID codec_id, std::string *codec_name = nullptr) const;
    int                         get_hw_encoder_name(AVCodecID codec_id, std::string *codec_name = nullptr) const;
    int                         get_hw_vaapi_codec_name(AVCodecID codec_id, std::string *codec_name) const;
    int                         get_hw_mmal_decoder_name(AVCodecID codec_id, std::string *codec_name) const;
    /*
     * @brief Determine video for linux decoder codec name
     * @param[in] codec_id - Id of encoder/decoder codec
     * @param[out] codec_name - Name of the codec.
     * @return 0 on success, AVERROR_DECODER_NOT_FOUND if no codec available.
     */
    //int                         get_hw_v4l2m2m_decoder_name(AVCodecID codec_id, std::string *codec_name) const;
    int                         get_hw_omx_encoder_name(AVCodecID codec_id, std::string *codec_name) const;
    int                         get_hw_v4l2m2m_encoder_name(AVCodecID codec_id, std::string *codec_name) const;
    static AVPixelFormat        find_sw_fmt_by_hw_type(AVHWDeviceType type);
    uint32_t                    get_next_segment(int64_t pos) const;
    bool                        goto_next_segment(uint32_t next_segment) const;
 
    int                         create_fake_wav_header() const;
    int                         create_fake_aiff_header() const;
    int                         read_aiff_chunk(Buffer *buffer, size_t *buffoffset, const char *ID, uint8_t *chunk, size_t *size) const;
    bool                        is_audio_stream(int stream_idx) const;
    bool                        is_video_stream(int stream_idx) const;
    bool                        is_subtitle_stream(int stream_idx) const;
    StreamRef *                 get_out_subtitle_stream(int stream_idx);
    bool                        stream_exists(int stream_idx) const;
 
    void                        add_stream_map(int in_stream_idx, int out_stream_idx);
 
    int                         map_in_to_out_stream(int in_stream_idx) const;
 
    int                         add_subtitle_streams();
 
    int                         seek_frame();
 
    int                         start_new_segment();
 
    static int                  read_packet(void *opaque, uint8_t *buf, int buf_size);
    int                         add_external_subtitle_streams();
    int                         add_external_subtitle_stream(const std::string & subtitle_file, const std::optional<std::string> & language);
    int                         foreach_subtitle_file(const std::string& search_path, const std::regex& regex, int depth, const std::function<int (const std::string &, const std::optional<std::string> &)> & f);
 
private:
    std::shared_ptr<FileIO>     m_fileio;                       
    time_t                      m_mtime;                        
    std::recursive_mutex        m_seek_to_fifo_mutex;           
    std::queue<uint32_t>        m_seek_to_fifo;                 
    std::atomic_uint32_t        m_last_seek_frame_no;           
    bool                        m_have_seeked;                  
    bool                        m_skip_next_frame;              
    bool                        m_is_video;                     
    MULTIFRAME_MAP              m_frame_map;                    
    // Audio conversion and buffering
    AVSampleFormat              m_cur_sample_fmt;               
    int                         m_cur_sample_rate;              
#if LAVU_DEP_OLD_CHANNEL_LAYOUT
    AVChannelLayout             m_cur_ch_layout;                
#else   // !LAVU_DEP_OLD_CHANNEL_LAYOUT
    uint64_t                    m_cur_channel_layout;           
#endif  // !LAVU_DEP_OLD_CHANNEL_LAYOUT
    FFmpeg_SwrContext           m_audio_resample_ctx;           
    FFmpeg_AudioFifo            m_audio_fifo;                   
    // Video conversion and buffering
    FFmpeg_SwsContext           m_sws_ctx;                      
    AVFilterContext *           m_buffer_sink_context;          
    AVFilterContext *           m_buffer_source_context;        
    AVFilterGraph *             m_filter_graph;                 
    int64_t                     m_pts;                          
    int64_t                     m_pos;                          
    // Common things for audio/video/subtitles
    INPUTFILE                   m_in;                           
    OUTPUTFILE                  m_out;                          
    STREAM_MAP                  m_stream_map;                   
    uint32_t                    m_current_segment;              
    bool                        m_insert_keyframe;              
    // If the audio and/or video stream is copied, packets will be stuffed into the packet queue.
    bool                        m_copy_audio;                   
    bool                        m_copy_video;                   
    // Time stamps
    int64_t                     m_cur_audio_ts;                 
    int64_t                     m_cur_video_ts;                 
    const FFmpegfs_Format *     m_current_format;               
    Buffer *                    m_buffer;                       
    uint32_t                    m_reset_pts;                    
    uint32_t                    m_fake_frame_no;                
    static const std::vector<PRORES_BITRATE> m_prores_bitrate;  
    // Hardware acceleration
    static const DEVICETYPE_MAP m_devicetype_map;               
    HWACCELMODE                 m_hwaccel_enc_mode;             
    HWACCELMODE                 m_hwaccel_dec_mode;             
    bool                        m_hwaccel_enable_enc_buffering; 
    bool                        m_hwaccel_enable_dec_buffering; 
    AVBufferRef *               m_hwaccel_enc_device_ctx;       
    AVBufferRef *               m_hwaccel_dec_device_ctx;       
    AVPixelFormat               m_enc_hw_pix_fmt;               
    AVPixelFormat               m_dec_hw_pix_fmt;               
#define FFMPEGFS_AUDIO          static_cast<uint32_t>(0x0001)   
#define FFMPEGFS_VIDEO          static_cast<uint32_t>(0x0002)   
#define FFMPEGFS_SUBTITLE       static_cast<uint32_t>(0x0004)   
    uint32_t                    m_active_stream_msk;            
    uint32_t                    m_inhibit_stream_msk;           
    std::queue<FFmpeg_Packet>  m_hls_packet_fifo;              
};
 
#endif // FFMPEG_TRANSCODER_H