VGearsLZSDataStream.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#include <OgreDataStream.h>
#include "common/TypeDefine.h"
 
namespace VGears{
 
    template<size_t buffer_size> class RingBuffer{
 
        public:
 
            RingBuffer(){clear();}
 
            void Write(const void *in_buffer){
                buffer_[position_] = *(static_cast<const uint8*>(in_buffer));
                ++ position_ %= buffer_size;
                ++ available_ = std::min(available_, buffer_size);
            }
 
            size_t Read(void *out_buffer, size_t count){
                assert(available_ && "Can't read if no data is available");
                size_t read(0);
                uint8 *buffer(static_cast<uint8*>(out_buffer));
                while (read < count && available_){
                    *(buffer ++)
                      = buffer_[(position_ - available_) % buffer_size];
                    -- available_;
                    ++ read;
                }
                return read;
            }
 
            uint8 Get(const size_t offset){
                return buffer_[offset % buffer_size];
            }
 
            size_t Available() const{return available_;}
 
            void clear(){
                position_ = 0;
                available_ = 0;
                memset(buffer_, 0, buffer_size);
            }
 
        protected:
 
            uint8 buffer_[buffer_size];
 
            size_t position_;
 
            size_t available_;
 
    };
 
    class LZSDataStream : public Ogre::DataStream{
 
        public:
 
            LZSDataStream(const Ogre::DataStreamPtr &compressed_stream);
 
            LZSDataStream(
              const String &name, const Ogre::DataStreamPtr &compressed_stream
            );
 
            virtual ~LZSDataStream();
 
            virtual size_t read(void *buf, size_t count) override;
 
            virtual bool eof() const override;
 
            virtual void skip(long count) override;
 
            virtual void seek(size_t pos) override;
 
            virtual size_t tell() const override;
 
            virtual void close() override;
 
            size_t AvailableCompressed() const {return available_compressed_;}
 
            size_t AvailableUncompressed() const{return buffer_.Available();}
 
            void FlipEndian(uint32 &inout_data);
 
        protected:
 
            virtual void init();
 
            virtual void DecompressChunk();
 
            Ogre::DataStreamPtr compressed_stream_;
            uint32              available_compressed_;
            size_t              position_;
            RingBuffer<4096>    buffer_;
    };
 
    typedef Ogre::SharedPtr<LZSDataStream>  LZSDataStreamPtr;
}