TightDecoder.h

#pragma once
#ifndef TIGHT_VNC
#define TIGHT_VNC
#include <QRect>
#include <QImage>
struct z_stream_s;
class QTcpSocket;
namespace NDEVR
{
    struct PixelFormat;
    class ZlibInStream
    {
    public:
        ZlibInStream()
            : underlying(0)
            , zs(NULL)
        {
            init();
        }

        ~ZlibInStream()
        {
            deinit();
        }

        void setUnderlying(const uint01* is, size_t bytesIn_)
        {
            underlying.addAll(is, cast<uint04>(bytesIn_));
        }

        void flushUnderlying()
        {
            setUnderlying(NULL, 0);
        }

        void reset()
        {
            underlying.clear();
            deinit();
            init();
        }

        void init();

        void deinit();
        bool readBytes(uint01* data, size_t length);
    private:
        Buffer<uint01> underlying; 
        z_stream_s* zs;            
 
    };

    class TightDecoder
    {
 
    public:
        TightDecoder()
        {
 
        }
        virtual ~TightDecoder()
        {
 
        }
        static void ReadAll(QTcpSocket* is, uint01* os, uint04 size);
        static void CopyToBuffer(uint01*& buffer, void* value, uint04 size, uint04& total_size)
        {
            memcpy(buffer, value, size);
            buffer += size; 
            total_size += size;
        }

        static bool ReadRect(const QRect& r, QTcpSocket* is, const PixelFormat& pf, QImage& pb);
        
 
    private:
        static uint04 ReadCompact(QTcpSocket* is);
        static void FilterGradient(const uint01* inbuf, const PixelFormat& pf, uint04* outbuf, int stride, const QRect& r);
 
        static void FilterPalette(const uint01* palette, uint04 palSize, const uint01* inbuf, uint01* outbuf, int stride, const QRect& r, uint04 pixel_size);
 
    private:
        static ZlibInStream zis[4];
    };
}
#endif