Compressor.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/Buffer.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/String.h>
#include <NDEVR/Pointer.h>
#define NDEVR_SUPPORTS_ZFP 0
namespace NDEVR
{
    class File;
    struct Module;
    enum CompressionMode : uint01
    {
        e_no_compression
        , e_default_compression
        , e_best_speed
        , e_string_compression
        , e_floating_point_compression
        , e_best_compression
        , e_floating_point_compression_1_fltp04
        , e_floating_point_compression_2_fltp04
        , e_floating_point_compression_3_fltp04
        , e_floating_point_compression_4_fltp04
        , e_floating_point_compression_1_fltp08
        , e_floating_point_compression_2_fltp08
        , e_floating_point_compression_3_fltp08
        , e_floating_point_compression_4_fltp08
        , e_string_reference
        , e_compression_count//always last
    };
 
    struct CompressedStringInfo
    {
        uint04 index;
        Bounds<1, uint04> bounds;
    };
 
    struct BinaryCompressionObject
    {
        CompressionMode compression_mode = CompressionMode::e_no_compression;
        uint01* uncompressed_data = nullptr;
        uint08 uncompressed_size = 0;
        uint01* compressed_data = nullptr;
        uint08 compressed_size = 0;
        uint08 buffer_size = 0;
 
        Dictionary<String, uint04>* m_string_reference = nullptr;
        Buffer<Bounds<1, uint04>>* m_string_size_info = nullptr;
        String* m_strings = nullptr;
        DynamicPointer<BinaryCompressionObject> compression_link;
    };
    class NDEVR_BASE_API Compressor
    {
    public:
        template<class t_type>
        static CompressionMode PickCompressionMode(CompressionMode compression_mode = e_default_compression)
        {
            if (compression_mode == e_best_compression || compression_mode == e_default_compression)
            {
                if (ObjectInfo<t_type>::String)
                    compression_mode = e_string_reference;
#if NDEVR_SUPPORTS_ZFP
                else if (ObjectInfo<t_type>::Float)
                {
                    switch (ObjectInfo<t_type>::Dimensions)
                    {
                    case 0:
                    case 1:
                        if (sizeof(t_type) == 4)
                            compression_mode = e_floating_point_compression_1_fltp04;
                        else if (sizeof(t_type) == 8)
                            compression_mode = e_floating_point_compression_1_fltp08;
                        break;
                    case 2:
                        if (sizeof(t_type) / 2 == 4)
                            compression_mode = e_floating_point_compression_2_fltp04;
                        else if (sizeof(t_type) / 2 == 8)
                            compression_mode = e_floating_point_compression_2_fltp08;
                        break;
                    case 3:
                        if (sizeof(t_type) / 3 == 4)
                            compression_mode = e_floating_point_compression_3_fltp04;
                        else if (sizeof(t_type) / 3 == 8)
                            compression_mode = e_floating_point_compression_3_fltp08;
                        break;
                    case 4:
                        if (sizeof(t_type) / 4 == 4)
                            compression_mode = e_floating_point_compression_4_fltp04;
                        else if (sizeof(t_type) / 4 == 8)
                            compression_mode = e_floating_point_compression_4_fltp08;
                        break;
                    }
                }
#endif
                //else if (ObjectInfo<t_type>::Float)
                    //compression_mode = e_floating_point_compression;
            }
            return compression_mode;
        }
 
        template<class t_type, class t_index_type, class t_memory_allocator, class t_memory_manager>
        static typename std::enable_if<!ObjectInfo<t_type>::Buffer>::type Compress(BinaryCompressionObject& object, Buffer<uint01>& compression_data, const Buffer<t_type, t_index_type, t_memory_allocator, t_memory_manager>& data)
        {
            object.buffer_size = data.size();
            if (object.buffer_size != 0)
            {
                object.compression_mode = Compressor::PickCompressionMode<t_type>(object.compression_mode);
                object.uncompressed_data = (uint01*)data.ptr();
                object.uncompressed_size = data.memSize();
                switch (object.compression_mode)
                {
                case e_string_compression:
                    compression_data.setSize(sizeof(Bounds<1, uint04>));
                    object.compressed_size = sizeof(Bounds<1, uint04>);
                    break;
                case e_string_reference:
                    compression_data.clear();
                    object.compressed_size = 0;
                    break;
                default:
                    compression_data.setSize(data.memSize());
                    object.compressed_size = data.memSize();
                    break;
                }
                object.compressed_data = compression_data.begin();
                CompressData(object);
                if(object.compression_mode != e_string_reference)
                    compression_data.setSize(cast<t_index_type>(object.compressed_size));
                
            }
            else
            {
                compression_data.clear();
            }
        }
 
        template<class t_index_type, class t_memory_allocator, class t_memory_manager>
        static void CompressString(BinaryCompressionObject& object, Buffer<uint01>& compression_data, const Buffer<String, t_index_type, t_memory_allocator, t_memory_manager>& data)
        {
            Buffer<uint04> locations;
            locations.setSize(data.size());
            for (uint04 i = 0; i < data.size(); i++)
            {
                CompressedStringInfo info = AddString(object, data[i]);
                locations[i] = info.index;
            }
            Compress(object, compression_data, locations);
        }
        
        template<class t_type, class t_index_type, class t_memory_allocator, class t_memory_manager>
        static typename std::enable_if<ObjectInfo<t_type>::Buffer>::type Compress(BinaryCompressionObject& object, Buffer<uint01>& compression_data, const Buffer<t_type, t_index_type, t_memory_allocator, t_memory_manager>& data)
        {
            Buffer<uint01> temp_compress;
            Buffer<uint04> sizes;
            sizes.setSize(data.size());
            Buffer<decltype(t_type::Type())> combined_data;
            for (uint04 i = 0; i < data.size(); i++)
            {
                sizes[i] = data[i].size();
                combined_data.addAll(data[i]);
            }
            compression_data.clear();
            BinaryCompressionObject* sub_obj = new BinaryCompressionObject();
            *sub_obj = object;
            object.compression_link = sub_obj;
 
            Compress(*sub_obj, temp_compress, sizes);
            compression_data += temp_compress;
            
            Compress(object, temp_compress, combined_data);
            compression_data += temp_compress;
            sub_obj->compressed_data = compression_data.begin();
            object.compressed_data = compression_data.begin(cast<t_index_type>(sub_obj->compressed_size));
        }
        
        static void DecompressData(BinaryCompressionObject& data);
        static void CompressData(BinaryCompressionObject& data);
        static Module ZLibModule();
        static sint04 ZLibDecompress(const uint01* compressed, uint01* uncompressed, size_t compressed_size, size_t& decompressed_size);
        static sint04 ZLibCompress(uint01* compressed, const uint01* uncompressed, size_t& compressed_size, size_t decompressed_size);
        static sint04 ZLibDecompressFile(File src, File output_dir);
        static CompressedStringInfo AddString(BinaryCompressionObject& data, const String& string);
        static char* GetString(BinaryCompressionObject& data, const Bounds<1, uint04>& bounds);
        static char* GetString(BinaryCompressionObject& data, uint04 index);
        static uint04 GetStringLength(BinaryCompressionObject& data, uint04 index);
    };
}