indexedfile_v110.h

Go to the documentation of this file.

 
#ifndef INDEXEDFILE_V110_CLASS_HEADER
#define INDEXEDFILE_V110_CLASS_HEADER
 
#include <ifhd/v100/indexedfile_v100.h>
 
#include <list>
 
namespace ifhd
{
namespace v110
{
 
//*************************************************************************************************
/*
 
    FILE LAYOUT:
 
    +---------------------------------------------------------------+
    |HDR|                   DATA                |HDR-EXT|    IDX    |
    +---------------------------------------------------------------+
 
*/

static constexpr uint32_t version_id = 0x00000110;
 
 

class IndexedFileV110
{
    public:
        enum
        {
            tf_chunk_index      = 1,
            tf_chunk_time       = 2
        };
 
#ifdef _WIN32
#pragma pack(push)
#pragma pack(1)
#else
#pragma pack(push)
#pragma pack(1)
#endif
        using DateTime = v100::IndexedFileV100::DateTime;
        typedef struct TagFileHeader
        {
            uint32_t                         file_id;   
            uint32_t                         version_id;
            FilePos                          extension_offset;
            uint32_t                         extension_count;
            uint32_t                         reserved1;
            FilePos                          data_offset;
            utils5ext::FileSize              data_size;  
            uint64_t                         index_count;
            FilePos                          index_offset;
            uint64_t                         duration;
            DateTime                         date_time;
            uint64_t                         chunk_count;            
            uint64_t                         max_chunk_size;          
            uint64_t                         reserved2[5];        
            int8_t                           description[1912]; 
        } FileHeader;   // filled up to 2048 Bytes

        typedef struct TagFileExtension
        {
            int8_t                           identifier[32];
            uint32_t                         type_id;
            uint32_t                         version_id;
            FilePos                          data_pos;
            utils5ext::FileSize              data_size;
            uint8_t                          reserved[8];
        } FileExtension;

        typedef struct TagChunkHeader
        {
            uint64_t                         time_stamp;
            uint64_t                         ref_index;
            uint32_t                         size;
            uint32_t                         flags;
            uint64_t                         reserved;
        } ChunkHeader;

        typedef struct TagChunkRef
        {
            uint64_t                         time_stamp;
            uint32_t                         size;
            uint32_t                         flags;
            uint64_t                         chunk_offset;
            uint64_t                         chunk_index;
        } ChunkRef;
 
#ifdef _WIN32
#pragma pack(pop)
#else
#pragma pack(pop)
#endif

        typedef struct TagIndexBlockItem
        {
            ChunkRef*                      data;             
            int                            data_size;         
            int                            item_count;        
            struct TagIndexBlockItem*      next;             
        } IndexBlockItem;

        typedef enum
        {
            sf_default                      = 0x0,         
            sf_keydata                      = 0x1          
        } SeekFlags;

        typedef enum
        {
            om_none                          = 0x0,          
            om_query_info                    = 0x4           
        } OpenMode;
 
    protected:
 
        static int                         default_block_size;       
        static int                         default_cache_size;       
        static int                         index_table_cluster_size; 
 
        int                                _sector_size;             
 
        utils5ext::File*                   _file;                    
 
        FilePos                            _file_pos;                
 
        uint8_t*                           _buffer;                  
        int                                _buffer_size;             
 
        IndexBlockItem*                    _index_blocks;            
        IndexBlockItem*                    _active_index_block;      
 
        FileHeader*                        _file_header;             

        typedef struct
        {
            FileExtension  file_extension;  
            void*          extension_page;  
        } FileExtensionStruct;
 
        typedef std::list<FileExtensionStruct*> FileExtensionList;   
        FileExtensionList                   _extensions;             
 
        void*                               _cache;                  
        int                                 _cache_size;             
 
        bool                                _write_mode;             
 
    public:
        IndexedFileV110();

        ~IndexedFileV110();

        void close();

        void setDescription(const std::string& description);

        std::string getDescription() const;

        void setDateTime(const a_util::datetime::DateTime* date_time);

        void getDateTime(a_util::datetime::DateTime* date_time) const;

        int getExtensionCount() const;

        bool findExtension(const std::string& identifier, FileExtension** extension_info, void** data) const;

        void getExtension(int index, FileExtension** extension_info, void** data) const;

        void appendExtension(const std::string& identifier,
                                const void* data,
                                int data_size,
                                uint32_t type_id=0,
                                uint32_t version_id=0);

        void appendExtension(const void* data, const FileExtension* extension_info);

        void freeExtensions();

        void getHeader(FileHeader** file_header) const;
 
    protected:
        void initialize();

        void allocBuffer(int size);
        void freeBuffer();

        void appendIndex(uint64_t pos, timestamp_t time_stamp);
        void allocIndexBlock(int count=-1);
        void freeIndexTable();

        void allocHeader();
        void freeHeader();
        void allocExtensionPage(utils5ext::FileSize size, void** data);
 
    protected:
        void allocCache(int size);
        void freeCache();
        void*  getCacheAddr();

        int getSectorSize(const a_util::filesystem::Path& filename) const;

        void* internalMalloc(int size);
        void internalFree(void* memory);
};
 
} // namespace v110
} // namespace ifhd
 
//*************************************************************************************************
#endif // _INDEXEDFILE_V110_CLASS_HEADER_