indexedfilereader_v201_v301.h

Go to the documentation of this file.

 
#ifndef INDEXEDFILE_READER_V201_V301_CLASS_HEADER
#define INDEXEDFILE_READER_V201_V301_CLASS_HEADER
 
#include <ifhd/v201_v301/indexedfile_v201_v301.h>
#include <ifhd/v201_v301/indexreadtable_v201_v301.h>
 
#include <memory>
#include <map>
#include <optional>
 
namespace ifhd
{
namespace v201_v301
{
 
class SourceFile
{
    public:
        virtual ~SourceFile() = default;
 
        virtual void read(void* destination, uint64_t count) = 0;
 
        virtual void seek(uint64_t offset) = 0;
};
 
//*************************************************************************************************
class IndexedFileReader : public IndexedFile
{
    private:
        class IndexedFileReaderImpl;
        std::unique_ptr<IndexedFileReaderImpl> _d;
 
    protected:
        // For internal use only (will be moved to a private implementation).
        uint32_t     _flags;
        int64_t      _end_of_data_marker;
        bool         _file_pos_invalid;
        ChunkHeader* _current_chunk;
        void*        _current_chunk_data;
        bool         _header_valid;
        bool         _data_valid;
        bool         _prefetched;
        int64_t      _chunk_index;
        int64_t      _index_table_index;
        FilePos      _file_pos_current_chunk;
        
        IndexReadTable     _index_table;
 
    protected:
        bool                                         _compatibility_v110;
        void*                                        _delegate;
        mutable std::map<std::string, FileExtension> _extension_info_v110_by_name;
        a_util::filesystem::Path                     _filename;
 
    public:
        IndexedFileReader();
 
        ~IndexedFileReader();
 
        static constexpr auto read_cache_default = std::nullopt;
        static constexpr size_t read_cache_deactivated = 0;
        virtual void open(const a_util::filesystem::Path& filename,
                          const std::optional<size_t>& read_cache_size = IndexedFileReader::read_cache_default,
                          uint32_t flags = 0);
 
        virtual void open(const std::shared_ptr<SourceFile>& source_file, uint32_t flags = 0);
 
        virtual void close();
 
        void reset();
 
        int64_t getCurrentPos(TimeFormat time_format) const;
 
        int64_t setCurrentPos(int64_t position, TimeFormat time_format);
               
 
        int64_t seek(uint16_t stream_id,
                    int64_t position,
                    TimeFormat time_format,
                    uint32_t flags=0);
 
        void queryChunkInfo(ChunkHeader** chunk_header);
 
        void readChunk(void** data, uint32_t flags=0);
 
        void skipChunk();
 
        void readNextChunk(ChunkHeader** chunk_header, void** data, uint32_t flags=0, uint32_t stream_id=0);
 
        void skipChunkInfo();
 
        void readNextChunkInfo(ChunkHeader** chunk_header);
 
        int64_t getFilePos() const;
 
        int64_t getChunkCount() const;
 
        timestamp_t getDuration() const;
 
        uint32_t getVersionId() const;
 
        timestamp_t getTimeOffset() const;
 
        int64_t getStreamTableIndexCount(uint16_t stream_id) const;
 
        int64_t getStreamIndexCount(uint16_t stream_id) const;
 
        void getAdditionalStreamInfo(uint16_t stream_id,
                                        const void** info_data,
                                        size_t* info_size) const;
        std::string getStreamName(uint16_t stream_id) const;
 
        bool streamExists(uint16_t stream_id) const;
 
        timestamp_t getFirstTime(uint16_t stream_id) const;
 
        timestamp_t getLastTime(uint16_t stream_id) const;
 
        size_t getExtensionCount() const;
 
        bool findExtension(const char* identifier,
                              FileExtension** extension_info,
                              void** data) const;
 
        void getExtension(size_t index,
                             FileExtension** extension_info,
                             void** data) const;
 
        int64_t lookupChunkRef(uint16_t stream_id, int64_t position, TimeFormat time_format) const;
 
        bool getLastChunkWithFlagBefore(uint64_t chunk_index, uint16_t stream_id, uint16_t flag,
                                        ChunkHeader& header,
                                        std::vector<uint8_t>& data);
 
    protected:
        virtual void initialize();
 
        void readFileHeader();
 
        void readFileHeaderExt();
 
    protected:
 
        void readCurrentChunkHeader();
 
        void readCurrentChunkData(void* buffer);
 
        void setEOF();
 
        void readDataBlock(void* buffer, size_t buffer_size);
 
        void checkFilePtr();
 
        void allocReadBuffers();
 
        void freeReadBuffers();
};
 
} // namespace
} // namespace
 
//*************************************************************************************************
#endif // _INDEXEDFILE_READER_V201_V301_CLASS_HEADER_