ffmpegfs/html/ffmpeg__transcoder_8h_source.html

/*

 * Copyright (C) 2017-2024 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_frame.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>


class Buffer;

struct SwrContext;

struct SwsContext;

struct AVFilterContext;

struct AVFilterGraph;

struct AVAudioFifo;

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(nullptr),

            m_pix_fmt(AV_PIX_FMT_NONE)

        {}


        FILETYPE                m_filetype;

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

    SwrContext *                m_audio_resample_ctx;

    AVAudioFifo *               m_audio_fifo;

    // Video conversion and buffering

    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<AVPacket*>       m_hls_packet_fifo;

};


#endif // FFMPEG_TRANSCODER_H

RESULTCODE::NONE
@ NONE
No result code available.

Buffer
The Buffer class.
Definition: buffer.h:56

FFmpeg_Base
The FFmpeg_Base class.
Definition: ffmpeg_base.h:46

FFmpeg_Frame
The FFmpeg_Frame class.
Definition: ffmpeg_frame.h:43

FFmpeg_Profiles
The FFmpeg_Profiles class.
Definition: ffmpeg_profiles.h:43

FFmpeg_Profiles::PROFILE_OPTION_VEC
std::vector< PROFILE_OPTION > PROFILE_OPTION_VEC
PROFILE_OPTION array.
Definition: ffmpeg_profiles.h:61

FFmpeg_Transcoder::StreamRef
In/output stream reference data.
Definition: ffmpeg_transcoder.h:115

FFmpeg_Transcoder::StreamRef::m_stream_idx
int m_stream_idx
Stream index in AVFormatContext.
Definition: ffmpeg_transcoder.h:134

FFmpeg_Transcoder::StreamRef::m_start_time
int64_t m_start_time
Start time of the stream in stream time base units, may be 0.
Definition: ffmpeg_transcoder.h:135

FFmpeg_Transcoder::StreamRef::m_stream
AVStream * m_stream
AVStream for this encoder stream.
Definition: ffmpeg_transcoder.h:133

FFmpeg_Transcoder::StreamRef::reset
void reset()
Close (reset) AVCodecContext pointer.
Definition: ffmpeg_transcoder.cc:210

FFmpeg_Transcoder::StreamRef::set_codec_ctx
void set_codec_ctx(AVCodecContext *codec_ctx)
Set the AVCodecContext pointer. Will be shared and deleted after the last consumer freed it.
Definition: ffmpeg_transcoder.cc:196

FFmpeg_Transcoder::StreamRef::m_codec_ctx
std::shared_ptr< AVCodecContext > m_codec_ctx
AVCodecContext for this encoder stream.
Definition: ffmpeg_transcoder.h:132

FFmpeg_Transcoder
The FFmpeg_Transcoder class.
Definition: ffmpeg_transcoder.h:76

FFmpeg_Transcoder::add_samples_to_fifo
int add_samples_to_fifo(uint8_t **converted_input_samples, int frame_size)
Add converted input audio samples to the FIFO buffer for later processing.
Definition: ffmpeg_transcoder.cc:3986

FFmpeg_Transcoder::m_current_segment
uint32_t m_current_segment
HLS only: Segment file number currently being encoded.
Definition: ffmpeg_transcoder.h:1264

FFmpeg_Transcoder::video_size
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)
Predict video file size. This may (better will surely) be inaccurate.
Definition: ffmpeg_transcoder.cc:5926

FFmpeg_Transcoder::add_subtitle_stream
int add_subtitle_stream(AVCodecID codec_id, StreamRef &input_streamref, const std::optional< std::string > &language=std::nullopt)
Add new subtitle stream to output file.
Definition: ffmpeg_transcoder.cc:2209

FFmpeg_Transcoder::HWACCELMODE
HWACCELMODE
Currently active hardware acceleration mode.
Definition: ffmpeg_transcoder.h:181

FFmpeg_Transcoder::m_hwaccel_enable_enc_buffering
bool m_hwaccel_enable_enc_buffering
Enable hardware acceleration frame buffers for encoder.
Definition: ffmpeg_transcoder.h:1288

FFmpeg_Transcoder::open_albumarts
int open_albumarts()
open_albumarts
Definition: ffmpeg_transcoder.cc:749

FFmpeg_Transcoder::m_devicetype_map
static const DEVICETYPE_MAP m_devicetype_map
List of AVPixelFormats mapped to hardware acceleration types.
Definition: ffmpeg_transcoder.h:1285

FFmpeg_Transcoder::open_output
int open_output(Buffer *buffer)
Open output file. Data will actually be written to buffer and copied by FUSE when accessed.
Definition: ffmpeg_transcoder.cc:1263

FFmpeg_Transcoder::flush_frames_all
int flush_frames_all(bool use_flush_packet)
Flush the remaining frames for all streams.
Definition: ffmpeg_transcoder.cc:4018

FFmpeg_Transcoder::stack_seek_frame
int stack_seek_frame(uint32_t frame_no)
Seek to a specific frame. Does not actually perform the seek, this is done asynchronously by the tran...
Definition: ffmpeg_transcoder.cc:6733

FFmpeg_Transcoder::get_hw_vaapi_codec_name
int get_hw_vaapi_codec_name(AVCodecID codec_id, std::string *codec_name) const
Determine VAAPI codec name.
Definition: ffmpeg_transcoder.cc:7150

FFmpeg_Transcoder::purge_audio_fifo
int purge_audio_fifo()
Purge all samples in audio FIFO.
Definition: ffmpeg_transcoder.cc:6321

FFmpeg_Transcoder::open_bestmatch_audio
int open_bestmatch_audio()
Open the best match audio stream.
Definition: ffmpeg_transcoder.cc:666

FFmpeg_Transcoder::filename
virtual const char * filename() const override
Return source filename.
Definition: ffmpeg_transcoder.cc:6497

FFmpeg_Transcoder::get_hw_omx_encoder_name
int get_hw_omx_encoder_name(AVCodecID codec_id, std::string *codec_name) const
Determine OMX encoder codec name.
Definition: ffmpeg_transcoder.cc:7385

FFmpeg_Transcoder::process_single_fr
int process_single_fr(DECODER_STATUS *status)
Definition: ffmpeg_transcoder.cc:5251

FFmpeg_Transcoder::LPCPRORES_BITRATE
PRORES_BITRATE const  * LPCPRORES_BITRATE
Pointer to const version of PRORES_BITRATE.
Definition: ffmpeg_transcoder.h:112

FFmpeg_Transcoder::m_audio_fifo
AVAudioFifo * m_audio_fifo
Audio sample FIFO.
Definition: ffmpeg_transcoder.h:1249

FFmpeg_Transcoder::can_copy_stream
bool can_copy_stream(const AVStream *stream) const
Check if stream can be copied from input to output (AUTOCOPY option).
Definition: ffmpeg_transcoder.cc:784

FFmpeg_Transcoder::input_read
static int input_read(void *opaque, unsigned char *data, int size)
Custom read function for FFmpeg.
Definition: ffmpeg_transcoder.cc:6220

FFmpeg_Transcoder::MULTIFRAME_MAP
std::multimap< int64_t, MULTIFRAME > MULTIFRAME_MAP
Audio frame/video frame/subtitle buffer.
Definition: ffmpeg_transcoder.h:188

FFmpeg_Transcoder::BUFFER_DATA
struct FFmpeg_Transcoder::BUFFER_DATA BUFFER_DATA
Buffer structure, used in FFmpeg_Transcoder::read_packet.

FFmpeg_Transcoder::purge_multiframe_map
size_t purge_multiframe_map()
Purge all frames in buffer.
Definition: ffmpeg_transcoder.cc:6335

FFmpeg_Transcoder::get_hw_mmal_decoder_name
int get_hw_mmal_decoder_name(AVCodecID codec_id, std::string *codec_name) const
Determine MMAL decoder codec name.
Definition: ffmpeg_transcoder.cc:7238

FFmpeg_Transcoder::m_hwaccel_enable_dec_buffering
bool m_hwaccel_enable_dec_buffering
Enable hardware acceleration frame buffers for decoder.
Definition: ffmpeg_transcoder.h:1289

FFmpeg_Transcoder::m_cur_sample_fmt
AVSampleFormat m_cur_sample_fmt
Currently selected audio sample format.
Definition: ffmpeg_transcoder.h:1241

FFmpeg_Transcoder::store_packet
int store_packet(AVPacket *pkt, AVMediaType mediatype)
Store packet in output stream.
Definition: ffmpeg_transcoder.cc:3612

FFmpeg_Transcoder::purge
void purge()
Purge FIFO and map buffers and report lost packets/frames/samples.
Definition: ffmpeg_transcoder.cc:6359

FFmpeg_Transcoder::add_stream_copy
int add_stream_copy(AVCodecID codec_id, AVMediaType codec_type)
Add new stream copy to output file.
Definition: ffmpeg_transcoder.cc:2349

FFmpeg_Transcoder::m_current_format
const FFmpegfs_Format * m_current_format
Currently used output format(s)
Definition: ffmpeg_transcoder.h:1275

FFmpeg_Transcoder::map_in_to_out_stream
int map_in_to_out_stream(int in_stream_idx) const
Map input stream index to output stream index.
Definition: ffmpeg_transcoder.cc:7558

FFmpeg_Transcoder::audio_size
static bool audio_size(size_t *filesize, AVCodecID codec_id, BITRATE bit_rate, int64_t duration, int channels, int sample_rate, AVSampleFormat sample_format)
Predict audio file size. This may (better will surely) be inaccurate.
Definition: ffmpeg_transcoder.cc:5734

FFmpeg_Transcoder::have_seeked
bool have_seeked() const
Check if we made a seek operation.
Definition: ffmpeg_transcoder.cc:6802

FFmpeg_Transcoder::add_external_subtitle_streams
int add_external_subtitle_streams()
Scan for external subtitle files.
Definition: ffmpeg_transcoder.cc:7778

FFmpeg_Transcoder::init_deinterlace_filters
int init_deinterlace_filters(AVCodecContext *codec_ctx, AVPixelFormat pix_fmt, const AVRational &avg_frame_rate, const AVRational &time_base)
Initialise video filters.
Definition: ffmpeg_transcoder.cc:6513

FFmpeg_Transcoder::prepare_format
int prepare_format(AVDictionary **dict, FILETYPE filetype) const
Prepare format optimisations.
Definition: ffmpeg_transcoder.cc:2925

FFmpeg_Transcoder::get_out_subtitle_stream
StreamRef * get_out_subtitle_stream(int stream_idx)
Get subtitle stream for the stream index.
Definition: ffmpeg_transcoder.cc:7533

FFmpeg_Transcoder::m_in
INPUTFILE m_in
Input file information.
Definition: ffmpeg_transcoder.h:1260

FFmpeg_Transcoder::decode_video_frame
int decode_video_frame(AVPacket *pkt, int *decoded)
Decode one video frame.
Definition: ffmpeg_transcoder.cc:3325

FFmpeg_Transcoder::decode_subtitle
int decode_subtitle(AVPacket *pkt, int *decoded)
Decode one subtitle.
Definition: ffmpeg_transcoder.cc:3542

FFmpeg_Transcoder::m_copy_video
bool m_copy_video
If true, copy video stream from source to target (just remux, no recode).
Definition: ffmpeg_transcoder.h:1269

FFmpeg_Transcoder::m_inhibit_stream_msk
uint32_t m_inhibit_stream_msk
HLS: Currently inhibited streams bit mask. Packets temporarly go to m_hls_packet_fifo and will be pre...
Definition: ffmpeg_transcoder.h:1300

FFmpeg_Transcoder::m_seek_to_fifo
std::queue< uint32_t > m_seek_to_fifo
Stack of seek requests. Will be processed FIFO.
Definition: ffmpeg_transcoder.h:1232

FFmpeg_Transcoder::get_next_segment
uint32_t get_next_segment(int64_t pos) const
Calculate next HLS segment from position.
Definition: ffmpeg_transcoder.cc:7506

FFmpeg_Transcoder::open_subtitles
int open_subtitles()
Open all subtitles streams, if present in input file and if supported by output file....
Definition: ffmpeg_transcoder.cc:705

FFmpeg_Transcoder::m_hls_packet_fifo
std::queue< AVPacket * > m_hls_packet_fifo
HLS packet FIFO.
Definition: ffmpeg_transcoder.h:1301

FFmpeg_Transcoder::open_bestmatch_video
int open_bestmatch_video()
Open the best match video stream, if present in input file.
Definition: ffmpeg_transcoder.cc:578

FFmpeg_Transcoder::find_sw_fmt_by_hw_type
static AVPixelFormat find_sw_fmt_by_hw_type(AVHWDeviceType type)
Get the software pixel format for the given hardware acceleration.
Definition: ffmpeg_transcoder.cc:7459

FFmpeg_Transcoder::send_filters
int send_filters(FFmpeg_Frame *srcframe, int &ret)
Send video frame to the filters.
Definition: ffmpeg_transcoder.cc:6655

FFmpeg_Transcoder::m_insert_keyframe
bool m_insert_keyframe
HLS only: Allow insertion of 1 keyframe.
Definition: ffmpeg_transcoder.h:1265

FFmpeg_Transcoder::init_converted_samples
int init_converted_samples(uint8_t ***converted_input_samples, int frame_size)
Initialise a temporary storage for the specified number of audio samples. The conversion requires tem...
Definition: ffmpeg_transcoder.cc:3914

FFmpeg_Transcoder::encode_finish
int encode_finish()
Definition: ffmpeg_transcoder.cc:6179

FFmpeg_Transcoder::LPPRORES_BITRATE
struct FFmpeg_Transcoder::PRORES_BITRATE * LPPRORES_BITRATE
Pointer version of PRORES_BITRATE.

FFmpeg_Transcoder::output_write
static int output_write(void *opaque, const uint8_t *data, int size)
Custom write function for FFmpeg.
Definition: ffmpeg_transcoder.cc:6248

FFmpeg_Transcoder::get_output_sample_rate
static bool get_output_sample_rate(int input_sample_rate, int max_sample_rate, int *output_sample_rate=nullptr)
Calculate output sample rate based on user option.
Definition: ffmpeg_transcoder.cc:1417

FFmpeg_Transcoder::close_input_file
bool close_input_file()
Closes the input file if open. Can safely be called again after the file was already closed or if the...
Definition: ffmpeg_transcoder.cc:6435

FFmpeg_Transcoder::STREAM_MAP
std::map< int, int > STREAM_MAP
Map input subtitle stream to output stream.
Definition: ffmpeg_transcoder.h:189

FFmpeg_Transcoder::copy_metadata
void copy_metadata(AVDictionary **metadata_out, const AVDictionary *metadata_in, bool contentstream=true)
Process the metadata in the FFmpeg file. This should be called at the beginning, before reading audio...
Definition: ffmpeg_transcoder.cc:4901

FFmpeg_Transcoder::update_codec
int update_codec(void *opt, const PROFILE_OPTION_VEC &profile_option_vec) const
Prepare codec options.
Definition: ffmpeg_transcoder.cc:1556

FFmpeg_Transcoder::flush_buffers
void flush_buffers()
Flush FFmpeg's input buffers.
Definition: ffmpeg_transcoder.cc:5034

FFmpeg_Transcoder::add_external_subtitle_stream
int add_external_subtitle_stream(const std::string &subtitle_file, const std::optional< std::string > &language)
add_external_subtitle_stream
Definition: ffmpeg_transcoder.cc:7636

FFmpeg_Transcoder::StreamRef_map
std::map< int, StreamRef > StreamRef_map
Map stream index to StreamRef.
Definition: ffmpeg_transcoder.h:138

FFmpeg_Transcoder::m_filter_graph
AVFilterGraph * m_filter_graph
Video filter graph.
Definition: ffmpeg_transcoder.h:1255

FFmpeg_Transcoder::get_aspect_ratio
bool get_aspect_ratio(int width, int height, const AVRational &sar, AVRational *ar) const
Calculate aspect ratio for width/height and sample aspect ratio (sar).
Definition: ffmpeg_transcoder.cc:1457

FFmpeg_Transcoder::get_format
enum AVPixelFormat get_format(AVCodecContext *input_codec_ctx, const enum AVPixelFormat *pix_fmts) const
Definition: ffmpeg_transcoder.cc:6813

FFmpeg_Transcoder::m_reset_pts
uint32_t m_reset_pts
We have to reset audio/video pts to the new position.
Definition: ffmpeg_transcoder.h:1279

FFmpeg_Transcoder::m_hwaccel_dec_device_ctx
AVBufferRef * m_hwaccel_dec_device_ctx
Hardware acceleration device context for decoder.
Definition: ffmpeg_transcoder.h:1291

FFmpeg_Transcoder::init_resampler
int init_resampler()
Initialize the audio resampler based on the input and output codec settings. If the input and output ...
Definition: ffmpeg_transcoder.cc:2764

FFmpeg_Transcoder::FFmpeg_Transcoder
FFmpeg_Transcoder()
Definition: ffmpeg_transcoder.cc:217

FFmpeg_Transcoder::m_buffer
Buffer * m_buffer
Pointer to cache buffer object.
Definition: ffmpeg_transcoder.h:1277

FFmpeg_Transcoder::encode_video_frame
int encode_video_frame(const AVFrame *frame, int *data_present)
Encode one frame worth of video to the output file.
Definition: ffmpeg_transcoder.cc:4451

FFmpeg_Transcoder::m_fileio
std::shared_ptr< FileIO > m_fileio
FileIO object of input file.
Definition: ffmpeg_transcoder.h:1229

FFmpeg_Transcoder::m_skip_next_frame
bool m_skip_next_frame
After seek, skip next video frame.
Definition: ffmpeg_transcoder.h:1235

FFmpeg_Transcoder::closeio
void closeio()
Close transcoder, free all ressources.
Definition: ffmpeg_transcoder.cc:6476

FFmpeg_Transcoder::read_decode_convert_and_store
int read_decode_convert_and_store(int *finished)
Read frame from source file, decode and store in FIFO.
Definition: ffmpeg_transcoder.cc:4102

FFmpeg_Transcoder::is_video
bool is_video() const
Definition: ffmpeg_transcoder.cc:277

FFmpeg_Transcoder::add_albumart_frame
int add_albumart_frame(AVStream *output_stream, AVPacket *pkt_in)
Add album art to stream.
Definition: ffmpeg_transcoder.cc:2536

FFmpeg_Transcoder::get_hw_encoder_name
int get_hw_encoder_name(AVCodecID codec_id, std::string *codec_name=nullptr) const
Get the hardware codec name as string. This is required, because e.g. the name for the software codec...
Definition: ffmpeg_transcoder.cc:7105

FFmpeg_Transcoder::video_frame_count
uint32_t video_frame_count() const
Get the number of video frames in file.
Definition: ffmpeg_transcoder.cc:6169

FFmpeg_Transcoder::is_hls
bool is_hls() const
Check for HLS format.
Definition: ffmpeg_transcoder.cc:6790

FFmpeg_Transcoder::copy_audio_to_frame_buffer
int copy_audio_to_frame_buffer(int *finished)
Copy data from audio FIFO to frame buffer. Divides WAV data into proper chunks to be fed into the enc...
Definition: ffmpeg_transcoder.cc:5187

FFmpeg_Transcoder::create_fake_aiff_header
int create_fake_aiff_header() const
Create a fake AIFF header Create a fake AIFF header. Inserts predicted file sizes to allow playback t...
Definition: ffmpeg_transcoder.cc:3051

FFmpeg_Transcoder::read_aiff_chunk
int read_aiff_chunk(Buffer *buffer, size_t *buffoffset, const char *ID, uint8_t *chunk, size_t *size) const
Read AIFF chunk.
Definition: ffmpeg_transcoder.cc:3006

FFmpeg_Transcoder::is_audio_stream
bool is_audio_stream(int stream_idx) const
Check for audio stream.
Definition: ffmpeg_transcoder.cc:7516

FFmpeg_Transcoder::m_frame_map
MULTIFRAME_MAP m_frame_map
Audio/video/subtitle frame map.
Definition: ffmpeg_transcoder.h:1238

FFmpeg_Transcoder::goto_next_segment
bool goto_next_segment(uint32_t next_segment) const
Check if segment number is next designated segment.
Definition: ffmpeg_transcoder.cc:7511

FFmpeg_Transcoder::predicted_filesize
size_t predicted_filesize() const
Try to predict the recoded file size. This may (better will surely) be inaccurate.
Definition: ffmpeg_transcoder.cc:6164

FFmpeg_Transcoder::is_video_stream
bool is_video_stream(int stream_idx) const
Check for video stream.
Definition: ffmpeg_transcoder.cc:7521

FFmpeg_Transcoder::total_overhead
static bool total_overhead(size_t *filesize, FILETYPE filetype)
Predict overhead in file size. This may (better will surely) be inaccurate.
Definition: ffmpeg_transcoder.cc:6010

FFmpeg_Transcoder::is_subtitle_stream
bool is_subtitle_stream(int stream_idx) const
Check for subtitle stream.
Definition: ffmpeg_transcoder.cc:7526

FFmpeg_Transcoder::add_albumart_stream
int add_albumart_stream(const AVCodecContext *input_codec_ctx)
Add a stream for an album art.
Definition: ffmpeg_transcoder.cc:2428

FFmpeg_Transcoder::m_pos
int64_t m_pos
Generated position.
Definition: ffmpeg_transcoder.h:1257

FFmpeg_Transcoder::m_have_seeked
bool m_have_seeked
After seek operations this is set to make sure the trancoding result is marked RESULTCODE_INCOMPLETE ...
Definition: ffmpeg_transcoder.h:1234

FFmpeg_Transcoder::get_hw_pix_fmt
AVPixelFormat get_hw_pix_fmt(const AVCodec *codec, AVHWDeviceType dev_type, bool use_device_ctx) const
Determine the hardware pixel format for the codec, if applicable.
Definition: ffmpeg_transcoder.cc:917

FFmpeg_Transcoder::flush_delayed_audio
int flush_delayed_audio()
Flush delayed audio packets, if there are any.
Definition: ffmpeg_transcoder.cc:5114

FFmpeg_Transcoder::do_seek_frame
int do_seek_frame(uint32_t frame_no)
Actually perform seek for frame. This function ensures that it is positioned at a key frame,...
Definition: ffmpeg_transcoder.cc:5046

FFmpeg_Transcoder::decode
int decode(AVCodecContext *codec_ctx, AVFrame *frame, int *got_frame, const AVPacket *pkt) const
Definition: ffmpeg_transcoder.cc:3168

FFmpeg_Transcoder::id3v1tag
const ID3v1 * id3v1tag() const
Assemble an ID3v1 file tag.
Definition: ffmpeg_transcoder.cc:6215

FFmpeg_Transcoder::calculate_predicted_filesize
size_t calculate_predicted_filesize() const
Try to predict final file size.
Definition: ffmpeg_transcoder.cc:6087

FFmpeg_Transcoder::init_audio_output_frame
int init_audio_output_frame(AVFrame *frame, int frame_size) const
Initialise one input frame for writing to the output file. The frame will be exactly frame_size sampl...
Definition: ffmpeg_transcoder.cc:4173

FFmpeg_Transcoder::encode_image_frame
int encode_image_frame(const AVFrame *frame, int *data_present)
Encode frame to image.
Definition: ffmpeg_transcoder.cc:4334

FFmpeg_Transcoder::get_prores_bitrate
static BITRATE get_prores_bitrate(int width, int height, const AVRational &framerate, bool interleaved, PRORESLEVEL profile)
Calculate the appropriate bitrate for a ProRes file given several parameters.
Definition: ffmpeg_transcoder.cc:5659

FFmpeg_Transcoder::seek
static int64_t seek(void *opaque, int64_t offset, int whence)
Custom seek function for FFmpeg.
Definition: ffmpeg_transcoder.cc:6274

FFmpeg_Transcoder::segment_count
uint32_t segment_count() const
Get the number of HLS segments of file.
Definition: ffmpeg_transcoder.cc:6174

FFmpeg_Transcoder::get_hw_v4l2m2m_encoder_name
int get_hw_v4l2m2m_encoder_name(AVCodecID codec_id, std::string *codec_name) const
Determine video for linux encoder codec name.
Definition: ffmpeg_transcoder.cc:7410

FFmpeg_Transcoder::m_is_video
bool m_is_video
true if input is a video file
Definition: ffmpeg_transcoder.h:1236

FFmpeg_Transcoder::alloc_picture
int alloc_picture(AVFrame *frame, AVPixelFormat pix_fmt, int width, int height) const
Allocate memory for one picture.
Definition: ffmpeg_transcoder.cc:3149

FFmpeg_Transcoder::m_hwaccel_enc_device_ctx
AVBufferRef * m_hwaccel_enc_device_ctx
Hardware acceleration device context for encoder.
Definition: ffmpeg_transcoder.h:1290

FFmpeg_Transcoder::m_prores_bitrate
static const std::vector< PRORES_BITRATE > m_prores_bitrate
ProRes bitrate table. Used for file size prediction.
Definition: ffmpeg_transcoder.h:1282

FFmpeg_Transcoder::prepare_codec
int prepare_codec(void *opt, FILETYPE filetype) const
Prepare codec options for a file type.
Definition: ffmpeg_transcoder.cc:1578

FFmpeg_Transcoder::add_stream_map
void add_stream_map(int in_stream_idx, int out_stream_idx)
Add entry to input stream to output stream map.
Definition: ffmpeg_transcoder.cc:7550

FFmpeg_Transcoder::decode_frame
int decode_frame(AVPacket *pkt)
Decode one frame.
Definition: ffmpeg_transcoder.cc:3745

FFmpeg_Transcoder::add_subtitle_streams
int add_subtitle_streams()
Add all subtitle streams. Already existing streams are not added again.
Definition: ffmpeg_transcoder.cc:2733

FFmpeg_Transcoder::open_output_filestreams
int open_output_filestreams(Buffer *buffer)
Open an output file and the required encoder. Also set some basic encoder parameters....
Definition: ffmpeg_transcoder.cc:2563

FFmpeg_Transcoder::m_cur_video_ts
int64_t m_cur_video_ts
If the video stream is copied and the time stamps are absent from the input stream,...
Definition: ffmpeg_transcoder.h:1273

FFmpeg_Transcoder::stream_exists
bool stream_exists(int stream_idx) const
Check if stream exists.
Definition: ffmpeg_transcoder.cc:7545

FFmpeg_Transcoder::MULTIFRAME
std::variant< FFmpeg_Frame, FFmpeg_Subtitle > MULTIFRAME
Combined audio/videoframe and subtitle.
Definition: ffmpeg_transcoder.h:187

FFmpeg_Transcoder::is_multiformat
bool is_multiformat() const
Check for an export frame format.
Definition: ffmpeg_transcoder.cc:6765

FFmpeg_Transcoder::m_hwaccel_dec_mode
HWACCELMODE m_hwaccel_dec_mode
Current hardware acceleration mode for decoder.
Definition: ffmpeg_transcoder.h:1287

FFmpeg_Transcoder::skip_decoded_frames
int skip_decoded_frames(uint32_t frame_no, bool forced_seek)
Skip decoded frames or force seek to frame_no.
Definition: ffmpeg_transcoder.cc:5067

FFmpeg_Transcoder::m_stream_map
STREAM_MAP m_stream_map
Input stream to output stream map.
Definition: ffmpeg_transcoder.h:1262

FFmpeg_Transcoder::create_audio_frame
int create_audio_frame(int frame_size)
Load one audio frame from the FIFO buffer and store in frame buffer.
Definition: ffmpeg_transcoder.cc:4787

FFmpeg_Transcoder::write_output_file_header
int write_output_file_header()
Write the header of the output file container.
Definition: ffmpeg_transcoder.cc:3110

FFmpeg_Transcoder::hwdevice_ctx_create
int hwdevice_ctx_create(AVBufferRef **hwaccel_enc_device_ctx, AVHWDeviceType dev_type, const std::string &device) const
Definition: ffmpeg_transcoder.cc:6837

FFmpeg_Transcoder::virtname
virtual const char * virtname() const override
Return virtual filename. Same as destination filename, but with virtual (mount) path....
Definition: ffmpeg_transcoder.cc:6507

FFmpeg_Transcoder::free_filters
void free_filters()
Free filter sinks.
Definition: ffmpeg_transcoder.cc:6712

FFmpeg_Transcoder::PRORES_BITRATE
struct FFmpeg_Transcoder::PRORES_BITRATE PRORES_BITRATE
Predicted bitrates for Apple Prores, see https://www.apple.com/final-cut-pro/docs/Apple_ProRes_White_...

FFmpeg_Transcoder::destname
virtual const char * destname() const override
Return destination filename.
Definition: ffmpeg_transcoder.cc:6502

FFmpeg_Transcoder::m_fake_frame_no
uint32_t m_fake_frame_no
The MJEPG codec requires monotonically growing PTS values so we fake some to avoid them going backwar...
Definition: ffmpeg_transcoder.h:1280

FFmpeg_Transcoder::read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
FFmpeg_Transcoder::read_packet.
Definition: ffmpeg_transcoder.cc:7618

FFmpeg_Transcoder::flush_frames_single
int flush_frames_single(int stream_idx, bool use_flush_packet)
Flush the remaining frames.
Definition: ffmpeg_transcoder.cc:4043

FFmpeg_Transcoder::m_buffer_sink_context
AVFilterContext * m_buffer_sink_context
Video filter sink context.
Definition: ffmpeg_transcoder.h:1253

FFmpeg_Transcoder::open_decoder
int open_decoder(AVFormatContext *format_ctx, AVCodecContext **codec_ctx, int stream_idx, const AVCodec *input_codec, AVMediaType mediatype)
Open codec context for stream_idx.
Definition: ffmpeg_transcoder.cc:950

FFmpeg_Transcoder::write_output_file_trailer
int write_output_file_trailer()
Write the trailer of the output file container.
Definition: ffmpeg_transcoder.cc:4863

FFmpeg_Transcoder::create_fake_wav_header
int create_fake_wav_header() const
Create a fake WAV header Create a fake WAV header. Inserts predicted file sizes to allow playback to ...
Definition: ffmpeg_transcoder.cc:2948

FFmpeg_Transcoder::close_resample
bool close_resample()
Close and free the resampler context.
Definition: ffmpeg_transcoder.cc:6309

FFmpeg_Transcoder::process_albumarts
int process_albumarts()
Copy all album arts from source to target.
Definition: ffmpeg_transcoder.cc:5011

FFmpeg_Transcoder::get_hw_decoder_name
int get_hw_decoder_name(AVCodecID codec_id, std::string *codec_name=nullptr) const
Get the hardware codec name as string. This is required, because e.g. the name for the software codec...
Definition: ffmpeg_transcoder.cc:7060

FFmpeg_Transcoder::m_pts
int64_t m_pts
Generated PTS.
Definition: ffmpeg_transcoder.h:1256

FFmpeg_Transcoder::decode_audio_frame
int decode_audio_frame(AVPacket *pkt, int *decoded)
Decode one audio frame.
Definition: ffmpeg_transcoder.cc:3222

FFmpeg_Transcoder::m_enc_hw_pix_fmt
AVPixelFormat m_enc_hw_pix_fmt
Requested encoder hardware pixel format.
Definition: ffmpeg_transcoder.h:1292

FFmpeg_Transcoder::m_out
OUTPUTFILE m_out
Output file information.
Definition: ffmpeg_transcoder.h:1261

FFmpeg_Transcoder::m_cur_audio_ts
int64_t m_cur_audio_ts
If the audio stream is copied and the time stamps are absent from the input stream,...
Definition: ffmpeg_transcoder.h:1272

FFmpeg_Transcoder::m_last_seek_frame_no
std::atomic_uint32_t m_last_seek_frame_no
If not 0, this is the last frame that we seeked to. Video sources only.
Definition: ffmpeg_transcoder.h:1233

FFmpeg_Transcoder::m_dec_hw_pix_fmt
AVPixelFormat m_dec_hw_pix_fmt
Requested decoder hardware pixel format.
Definition: ffmpeg_transcoder.h:1293

FFmpeg_Transcoder::last_seek_frame_no
uint32_t last_seek_frame_no() const
Current seek frame if available.
Definition: ffmpeg_transcoder.cc:7851

FFmpeg_Transcoder::flush_delayed_subtitles
int flush_delayed_subtitles()
Flush delayed subtitle packets, if there are any.
Definition: ffmpeg_transcoder.cc:5182

FFmpeg_Transcoder::is_open
bool is_open() const
Definition: ffmpeg_transcoder.cc:289

FFmpeg_Transcoder::m_cur_ch_layout
AVChannelLayout m_cur_ch_layout
Currently selected audio channel layout.
Definition: ffmpeg_transcoder.h:1244

FFmpeg_Transcoder::process_metadata
int process_metadata()
Copy metadata from source to target.
Definition: ffmpeg_transcoder.cc:4959

FFmpeg_Transcoder::init_rescaler
int init_rescaler(AVPixelFormat in_pix_fmt, int in_width, int in_height, AVPixelFormat out_pix_fmt, int out_width, int out_height)
Init image size rescaler and pixel format converter.
Definition: ffmpeg_transcoder.cc:1594

FFmpeg_Transcoder::tagcpy
const char * tagcpy(char(&out)[size], const std::string &in) const
Safely copy a tag to a target buffer. If the input buffer size is larger than output the data will be...
Definition: ffmpeg_transcoder.cc:4883

FFmpeg_Transcoder::hwframe_copy_to_hw
int hwframe_copy_to_hw(AVCodecContext *output_codec_ctx, FFmpeg_Frame *hw_frame, const AVFrame *sw_frame) const
Definition: ffmpeg_transcoder.cc:7014

FFmpeg_Transcoder::hwframe_ctx_set
int hwframe_ctx_set(AVCodecContext *output_codec_ctx, AVCodecContext *input_codec_ctx, AVBufferRef *hw_device_ctx) const
Adds a reference to an existing decoder hardware frame context or allocates a new AVHWFramesContext t...
Definition: ffmpeg_transcoder.cc:6888

FFmpeg_Transcoder::open_output_file
int open_output_file(Buffer *buffer)
Open output file. Data will actually be written to buffer and copied by FUSE when accessed.
Definition: ffmpeg_transcoder.cc:856

FFmpeg_Transcoder::open_bestmatch_decoder
int open_bestmatch_decoder(AVFormatContext *format_ctx, AVCodecContext **codec_ctx, int *stream_idx, AVMediaType type)
Find best match stream and open codec context for it.
Definition: ffmpeg_transcoder.cc:889

FFmpeg_Transcoder::mtime
time_t mtime() const
Get last modification time of file.
Definition: ffmpeg_transcoder.cc:4877

FFmpeg_Transcoder::close_output_file
bool close_output_file()
Closes the output file if open and reports lost packets. Can safely be called again after the file wa...
Definition: ffmpeg_transcoder.cc:6392

FFmpeg_Transcoder::get_format_static
static enum AVPixelFormat get_format_static(AVCodecContext *input_codec_ctx, const enum AVPixelFormat *pix_fmts)
Definition: ffmpeg_transcoder.cc:6807

FFmpeg_Transcoder::DEVICETYPE_MAP
std::map< AVHWDeviceType, AVPixelFormat > DEVICETYPE_MAP
Map device types to pixel formats.
Definition: ffmpeg_transcoder.h:178

FFmpeg_Transcoder::duration
int64_t duration() const
Get the file duration.
Definition: ffmpeg_transcoder.cc:6159

FFmpeg_Transcoder::purge_hls_fifo
size_t purge_hls_fifo()
Purge all packets in HLS FIFO buffer.
Definition: ffmpeg_transcoder.cc:6344

FFmpeg_Transcoder::init_audio_fifo
int init_audio_fifo()
Initialise a FIFO buffer for the audio samples to be encoded.
Definition: ffmpeg_transcoder.cc:2884

FFmpeg_Transcoder::is_frameset
bool is_frameset() const
Check for an export frame format.
Definition: ffmpeg_transcoder.cc:6778

FFmpeg_Transcoder::process_output
int process_output()
Process headers of output file Write file header, process meta data and add album arts.
Definition: ffmpeg_transcoder.cc:1396

FFmpeg_Transcoder::start_new_segment
int start_new_segment()
HLS only: start a new HLS segment.
Definition: ffmpeg_transcoder.cc:5528

FFmpeg_Transcoder::m_buffer_source_context
AVFilterContext * m_buffer_source_context
Video filter source context.
Definition: ffmpeg_transcoder.h:1254

FFmpeg_Transcoder::convert_samples
int convert_samples(uint8_t **input_data, int in_samples, uint8_t **converted_data, int *out_samples)
Convert the input audio samples into the output sample format. The conversion happens on a per-frame ...
Definition: ffmpeg_transcoder.cc:3946

FFmpeg_Transcoder::pts
int64_t pts() const
Get PTS (presentation time stamp) of decoded audio/video so far.
Definition: ffmpeg_transcoder.cc:7837

FFmpeg_Transcoder::m_seek_to_fifo_mutex
std::recursive_mutex m_seek_to_fifo_mutex
Access mutex for seek FIFO.
Definition: ffmpeg_transcoder.h:1231

FFmpeg_Transcoder::flush_delayed_video
int flush_delayed_video()
Flush delayed video packets, if there are any.
Definition: ffmpeg_transcoder.cc:5144

FFmpeg_Transcoder::hwdevice_ctx_add_ref
int hwdevice_ctx_add_ref(AVCodecContext *input_codec_ctx)
Add reference to hardware device context.
Definition: ffmpeg_transcoder.cc:6856

FFmpeg_Transcoder::m_cur_sample_rate
int m_cur_sample_rate
Currently selected audio sample rate.
Definition: ffmpeg_transcoder.h:1242

FFmpeg_Transcoder::update_format
int update_format(AVDictionary **dict, const PROFILE_OPTION_VEC &option_vec) const
Update format options.
Definition: ffmpeg_transcoder.cc:2896

FFmpeg_Transcoder::m_audio_resample_ctx
SwrContext * m_audio_resample_ctx
SwResample context for audio resampling.
Definition: ffmpeg_transcoder.h:1248

FFmpeg_Transcoder::m_copy_audio
bool m_copy_audio
If true, copy audio stream from source to target (just remux, no recode).
Definition: ffmpeg_transcoder.h:1268

FFmpeg_Transcoder::open_input_file
int open_input_file(LPVIRTUALFILE virtualfile, std::shared_ptr< FileIO > fio=nullptr)
Definition: ffmpeg_transcoder.cc:294

FFmpeg_Transcoder::make_pts
void make_pts(AVPacket *pkt, int64_t *cur_ts) const
Create PTS/DTS and update the packet. If the update packet lacks time stamps, create a fictitious PTS...
Definition: ffmpeg_transcoder.cc:3718

FFmpeg_Transcoder::stack_seek_segment
int stack_seek_segment(uint32_t segment_no)
Seek to a specific HLS segment. Does not actually perform the seek, this is done asynchronously by th...
Definition: ffmpeg_transcoder.cc:6749

FFmpeg_Transcoder::m_sws_ctx
SwsContext * m_sws_ctx
Context for video filtering.
Definition: ffmpeg_transcoder.h:1252

FFmpeg_Transcoder::m_mtime
time_t m_mtime
Modified time of input file.
Definition: ffmpeg_transcoder.h:1230

FFmpeg_Transcoder::produce_audio_dts
void produce_audio_dts(AVPacket *pkt)
Produce audio dts/pts. This is required because the target codec usually has a different frame size t...
Definition: ffmpeg_transcoder.cc:4212

FFmpeg_Transcoder::hwframe_copy_from_hw
int hwframe_copy_from_hw(AVCodecContext *output_codec_ctx, FFmpeg_Frame *sw_frame, const AVFrame *hw_frame) const
Definition: ffmpeg_transcoder.cc:6993

FFmpeg_Transcoder::foreach_subtitle_file
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)
foreach_subititle_file
Definition: ffmpeg_transcoder.cc:7570

FFmpeg_Transcoder::m_active_stream_msk
uint32_t m_active_stream_msk
HLS: Currently active streams bit mask. Set FFMPEGFS_AUDIO and/or FFMPEGFS_VIDEO.
Definition: ffmpeg_transcoder.h:1299

FFmpeg_Transcoder::~FFmpeg_Transcoder
virtual ~FFmpeg_Transcoder()
Definition: ffmpeg_transcoder.cc:269

FFmpeg_Transcoder::get_output_bit_rate
static bool get_output_bit_rate(BITRATE input_bit_rate, BITRATE max_bit_rate, BITRATE *output_bit_rate=nullptr)
Calculate output bit rate based on user option.
Definition: ffmpeg_transcoder.cc:1437

FFmpeg_Transcoder::get_pix_formats
void get_pix_formats(AVPixelFormat *in_pix_fmt, AVPixelFormat *out_pix_fmt, AVCodecContext *output_codec_ctx=nullptr) const
Get correct input and output pixel format.
Definition: ffmpeg_transcoder.cc:7471

FFmpeg_Transcoder::seek_frame
int seek_frame()
Frame sets only: perform seek to a certain frame.
Definition: ffmpeg_transcoder.cc:5474

FFmpeg_Transcoder::m_hwaccel_enc_mode
HWACCELMODE m_hwaccel_enc_mode
Current hardware acceleration mode for encoder.
Definition: ffmpeg_transcoder.h:1286

FFmpeg_Transcoder::hwdevice_ctx_free
void hwdevice_ctx_free(AVBufferRef **hwaccel_device_ctx)
Free (remove reference) to hardware device context.
Definition: ffmpeg_transcoder.cc:6879

FFmpeg_Transcoder::get_video_size
bool get_video_size(int *output_width, int *output_height) const
Get the size of the output video based on user selection and apsect ratio.
Definition: ffmpeg_transcoder.cc:1501

FFmpeg_Transcoder::add_stream
int add_stream(AVCodecID codec_id)
Add new stream to output file.
Definition: ffmpeg_transcoder.cc:1631

FFmpeg_Transcoder::encode_subtitle
int encode_subtitle(const AVSubtitle *sub, int out_stream_idx, int *data_present)
Encode one subtitle frame to the output file.
Definition: ffmpeg_transcoder.cc:4649

FFmpeg_Transcoder::encode_audio_frame
int encode_audio_frame(const AVFrame *frame, int *data_present)
Create one frame worth of audio to the output file.
Definition: ffmpeg_transcoder.cc:4256

FFmpegfs_Format
The FFmpegfs_Format class.
Definition: ffmpeg_utils.h:388

ffmpeg_base.h
FFmpeg transcoder base.

ffmpeg_frame.h
FFmpeg AVFrame extension.

ffmpeg_profiles.h
FFmpeg encoder profiles.

ffmpeg_subtitle.h
FFmpeg AVSubtitle extension.

MAX_PRORES_FRAMERATE
#define MAX_PRORES_FRAMERATE
Number of selectable fram rates.
Definition: ffmpeg_transcoder.h:87

LPCDECODER_STATUS
DECODER_STATUS const  * LPCDECODER_STATUS
Pointer to const version of DECODER_STATUS.
Definition: ffmpeg_transcoder.h:70

LPDECODER_STATUS
DECODER_STATUS * LPDECODER_STATUS
Pointer version of DECODER_STATUS.
Definition: ffmpeg_transcoder.h:69

DECODER_STATUS
DECODER_STATUS
Decoder status codes. Can be error, success or end of file.
Definition: ffmpeg_transcoder.h:64

DECODER_STATUS::DEC_ERROR
@ DEC_ERROR
Decoder error, see return code.

DECODER_STATUS::DEC_EOF
@ DEC_EOF
Read to end of file.

DECODER_STATUS::DEC_SUCCESS
@ DEC_SUCCESS
Frame decoded successfully.

PRORESLEVEL
PRORESLEVEL
Definition: ffmpeg_utils.h:210

BITRATE
#define BITRATE
For FFmpeg bit rate is an int.
Definition: ffmpeg_utils.h:145

FILETYPE
FILETYPE
Definition: ffmpeg_utils.h:154

fileio.h
FileIO class.

id3v1tag.h
ID3v1 tag structure

FFmpeg_Transcoder::BUFFER_DATA
Buffer structure, used in FFmpeg_Transcoder::read_packet.
Definition: ffmpeg_transcoder.h:82

FFmpeg_Transcoder::BUFFER_DATA::size
size_t size
Size left in the buffer.
Definition: ffmpeg_transcoder.h:84

FFmpeg_Transcoder::BUFFER_DATA::ptr
uint8_t * ptr
Pointer to buffer.
Definition: ffmpeg_transcoder.h:83

FFmpeg_Transcoder::INPUTFILE
Input file definition.
Definition: ffmpeg_transcoder.h:141

FFmpeg_Transcoder::INPUTFILE::m_format_ctx
AVFormatContext * m_format_ctx
Output format context.
Definition: ffmpeg_transcoder.h:150

FFmpeg_Transcoder::INPUTFILE::m_subtitle
StreamRef_map m_subtitle
Subtitle stream information.
Definition: ffmpeg_transcoder.h:155

FFmpeg_Transcoder::INPUTFILE::m_pix_fmt
AVPixelFormat m_pix_fmt
Video stream pixel format.
Definition: ffmpeg_transcoder.h:154

FFmpeg_Transcoder::INPUTFILE::m_album_art
std::vector< StreamRef > m_album_art
Album art stream.
Definition: ffmpeg_transcoder.h:157

FFmpeg_Transcoder::INPUTFILE::m_audio
StreamRef m_audio
Audio stream information.
Definition: ffmpeg_transcoder.h:152

FFmpeg_Transcoder::INPUTFILE::m_video
StreamRef m_video
Video stream information.
Definition: ffmpeg_transcoder.h:153

FFmpeg_Transcoder::INPUTFILE::m_filetype
FILETYPE m_filetype
File type, MP3, MP4, OPUS etc.
Definition: ffmpeg_transcoder.h:148

FFmpeg_Transcoder::OUTPUTFILE
Output file definition.
Definition: ffmpeg_transcoder.h:162

FFmpeg_Transcoder::OUTPUTFILE::m_video_pts
int64_t m_video_pts
Global timestamp for the video frames in output video stream time base units
Definition: ffmpeg_transcoder.h:172

FFmpeg_Transcoder::OUTPUTFILE::m_id3v1
ID3v1 m_id3v1
mp3 only, can be referenced at any time
Definition: ffmpeg_transcoder.h:175

FFmpeg_Transcoder::OUTPUTFILE::m_audio_pts
int64_t m_audio_pts
Global timestamp for the audio frames in output audio stream time base units
Definition: ffmpeg_transcoder.h:171

FFmpeg_Transcoder::OUTPUTFILE::m_last_mux_dts
int64_t m_last_mux_dts
Last muxed DTS.
Definition: ffmpeg_transcoder.h:173

FFmpeg_Transcoder::PRORES_BITRATE::PRORES_FRAMERATE
List of ProRes frame rates.
Definition: ffmpeg_transcoder.h:97

FFmpeg_Transcoder::PRORES_BITRATE::PRORES_FRAMERATE::m_interleaved
bool m_interleaved
Format is interleaved.
Definition: ffmpeg_transcoder.h:99

FFmpeg_Transcoder::PRORES_BITRATE::PRORES_FRAMERATE::m_framerate
int m_framerate
Frame rate.
Definition: ffmpeg_transcoder.h:98

FFmpeg_Transcoder::PRORES_BITRATE
Predicted bitrates for Apple Prores, see https://www.apple.com/final-cut-pro/docs/Apple_ProRes_White_...
Definition: ffmpeg_transcoder.h:93

FFmpeg_Transcoder::PRORES_BITRATE::m_framerate
struct FFmpeg_Transcoder::PRORES_BITRATE::PRORES_FRAMERATE m_framerate[MAX_PRORES_FRAMERATE]
Array of frame rates.

FFmpeg_Transcoder::PRORES_BITRATE::m_height
int m_height
Resolution: height.
Definition: ffmpeg_transcoder.h:95

FFmpeg_Transcoder::PRORES_BITRATE::m_bitrate
std::array< int, 6 > m_bitrate
Bitrates for this format.
Definition: ffmpeg_transcoder.h:110

FFmpeg_Transcoder::PRORES_BITRATE::m_width
int m_width
Resolution: width.
Definition: ffmpeg_transcoder.h:94

ID3v1
ID3 version 1 tag
Definition: id3v1tag.h:42

VIRTUALFILE
Virtual file definition.
Definition: fileio.h:123