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_