ffmpeg_utils.h

Go to the documentation of this file.

/*
 * 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_UTILS_H
#define FFMPEG_UTILS_H
 
#pragma once
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#if !defined(EXTRA_VERSION)
#define FFMPEFS_VERSION     PACKAGE_VERSION                     
#else
#define FFMPEFS_VERSION     PACKAGE_VERSION "-" EXTRA_VERSION   
#endif
 
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1                                  
#endif // !__STDC_FORMAT_MACROS
 
#include "ffmpeg_compat.h"
 
#include <string>
#include <vector>
#include <regex>
#include <set>
#include <array>
#include <iterator>
 
#ifndef PATH_MAX
#include <climits>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
// Disable annoying warnings outside our code
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <libavformat/avformat.h>
#pragma GCC diagnostic pop
#ifdef __cplusplus
}
#endif
 
#define INVALID_STREAM  -1              
#ifndef LIBAVUTIL_VERSION_MICRO
#error "LIBAVUTIL_VERSION_MICRO not defined. Missing include header?"
#endif
 
#define HAVE_AV_FORMAT_INJECT_GLOBAL_SIDE_DATA  (LIBAVFORMAT_VERSION_MICRO >= 100 && LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 64, 101))
 
#define HAVE_MEDIA_TYPE_STRING                  (LIBAVUTIL_VERSION_MICRO >= 100 && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 34, 101))
#if HAVE_MEDIA_TYPE_STRING
#define get_media_type_string                   av_get_media_type_string
#else
const char *get_media_type_string(enum AVMediaType media_type);
#endif
 
#define HAVE_VULKAN_HWACCEL                     (LIBAVUTIL_VERSION_MICRO >= 100 && LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(56, 39, 100))
 
#ifndef AV_ROUND_PASS_MINMAX
#define AV_ROUND_PASS_MINMAX                0
#endif
 
// These once had a different name
#if !defined(AV_CODEC_CAP_TRUNCATED) && defined(CODEC_CAP_TRUNCATED)
#define AV_CODEC_CAP_TRUNCATED                  CODEC_CAP_TRUNCATED                     
#endif
 
#if !defined(AV_CODEC_FLAG_TRUNCATED) && defined(CODEC_FLAG_TRUNCATED)
#define AV_CODEC_FLAG_TRUNCATED                 CODEC_FLAG_TRUNCATED                    
#endif
 
#ifndef AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER             CODEC_FLAG_GLOBAL_HEADER                
#endif
 
#ifndef FF_INPUT_BUFFER_PADDING_SIZE
#define FF_INPUT_BUFFER_PADDING_SIZE            256                                     
#endif
 
#ifndef AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE        CODEC_CAP_VARIABLE_FRAME_SIZE           
#endif
 
#if (LIBAVUTIL_VERSION_MAJOR > 54)
#define BITRATE int64_t                                                             
#else
#define BITRATE int                                                                 
#endif
 
#define SAFE_VALUE(p, v, d)     (((p) != nullptr) ? (p)->v : d)                     
enum class FILETYPE
{
    UNKNOWN,
    MP3,
    MP4,
    WAV,
    OGG,
    WEBM,
    MOV,
    AIFF,
    OPUS,
    PRORES,
    ALAC,
    PNG,
    JPG,
    BMP,
    TS,
    HLS,
    FLAC,
    MKV,
};
 
enum class PROFILE
{
    INVALID = -1,                       
    DEFAULT = 0,                        
    // MP4
    MP4_FF = 1,                         
    MP4_EDGE,                           
    MP4_IE,                             
    MP4_CHROME,                         
    MP4_SAFARI,                         
    MP4_OPERA,                          
    MP4_MAXTHON,                        
    // HLS/ts
    HLS_DEFAULT = DEFAULT,      
    // mov
    MOV_DEFAULT = DEFAULT,      
    // MOV/ProRes
    PRORES_DEFAULT = DEFAULT,   
    // MOV/ProRes
    ALAC_DEFAULT = DEFAULT,     
    // WebM
    WEBM_DEFAULT = DEFAULT,     
};
 
enum class PRORESLEVEL
{
    NONE = -1,          
    // Prores profiles
    PRORES_PROXY = 0,   
    PRORES_LT,          
    PRORES_STANDARD,    
    PRORES_HQ,          
};
 
enum class AUTOCOPY
{
    OFF = 0,      
    MATCH,        
    MATCHLIMIT,   
    STRICT,       
    STRICTLIMIT,  
};
 
enum class RECODESAME
{
    NO = 0,     
    YES,        
};
 
enum class SAMPLE_FMT
{
    FMT_DONTCARE = -1,   
    FMT_8,               
    FMT_16,              
    FMT_24,              
    FMT_32,              
    FMT_64,              
    FMT_F16,             
    FMT_F24,             
    FMT_F32,             
    FMT_F64              
};
 
struct Format_Options
{
    friend class FFmpegfs_Format;
 
    typedef std::vector<AVCodecID>  CODEC_VECT; 
    typedef struct _tagFORMAT
    {
        CODEC_VECT      m_video_codec;          
        CODEC_VECT      m_audio_codec;          
        CODEC_VECT      m_subtitle_codec;       
        AVSampleFormat  m_sample_format;        
    } FORMAT;
 
    typedef std::map<SAMPLE_FMT, const FORMAT> FORMAT_MAP;   
public:
    Format_Options();
 
    Format_Options(std::string format_name,
            std::string fileext,
            FORMAT_MAP format,
            bool albumart_supported
            );
 
    const std::string & format_name() const;
 
    const std::string & fileext() const;
 
    AVCodecID           video_codec() const;
    bool                is_video_codec_supported(AVCodecID codec_id) const;
    std::string         video_codec_list() const;
 
    AVCodecID           audio_codec() const;
    bool                is_audio_codec_supported(AVCodecID codec_id) const;
    std::string         audio_codec_list() const;
 
    AVSampleFormat      sample_format() const;
    bool                is_sample_fmt_supported() const;
    std::string         sample_fmt_list() const;
 
    AVCodecID           subtitle_codec(AVCodecID codec_id) const;
 
protected:
    std::string     m_format_name;
    std::string     m_fileext;              
    FORMAT_MAP      m_format_map;           
    bool            m_albumart_supported;   
};
 
class FFmpegfs_Format
{
    typedef std::map<FILETYPE, const Format_Options> OPTIONS_MAP;   
public:
    FFmpegfs_Format();
 
    bool                init(const std::string & desttype);
    const std::string & format_name() const;
    const std::string & desttype() const;
    const std::string & fileext() const;
    FILETYPE            filetype() const;
 
    AVCodecID           video_codec() const;
    bool                is_video_codec_supported(AVCodecID codec_id) const;
    std::string         video_codec_list() const;
 
    AVCodecID           audio_codec() const;
    bool                is_audio_codec_supported(AVCodecID codec_id) const;
    std::string         audio_codec_list() const;
 
    AVSampleFormat      sample_format() const;
    bool                is_sample_fmt_supported() const;
    std::string         sample_fmt_list() const;
 
    AVCodecID           subtitle_codec(AVCodecID codec_id) const;
 
    bool                is_multiformat() const;
    bool                is_frameset() const;
    bool                is_hls() const;
    bool                albumart_supported() const;
 
protected:
    const Format_Options        m_empty_options;    
    const Format_Options *      m_cur_opts;         
    static const OPTIONS_MAP    m_options_map;      
    std::string                 m_desttype;         
    FILETYPE                    m_filetype;         
};
 
typedef enum _tagFORMAT // Cannot use enum class, won't work as array index
{
    VIDEO,                                                      
    AUDIO                                                       
} FORMAT;
 
typedef std::array<FFmpegfs_Format, 2> FFMPEGFS_FORMAT_ARR;     
const std::string & append_sep(std::string * path);
const std::string & append_filename(std::string * path, const std::string & filename);
const std::string & remove_sep(std::string * path);
const std::string & remove_filename(std::string *filepath);
const std::string & remove_path(std::string *filepath);
const std::string & remove_ext(std::string *filepath);
bool                find_ext(std::string * ext, const std::string & filename);
bool                check_ext(const std::string & ext, const std::string & filename);
const std::string & replace_ext(std::string * filepath, const std::string & ext);
const std::string & append_ext(std::string * filepath, const std::string & ext);
std::shared_ptr<char[]> new_strdup(const std::string & str);
std::string         ffmpeg_geterror(int errnum);
 
int64_t             ffmpeg_rescale_q(int64_t ts, const AVRational & timebase_in, const AVRational & timebase_out = av_get_time_base_q());
int64_t             ffmpeg_rescale_q_rnd(int64_t ts, const AVRational & timebase_in, const AVRational & timebase_out = av_get_time_base_q());
std::string         format_number(int64_t value);
std::string         format_bitrate(BITRATE value);
std::string         format_samplerate(int value);
std::string         format_duration(int64_t value, uint32_t fracs = 3);
std::string         format_time(time_t value);
std::string         format_size(uint64_t value);
std::string         format_size_ex(uint64_t value);
std::string         format_result_size(size_t size_resulting, size_t size_predicted);
std::string         format_result_size_ex(size_t size_resulting, size_t size_predicted);
void                exepath(std::string *path);
std::string &       ltrim(std::string &s);
std::string &       rtrim(std::string &s);
std::string &       trim(std::string &s);
std::string         replace_all(std::string str, const std::string& from, const std::string& to);
std::string         replace_all(std::string * str, const std::string& from, const std::string& to = "");
bool                replace_start(std::string *str, const std::string& from, const std::string& to = "");
template<typename ... Args>
const std::string & strsprintf(std::string *str, const std::string & format, Args ... args)
{
    size_t size = static_cast<size_t>(snprintf(nullptr, 0, format.c_str(), args ...)) + 1; // Extra space for '\0'
    std::unique_ptr<char[]> buf(new(std::nothrow) char[size]);
    std::snprintf(buf.get(), size, format.c_str(), args ...);
    str->clear();
    str->insert(0, buf.get(), size - 1); // We don't want the '\0' inside
    return *str;
}
int                 strcasecmp(const std::string & s1, const std::string & s2);
void                make_upper(std::string * input);
void                make_lower(std::string * input);
std::string         ffmpeg_libinfo();
int                 show_caps(int device_only);
const char *        get_codec_name(AVCodecID codec_id, bool long_name = false);
int                 supports_albumart(FILETYPE filetype);
FILETYPE            get_filetype(const std::string & desttype);
std::string         get_filetype_text(FILETYPE filetype);
FILETYPE            get_filetype_from_list(const std::string & desttypelist);
int                 print_stream_info(const AVStream* stream);
std::string         fourcc_make_string(std::string * buf, uint32_t fourcc);
int                 reg_compare(const std::string &value, const std::string &pattern, std::regex::flag_type flag = std::regex::ECMAScript);
const std::string & expand_path(std::string *tgt, const std::string &src);
int                 is_mount(const std::string & path);
int                 mktree(const std::string & path, mode_t mode);
void                tempdir(std::string & path);
 
std::vector<std::string> split(const std::string& input, const std::string & regex);
 
template <typename T, std::size_t N>
constexpr std::size_t countof(T const (&)[N]) noexcept
{
    return N;
}
 
std::string         sanitise_filepath(const std::string & filepath);
std::string         sanitise_filepath(std::string * filepath);
 
void                 append_basepath(std::string *origpath, const char* path);
 
bool                is_album_art(AVCodecID codec_id, const AVRational *frame_rate = nullptr);
 
int                 nocasecompare(const std::string & lhs, const std::string &rhs);
 
struct comp
{
    bool operator() (const std::string& lhs, const std::string& rhs) const
    {
        return (nocasecompare(lhs, rhs) < 0);
    }
};
 
size_t              get_disk_free(std::string & path);
 
bool                check_ignore(size_t size, size_t offset);
 
std::string         make_filename(uint32_t file_no, const std::string &fileext);
 
bool                file_exists(const std::string & filename);
 
const char *        hwdevice_get_type_name(AVHWDeviceType dev_type);
 
enum class ENCODING
{
    ASCII          = -1,       
    UTF8_BOM       = -2,       
    UTF16LE_BOM    = -3,       
    UTF16BE_BOM    = -4,       
    UTF32LE_BOM    = -5,       
    UTF32BE_BOM    = -6,       
};
 
int                 to_utf8(std::string & text, const std::string & encoding);
int                 get_encoding (const char * str, std::string & encoding);
int                 read_file(const std::string & path, std::string & result);
 
void                stat_set_size(struct stat *st, size_t size);
 
bool                detect_docker();
 
template <typename T>
typename std::map<const std::string, const T, comp>::const_iterator search_by_value(const std::map<const std::string, const T, comp> & mapOfWords, T value)
{
    typename std::map<const std::string, const T, comp>::const_iterator it = mapOfWords.cbegin();
    while (it != mapOfWords.cend())
    {
        if (it->second == value)
        {
            return it;
        }
        ++it;
    }
    return mapOfWords.cend();
}
 
bool                is_text_codec(AVCodecID codec_id);
 
int                 get_audio_props(AVFormatContext *format_ctx, int *channels, int *samplerate);
 
const std::string & regex_escape(std::string *str);
 
bool                is_selected(const std::string & ext);
bool                is_blocked(const std::string & filename);
 
typedef std::vector<std::string> MATCHVEC;                     
template<class T>
std::string implode(const T &s)
{
    std::ostringstream stream;
    std::copy(s.begin(), s.end(), std::ostream_iterator<std::string>(stream, ","));
    std::string str(stream.str());
    // Remove trailing ,
    if (str.size())
    {
        str.pop_back();
    }
    return str;
}
 
template<class T>
void save_delete(T **p)
{
    T * tmp = __atomic_exchange_n(p, nullptr, __ATOMIC_RELEASE);
    if (tmp != nullptr)
    {
        delete tmp;
    }
}
 
void save_free(void **p);
 
void mssleep(int milliseconds);
void ussleep(int microseconds);
void nssleep(int nanoseconds);
 
#endif