fileio.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 FILEIO_H
#define FILEIO_H
 
#pragma once
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <sys/stat.h>
 
#include <string>
#include <vector>
#include <map>
#include <cstring>
#include <memory>
#include <array>
 
// Disable annoying warnings outside our code
#ifdef __cplusplus
extern "C" {
#endif
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#include <libavutil/avutil.h>
#pragma GCC diagnostic pop
#ifdef __cplusplus
}
#endif
 
#pragma pack(push, 1)
 
#define IMAGE_FRAME_TAG         "IMGFRAME"      
typedef struct IMAGE_FRAME
{
    std::array<char, 8>     m_tag;              
    uint32_t                m_frame_no;         
    uint64_t                m_offset;           
    uint32_t                m_size;             
    std::array<uint8_t, 8>  m_reserved;         
    // ...data
} IMAGE_FRAME;
#pragma pack(pop)
typedef IMAGE_FRAME const *LPCIMAGE_FRAME;      
typedef IMAGE_FRAME *LPIMAGE_FRAME;             
enum class VIRTUALTYPE
{
    PASSTHROUGH,                                        
    DISK,                                               
    SCRIPT,                                             
#ifdef USE_LIBVCD
    VCD,                                                
#endif // USE_LIBVCD
#ifdef USE_LIBDVD
    DVD,                                                
#endif // USE_LIBDVD
#ifdef USE_LIBBLURAY
    BLURAY,                                             
#endif // USE_LIBBLURAY
 
    BUFFER,                                             
};
typedef VIRTUALTYPE const *LPCVIRTUALTYPE;                          
typedef VIRTUALTYPE LPVIRTUALTYPE;                                  
#define VIRTUALFLAG_NONE            0x00000000                      
#define VIRTUALFLAG_PASSTHROUGH     0x00000001                      
#define VIRTUALFLAG_DIRECTORY       0x00000002                      
#define VIRTUALFLAG_FILESET         0x00000004                      
#define VIRTUALFLAG_FRAME           0x00000008                      
#define VIRTUALFLAG_HLS             0x00000010                      
#define VIRTUALFLAG_CUESHEET        0x00000020                      
#define VIRTUALFLAG_HIDDEN          0x00000040                      
typedef struct VIRTUALFILE
{
    VIRTUALFILE()
        : m_type(VIRTUALTYPE::DISK)
        , m_flags(VIRTUALFLAG_NONE)
        , m_format_idx(0)
        , m_full_title(false)
        , m_duration(0)
        , m_predicted_size(0)
        , m_video_frame_count(0)
        , m_has_audio(false)
        , m_has_video(false)
        , m_has_subtitle(false)
        , m_channels(0)
        , m_sample_rate(0)
        , m_width(0)
        , m_height(0)
        , m_framerate{ 0, 0 }
    {
        std::memset(&m_st, 0, sizeof(m_st));
    }
 
    uint32_t get_segment_count() const;                             
    VIRTUALTYPE             m_type;                                 
    int                     m_flags;                                
    size_t                  m_format_idx;                           
    std::string             m_destfile;                             
    std::string             m_virtfile;                             
    std::string             m_origfile;                             
    struct stat             m_st;                                   
    bool                    m_full_title;                           
    int64_t                 m_duration;                             
    size_t                  m_predicted_size;                       
    uint32_t                m_video_frame_count;                    
    bool                    m_has_audio;                            
    bool                    m_has_video;                            
    bool                    m_has_subtitle;                         
    std::vector<char>       m_file_contents;                        
#ifdef USE_LIBVCD
    struct VCD_CHAPTER
    {
        VCD_CHAPTER()
            : m_track_no(0)
            , m_chapter_no(0)
            , m_start_pos(0)
            , m_end_pos(0)
        {}
        int                 m_track_no;                             
        int                 m_chapter_no;                           
        uint64_t            m_start_pos;                            
        uint64_t            m_end_pos;                              
    }                       m_vcd;                                  
#endif //USE_LIBVCD
#ifdef USE_LIBDVD
    struct DVD_CHAPTER
    {
        DVD_CHAPTER()
            : m_title_no(0)
            , m_chapter_no(0)
            , m_angle_no(0)
        {}
        int                 m_title_no;                             
        int                 m_chapter_no;                           
        int                 m_angle_no;                             
    }                       m_dvd;                                  
#endif // USE_LIBDVD
#ifdef USE_LIBBLURAY
    struct BLURAY_CHAPTER
    {
        BLURAY_CHAPTER()
            : m_title_no(0)
            , m_playlist_no(0)
            , m_chapter_no(0)
            , m_angle_no(0)
        {}
        uint32_t            m_title_no;                             
        uint32_t            m_playlist_no;                          
        unsigned            m_chapter_no;                           
        unsigned            m_angle_no;                             
    }                       m_bluray;                               
#endif // USE_LIBBLURAY
    struct CUESHEET_TRACK
    {
        CUESHEET_TRACK()
            : m_tracktotal(0)
            , m_trackno(0)
            , m_start(0)
            , m_duration(0)
            , m_nextfile(nullptr)
        {}
 
        int                 m_tracktotal;                           
        int                 m_trackno;                              
        std::string         m_artist;                               
        std::string         m_title;                                
        std::string         m_album;                                
        std::string         m_genre;                                
        std::string         m_date;                                 
        int64_t             m_start;                                
        int64_t             m_duration;                             
        VIRTUALFILE*        m_nextfile;                             
    }                       m_cuesheet_track;                       
    std::string             m_cuesheet;                             
    // These may be filled in for DVD/Blu-ray
    int                     m_channels;                             
    int                     m_sample_rate;                          
    int                     m_width;                                
    int                     m_height;                               
    AVRational              m_framerate;                            
} VIRTUALFILE;
typedef VIRTUALFILE const *LPCVIRTUALFILE;                          
typedef VIRTUALFILE *LPVIRTUALFILE;                                 
class FileIO
{
public:
    explicit FileIO();
    virtual ~FileIO() = default;
 
    static std::shared_ptr<FileIO> alloc(VIRTUALTYPE type);
 
    virtual VIRTUALTYPE type() const = 0;
    virtual size_t      bufsize() const = 0;
    virtual int         openio(LPVIRTUALFILE virtualfile) = 0;
    virtual size_t      readio(void *data, size_t size) = 0;
    virtual int         error() const = 0;
    virtual int64_t     duration() const = 0;
    virtual size_t      size() const = 0;
    virtual size_t      tell() const = 0;
    virtual int         seek(int64_t offset, int whence) = 0;
    virtual bool        eof() const = 0;
    virtual void        closeio() = 0;
    LPVIRTUALFILE       virtualfile();
    const std::string & filename() const;
    const std::string & path() const;
 
protected:
    void                set_virtualfile(LPVIRTUALFILE virtualfile);
 
private:
    std::string         m_path;                                     
    LPVIRTUALFILE       m_virtualfile;                              
};
 
#endif // FILEIO_H