ffmpegfs.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2008 David Collett
 * Copyright (C) 2008-2013 K. Henriksson
 * Copyright (C) 2017-2024 FFmpeg support 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 FFMPEGFS_H
#define FFMPEGFS_H
 
#pragma once
 
#define FUSE_USE_VERSION 26             
#ifdef __cplusplus
extern "C" {
#endif
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <fuse.h>
#pragma GCC diagnostic pop
#ifdef __cplusplus
}
#endif
 
#include <stdarg.h>
 
#include "ffmpeg_utils.h"
#include "fileio.h"
 
enum class HWACCELAPI
{
    NONE,
    VAAPI,                  
    MMAL,                   
    OMX,                    
    // Additional formats
#if 0
    CUDA,                   
    V4L2M2M,                
    VDPAU,                  
    QSV,                    
    OPENCL,                 
#if HAVE_VULKAN_HWACCEL
    VULKAN,                 
#endif // HAVE_VULKAN_HWACCEL
#if __APPLE__
    // MacOS acceleration APIs not supported
    VIDEOTOOLBOX,           
#endif
#if __ANDROID__
    // Android acceleration APIs not supported
    MEDIACODEC,             
#endif
#if _WIN32
    // Windows acceleration APIs not supported
    DRM,                    
    DXVA2,                  
    D3D11VA,                
#endif
#endif
};
 
typedef std::multimap<AVCodecID, int> HWACCEL_BLOCKED_MAP;      
extern FFMPEGFS_FORMAT_ARR ffmpeg_format;                       
extern struct FFMPEGFS_PARAMS
{
    FFMPEGFS_PARAMS();
    FFMPEGFS_PARAMS(const FFMPEGFS_PARAMS & other);
    ~FFMPEGFS_PARAMS(); // Do not make virtual, breaks fuse API compatibility!
 
    bool                    smart_transcode() const;
 
    const FFmpegfs_Format * current_format(LPCVIRTUALFILE virtualfile) const;
 
    FFMPEGFS_PARAMS& operator=(const FFMPEGFS_PARAMS & other) noexcept;
 
    // Paths
    std::string             m_basepath;                     
    std::string             m_mountpath;                    
    // Output type
    AVCodecID               m_audio_codec;                  
    AVCodecID               m_video_codec;                  
    AUTOCOPY                m_autocopy;                     
    RECODESAME              m_recodesame;                   
    PROFILE                 m_profile;                      
    PRORESLEVEL             m_level;                        
    // Audio
    BITRATE                 m_audiobitrate;                 
    int                     m_audiosamplerate;              
    int                     m_audiochannels;                
    SAMPLE_FMT              m_sample_fmt;                   
    // Video
    BITRATE                 m_videobitrate;                 
    int                     m_videowidth;                   
    int                     m_videoheight;                  
    int                     m_deinterlace;                  
    // HLS Options
    int64_t                 m_segment_duration;             
    int64_t                 m_min_seek_time_diff;           
    // Hardware acceleration
    HWACCELAPI              m_hwaccel_enc_API;              
    AVHWDeviceType          m_hwaccel_enc_device_type;      
    std::string             m_hwaccel_enc_device;           
    HWACCELAPI              m_hwaccel_dec_API;              
    AVHWDeviceType          m_hwaccel_dec_device_type;      
    std::string             m_hwaccel_dec_device;           
    HWACCEL_BLOCKED_MAP*    m_hwaccel_dec_blocked;          
    // Subtitles
    int                     m_no_subtitles;                  
    // Album arts
    int                     m_noalbumarts;                  
    // Virtual script
    int                     m_enablescript;                 
    std::string             m_scriptfile;                   
    std::string             m_scriptsource;                 
    // FFmpegfs options
    int                     m_debug;                        
    std::string             m_log_maxlevel;                 
    int                     m_log_stderr;                   
    int                     m_log_syslog;                   
    std::string             m_logfile;                      
    // Background recoding/caching
    time_t                  m_expiry_time;                  
    time_t                  m_max_inactive_suspend;         
    time_t                  m_max_inactive_abort;           
    time_t                  m_prebuffer_time;               
    size_t                  m_prebuffer_size;               
    size_t                  m_max_cache_size;               
    size_t                  m_min_diskspace;                
    std::string             m_cachepath;                    
    int                     m_disable_cache;                
    time_t                  m_cache_maintenance;            
    int                     m_prune_cache;                  
    int                     m_clear_cache;                  
    unsigned int            m_max_threads;                  
    // Miscellanous options
    int                     m_decoding_errors;              
    int                     m_min_dvd_chapter_duration;     
    int                     m_oldnamescheme;                
    std::unique_ptr<MATCHVEC>   m_include_extensions;           
    std::unique_ptr<MATCHVEC>   m_hide_extensions;              
    // Experimental options
    int                     m_win_smb_fix;                  
} params;                                                   
class Cache_Entry;
 
extern bool             docker_client;                      
extern fuse_operations  ffmpegfs_ops;
 
class thread_pool;
extern std::unique_ptr<thread_pool> tp;
 
void            init_fuse_ops();
#endif
 
void            transcoder_cache_path(std::string *path);
bool            transcoder_init();
void            transcoder_free();
bool            transcoder_cache_maintenance();
bool            transcoder_cache_clear();
LPVIRTUALFILE   insert_file(VIRTUALTYPE type, const std::string & virtfile, const struct stat *stbuf, int flags = VIRTUALFLAG_NONE);
LPVIRTUALFILE   insert_file(VIRTUALTYPE type, const std::string &virtfile, const std::string & origfile, const struct stat *stbuf, int flags = VIRTUALFLAG_NONE);
LPVIRTUALFILE   insert_dir(VIRTUALTYPE type, const std::string & virtdir, const struct stat * stbuf, int flags = VIRTUALFLAG_NONE);
LPVIRTUALFILE   find_file(const std::string &virtfile);
LPVIRTUALFILE   find_file_from_orig(const std::string &origfile);
bool            check_path(const std::string & path);
int             load_path(const std::string & path, const struct stat *statbuf, void *buf, fuse_fill_dir_t filler);
LPVIRTUALFILE   find_original(const std::string & origpath);
LPVIRTUALFILE   find_original(std::string *filepath);
LPVIRTUALFILE   find_parent(const std::string & origpath);
 
std::string     get_sampleformat_text(SAMPLE_FMT sample_fmt);
std::string     get_audio_codec_text(AVCodecID audio_codec);
std::string     get_video_codec_text(AVCodecID video_codec);
std::string     get_autocopy_text(AUTOCOPY autocopy);
std::string     get_recodesame_text(RECODESAME recode);
std::string     get_profile_text(PROFILE profile);
std::string     get_level_text(PRORESLEVEL level);
std::string     get_hwaccel_API_text(HWACCELAPI hwaccel_API);
 
bool            check_hwaccel_dec_blocked(AVCodecID codec_id, int profile);
 
int             add_fuse_entry(void *buf, fuse_fill_dir_t filler, const std::string & name, const struct stat *stbuf, off_t off);
 
int             add_dotdot(void *buf, fuse_fill_dir_t filler, const struct stat *stbuf, off_t off);