xzx.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef XZINDEX_HPP__
#define XZINDEX_HPP__

#ifdef HAVE_CONFIG_H
  #include "config.h"
#endif

#ifndef WITHOUT_LZMA

#include <iostream>
#include <map>
#include <vector>

#include <lzma.h>

#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/traits.hpp>

#include "shore/stream/streams.hpp"

namespace shore {

class xzbase
{
 protected:

        static const size_t BUFSIZE=16384;

        union buffer_t
        {
                char c8[BUFSIZE];
                uint8_t u8[BUFSIZE];
                uint32_t u32[BUFSIZE>>2];
                uint64_t u64[BUFSIZE>>3];

                void clear_head()
                {
                        u64[0]=u64[1]=0;
                }
        };

        static const ::lzma_stream STREAM_INIT;

        ::lzma_ret m_xzstat;


        void xz_error(const std::string &msg);
        void xzstat_error(const std::string &msg);
};

class xzdeflater
:public xzbase
{
 private:

        ::lzma_stream m_strm;

        std::ostream& m_os;

        size_t m_blocksize;
        bool m_syncblocks;

        uint32_t m_preset;

        uint8_t* m_inbuf;
        uint8_t* m_outbuf;

        xzdeflater(const xzdeflater&);

        void deflate_block();

 public:

        xzdeflater(std::ostream& os,const bool syncblocks=true,
                   const size_t bs=131072,
                   const int level=6,const bool extreme=false);

        ~xzdeflater();

        void finish();
        
        void write(const char* s,size_t n);
};

class xzdeflater_sink
:public boost::iostreams::sink
{
 private:

        xzdeflater* m_def;

 public:

        xzdeflater_sink(xzdeflater*const def);
        std::streamsize write(const char* s,std::streamsize n);
        void close();
};

class xz_ostream
:public boost::iostreams::stream<xzdeflater_sink>
{
 private:

        xzdeflater m_def;

 public:

        xz_ostream(std::ostream* os,const bool syncblocks=true,const size_t bs=131072);
        ~xz_ostream();
};

class xzindex
:public xzbase
{
 public:
        
        class iterator
        :public xzbase
        {
         private:

                friend class xzindex;

                const xzindex *m_parent;
                ::lzma_index_iter m_iter_core;
                bool m_eof;

                iterator(const xzindex *const parent);

                void init();

         public:

                class detail
                {
                 private:

                        friend class xzinflater;

                        static const ::lzma_stream_flags &stream_flags(const iterator &it)
                        {
                                return *it.m_iter_core.stream.flags;
                        }
                };

                iterator();
                iterator(const iterator &other);
                iterator &operator=(const iterator &other);

                void locate(const uint64_t uncompressed_pos);
                void next_block();
                void next_stream();
                void rewind();

                bool eof() const;

                uint64_t compressed_file_offset() const;
                uint64_t uncompressed_file_offset() const;
                uint64_t stream_number() const;
                uint64_t block_number() const;
        };

 private:

        buffer_t m_readbuf;

        ::lzma_stream m_strm;

        ::lzma_index *m_index;

        bool m_valid;


        void parse_recursive(std::istream &is);
        void dealloc();

 public:

        xzindex(std::istream *const is);
        ~xzindex();

        bool valid() const;

        size_t get_stream_count() const;
        size_t get_block_count() const;
        uint64_t get_uncompressed_size() const;

        iterator begin() const;

        void print(std::ostream &os) const;
};

class xzinflater
:public xzbase
{
 private:
 
        static const size_t MAX_BLOCK_HEADER_SIZE=1024;

        static const size_t MAX_BLOCK_READ=BUFSIZE-MAX_BLOCK_HEADER_SIZE;

        enum
        {
                SEQ_STREAM_HEADER,
                SEQ_BLOCK_HEADER,
                SEQ_BLOCK,
                SEQ_INDEX_FOOTER_PADDING
        } m_sequence;

        buffer_t m_readbuf;
        buffer_t m_writebuf;
        size_t m_writebuf_limit;

        ::lzma_stream m_strm;

        ::lzma_stream_flags m_header;
        ::lzma_block m_block_options;
        ::lzma_filter m_filters[LZMA_FILTERS_MAX+1];
        ::lzma_stream_flags m_footer;

        uint64_t m_skip;

        std::istream &m_is;

        xzindex m_index;
        xzindex::iterator m_index_iter;

        uint64_t m_inflpos;
        uint64_t m_stream_number;
        uint64_t m_block_number;


        xzinflater(const xzinflater &);

        void get_input(const size_t n,const std::string &label);

        bool read_stream_header();
        void read_block_header();
        void read_stream_footer();
        void read_stream_padding();

        void process_input(size_t n);

        bool process_output(char **s,size_t nmax);

 public:

        xzinflater(std::istream &is,const bool raw_seekable);

        ~xzinflater();
        
        std::streamsize read(char *s,size_t n);

        std::streampos seek(int64_t ofs,std::ios_base::seekdir way);
        
        const xzindex &get_index() const;
};

class xzinflater_source
:public boost::iostreams::device<boost::iostreams::input_seekable>
{
 private:

        xzinflater *m_inf;

 public:

        xzinflater_source(xzinflater *const inf);
        ~xzinflater_source();

        std::streamsize read(char *s,std::streamsize n);

        std::streampos seek(boost::iostreams::stream_offset off,
                            std::ios_base::seekdir way);
};

class xz_istream
:public boost::iostreams::stream<xzinflater_source>
{
 private:

        xzinflater m_inf;

 public:

        xz_istream(std::istream *is,const bool raw_seekable);

        ~xz_istream();
        
        const xzindex &get_index() const;

        static std::string inflate(const std::string &zdata);
};

} // namespace shore

#endif // WITHOUT_LZMA
#endif // XZINDEX_HPP__