buffer.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017-2026 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 BUFFER_H
#define BUFFER_H
 
#pragma once
 
#include "fileio.h"
 
#include <mutex>
#include <vector>
#include <stddef.h>
 
#define CACHE_CHECK_BIT(mask, var)  ((mask) == (mask & (var)))  
#define CACHE_CLOSE_NOOPT   0x00000000                          
#define CACHE_CLOSE_FREE    0x00000001                          
#define CACHE_CLOSE_DELETE  (0x00000002 | CACHE_CLOSE_FREE)     
#define CACHE_FLAG_RO       0x00000001                          
#define CACHE_FLAG_RW       0x00000002                          
class Buffer : public FileIO
{
    static constexpr int PREALLOC_FACTOR = 5;
public:
    typedef struct _tagCACHEINFO
    {
    public:
        _tagCACHEINFO()
            : m_fd(-1)
            , m_buffer(nullptr)
            , m_buffer_pos(0)
            , m_buffer_watermark(0)
            , m_buffer_size(0)
            , m_seg_finished(false)
            , m_fd_idx(-1)
            , m_buffer_idx(nullptr)
            , m_buffer_size_idx(0)
            , m_flags(0)
            , m_buffer_write_size(0)
            , m_buffer_writes(0)
        {
        }
 
        void reset()
        {
            m_fd                = -1;
            m_buffer            = nullptr;
            m_buffer_pos        = 0;
            m_buffer_watermark  = 0;
            m_buffer_size       = 0;
            m_buffer_write_size = 0;
            m_buffer_writes     = 0;
        }
 
        // Main cache
        std::string             m_cachefile;                    
        int                     m_fd;                           
        uint8_t *               m_buffer;                       
        size_t                  m_buffer_pos;                   
        size_t                  m_buffer_watermark;             
        size_t                  m_buffer_size;                  
        bool                    m_seg_finished;                 
        // Index for frame sets
        std::string             m_cachefile_idx;                
        int                     m_fd_idx;                       
        uint8_t *               m_buffer_idx;                   
        size_t                  m_buffer_size_idx;              
        // Flags
        uint32_t                m_flags;                        
        // Statistics
        size_t                  m_buffer_write_size;            
        unsigned int            m_buffer_writes;                
    } CACHEINFO, *LPCACHEINFO;                                  
    typedef CACHEINFO const * LPCCACHEINFO;                     
public:
    explicit Buffer();
    virtual ~Buffer();
    virtual VIRTUALTYPE     type() const override;
    bool                    init(bool erase_cache);
    bool                    set_segment(uint32_t segment_no, size_t size);
    uint32_t                segment_count();
    uint32_t                current_segment_no();
    bool                    segment_exists(uint32_t segment_no);
    bool                    cachefile_valid(uint32_t segment_no);
    bool                    invalidate_segment(uint32_t segment_no = 0);
    bool                    release(int flags = CACHE_CLOSE_NOOPT);
    virtual size_t          bufsize() const override;
 
    virtual int             openio(LPVIRTUALFILE virtualfile) override;
    virtual size_t          readio(void *data, size_t size) override;
    size_t                  read_frame(std::vector<uint8_t> * data, uint32_t frame_no);
    virtual int             error() const override;
    virtual int64_t         duration() const override;
    virtual size_t          size() const override;
    virtual size_t          size(uint32_t segment_no) const;
    virtual size_t          tell() const override;
    virtual size_t          tell(uint32_t segment_no) const;
    virtual int             seek(int64_t offset, int whence) override;
    virtual int             seek(int64_t offset, int whence, uint32_t segment_no);
    virtual bool            eof() const override;
    virtual bool            eof(uint32_t segment_no) const;
    virtual void            closeio() override;
    size_t                  writeio(const uint8_t* data, size_t length);
    size_t                  write_frame(const uint8_t* data, size_t length, uint32_t frame_no);
    bool                    flush();
    bool                    clear();
    bool                    reserve(size_t size);
    size_t                  buffer_watermark(uint32_t segment_no = 0) const;
    bool                    copy(std::vector<uint8_t> * out_data, size_t offset, uint32_t segment_no = 0);
    bool                    copy(uint8_t* out_data, size_t offset, size_t bufsize, uint32_t segment_no = 0);
    const std::string &     cachefile(uint32_t segment_no) const;
    static const std::string & make_cachefile_name(std::string *cachefile, const std::string & filename, const std::string &fileext, bool is_idx);
    static bool             remove_file(const std::string & filename);
    bool                    have_frame(uint32_t frame_no);
    void                    finished_segment();
    bool                    is_segment_finished(uint32_t segment_no) const;
    bool                    open_file(uint32_t segment_no, uint32_t flags, size_t defaultsize = 0);
    bool                    close_file(uint32_t segment_no, uint32_t flags);
 
protected:
    bool                    remove_cachefile(uint32_t segment_no = 0) const;
    bool                    is_open();
 
private:
    uint8_t*                write_prepare(size_t length);
    void                    increment_pos(size_t increment);
    bool                    reallocate(size_t newsize);
    bool                    map_file(const std::string & filename, volatile int *fd, uint8_t **p, size_t *filesize, bool *isdefaultsize, size_t defaultsize, bool truncate) const;
    bool                    unmap_file(const std::string & filename, volatile int *fd, uint8_t **p, size_t len, size_t *filesize) const;
 
    LPCACHEINFO             cacheinfo(uint32_t segment_no);
    LPCCACHEINFO            const_cacheinfo(uint32_t segment_no) const;
 
private:
    std::recursive_mutex    m_mutex;                            
    LPCACHEINFO             m_cur_ci;                           
    uint32_t                m_cur_open;                         
    std::vector<CACHEINFO>  m_ci;                               
};
 
#endif