We have no use for it, so let's keep things simple.tags/v1.3.90
@@ -18,6 +18,7 @@ | |||
#include <stdio.h> | |||
#include <rdr/OutStream.h> | |||
#include <rfb/msgTypes.h> | |||
#include <rfb/encodings.h> | |||
#include <rfb/PixelFormat.h> | |||
#include <rfb/Rect.h> | |||
#include <rfb/ConnParams.h> |
@@ -1,4 +1,5 @@ | |||
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. | |||
* Copyright 2014 Pierre Ossman for Cendio AB | |||
* | |||
* This is free software; you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
@@ -16,7 +17,7 @@ | |||
* USA. | |||
*/ | |||
#include <stdio.h> | |||
#include <rfb/Exception.h> | |||
#include <rfb/encodings.h> | |||
#include <rfb/Decoder.h> | |||
#include <rfb/RawDecoder.h> | |||
#include <rfb/RREDecoder.h> | |||
@@ -30,41 +31,34 @@ Decoder::~Decoder() | |||
{ | |||
} | |||
DecoderCreateFnType Decoder::createFns[encodingMax+1] = { 0 }; | |||
bool Decoder::supported(int encoding) | |||
{ | |||
return encoding >= 0 && encoding <= encodingMax && createFns[encoding]; | |||
switch (encoding) { | |||
case encodingRaw: | |||
case encodingRRE: | |||
case encodingHextile: | |||
case encodingZRLE: | |||
case encodingTight: | |||
return true; | |||
default: | |||
return false; | |||
} | |||
} | |||
Decoder* Decoder::createDecoder(int encoding, CMsgReader* reader) | |||
{ | |||
if (supported(encoding)) | |||
return (*createFns[encoding])(reader); | |||
return 0; | |||
} | |||
void Decoder::registerDecoder(int encoding, | |||
DecoderCreateFnType createFn) | |||
{ | |||
if (encoding > encodingMax) | |||
throw Exception("Decoder::registerDecoder: encoding out of range"); | |||
if (createFns[encoding]) | |||
fprintf(stderr,"Replacing existing decoder for encoding %s (%d)\n", | |||
encodingName(encoding), encoding); | |||
createFns[encoding] = createFn; | |||
} | |||
int DecoderInit::count = 0; | |||
DecoderInit::DecoderInit() | |||
{ | |||
if (count++ != 0) return; | |||
Decoder::registerDecoder(encodingRaw, RawDecoder::create); | |||
Decoder::registerDecoder(encodingRRE, RREDecoder::create); | |||
Decoder::registerDecoder(encodingHextile, HextileDecoder::create); | |||
Decoder::registerDecoder(encodingZRLE, ZRLEDecoder::create); | |||
Decoder::registerDecoder(encodingTight, TightDecoder::create); | |||
switch (encoding) { | |||
case encodingRaw: | |||
return new RawDecoder(reader); | |||
case encodingRRE: | |||
return new RREDecoder(reader); | |||
case encodingHextile: | |||
return new HextileDecoder(reader); | |||
case encodingZRLE: | |||
return new ZRLEDecoder(reader); | |||
case encodingTight: | |||
return new TightDecoder(reader); | |||
default: | |||
return NULL; | |||
} | |||
} |
@@ -1,4 +1,5 @@ | |||
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. | |||
* Copyright 2014 Pierre Ossman for Cendio AB | |||
* | |||
* This is free software; you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
@@ -19,13 +20,10 @@ | |||
#define __RFB_DECODER_H__ | |||
#include <rfb/Rect.h> | |||
#include <rfb/encodings.h> | |||
namespace rfb { | |||
class CMsgReader; | |||
class CMsgHandler; | |||
class Decoder; | |||
typedef Decoder* (*DecoderCreateFnType)(CMsgReader*); | |||
class Decoder { | |||
public: | |||
@@ -34,19 +32,7 @@ namespace rfb { | |||
static bool supported(int encoding); | |||
static Decoder* createDecoder(int encoding, CMsgReader* reader); | |||
static void registerDecoder(int encoding, | |||
DecoderCreateFnType createFn); | |||
private: | |||
static DecoderCreateFnType createFns[encodingMax+1]; | |||
}; | |||
class DecoderInit { | |||
static int count; | |||
public: | |||
DecoderInit(); | |||
}; | |||
static DecoderInit decoderInitObj; | |||
} | |||
#endif |
@@ -1,4 +1,5 @@ | |||
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. | |||
* Copyright 2014 Pierre Ossman for Cendio AB | |||
* | |||
* This is free software; you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
@@ -16,6 +17,7 @@ | |||
* USA. | |||
*/ | |||
#include <stdio.h> | |||
#include <rfb/encodings.h> | |||
#include <rfb/Exception.h> | |||
#include <rfb/Encoder.h> | |||
#include <rfb/RawEncoder.h> | |||
@@ -30,48 +32,34 @@ Encoder::~Encoder() | |||
{ | |||
} | |||
EncoderCreateFnType Encoder::createFns[encodingMax+1] = { 0 }; | |||
bool Encoder::supported(int encoding) | |||
{ | |||
return encoding >= 0 && encoding <= encodingMax && createFns[encoding]; | |||
switch (encoding) { | |||
case encodingRaw: | |||
case encodingRRE: | |||
case encodingHextile: | |||
case encodingZRLE: | |||
case encodingTight: | |||
return true; | |||
default: | |||
return false; | |||
} | |||
} | |||
Encoder* Encoder::createEncoder(int encoding, SMsgWriter* writer) | |||
{ | |||
if (supported(encoding)) | |||
return (*createFns[encoding])(writer); | |||
return 0; | |||
} | |||
void Encoder::registerEncoder(int encoding, | |||
EncoderCreateFnType createFn) | |||
{ | |||
if (encoding > encodingMax) | |||
throw Exception("Encoder::registerEncoder: encoding out of range"); | |||
if (createFns[encoding]) | |||
fprintf(stderr,"Replacing existing encoder for encoding %s (%d)\n", | |||
encodingName(encoding), encoding); | |||
createFns[encoding] = createFn; | |||
} | |||
void Encoder::unregisterEncoder(int encoding) | |||
{ | |||
if (encoding > encodingMax) | |||
throw Exception("Encoder::unregisterEncoder: encoding out of range"); | |||
createFns[encoding] = 0; | |||
} | |||
int EncoderInit::count = 0; | |||
EncoderInit::EncoderInit() | |||
{ | |||
if (count++ != 0) return; | |||
Encoder::registerEncoder(encodingRaw, RawEncoder::create); | |||
Encoder::registerEncoder(encodingRRE, RREEncoder::create); | |||
Encoder::registerEncoder(encodingHextile, HextileEncoder::create); | |||
Encoder::registerEncoder(encodingZRLE, ZRLEEncoder::create); | |||
Encoder::registerEncoder(encodingTight, TightEncoder::create); | |||
switch (encoding) { | |||
case encodingRaw: | |||
return new RawEncoder(writer); | |||
case encodingRRE: | |||
return new RREEncoder(writer); | |||
case encodingHextile: | |||
return new HextileEncoder(writer); | |||
case encodingZRLE: | |||
return new ZRLEEncoder(writer); | |||
case encodingTight: | |||
return new TightEncoder(writer); | |||
default: | |||
return NULL; | |||
} | |||
} |
@@ -1,5 +1,6 @@ | |||
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved. | |||
* Copyright (C) 2011 D. R. Commander. All Rights Reserved. | |||
* Copyright 2014 Pierre Ossman for Cendio AB | |||
* | |||
* This is free software; you can redistribute it and/or modify | |||
* it under the terms of the GNU General Public License as published by | |||
@@ -20,14 +21,12 @@ | |||
#define __RFB_ENCODER_H__ | |||
#include <rfb/Rect.h> | |||
#include <rfb/encodings.h> | |||
#include <rfb/TransImageGetter.h> | |||
#include <rfb/JpegCompressor.h> | |||
namespace rfb { | |||
class SMsgWriter; | |||
class Encoder; | |||
class TransImageGetter; | |||
typedef Encoder* (*EncoderCreateFnType)(SMsgWriter*); | |||
class Encoder { | |||
public: | |||
@@ -46,20 +45,7 @@ namespace rfb { | |||
static bool supported(int encoding); | |||
static Encoder* createEncoder(int encoding, SMsgWriter* writer); | |||
static void registerEncoder(int encoding, | |||
EncoderCreateFnType createFn); | |||
static void unregisterEncoder(int encoding); | |||
private: | |||
static EncoderCreateFnType createFns[encodingMax+1]; | |||
}; | |||
class EncoderInit { | |||
static int count; | |||
public: | |||
EncoderInit(); | |||
}; | |||
static EncoderInit encoderInitObj; | |||
} | |||
#endif |
@@ -34,11 +34,6 @@ using namespace rfb; | |||
#include <rfb/hextileDecode.h> | |||
#undef BPP | |||
Decoder* HextileDecoder::create(CMsgReader* reader) | |||
{ | |||
return new HextileDecoder(reader); | |||
} | |||
HextileDecoder::HextileDecoder(CMsgReader* reader_) : reader(reader_) | |||
{ | |||
} |
@@ -24,11 +24,10 @@ namespace rfb { | |||
class HextileDecoder : public Decoder { | |||
public: | |||
static Decoder* create(CMsgReader* reader); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
HextileDecoder(CMsgReader* reader); | |||
virtual ~HextileDecoder(); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
private: | |||
HextileDecoder(CMsgReader* reader); | |||
CMsgReader* reader; | |||
}; | |||
} |
@@ -45,11 +45,6 @@ BoolParameter improvedHextile("ImprovedHextile", | |||
#include <rfb/hextileEncodeBetter.h> | |||
#undef BPP | |||
Encoder* HextileEncoder::create(SMsgWriter* writer) | |||
{ | |||
return new HextileEncoder(writer); | |||
} | |||
HextileEncoder::HextileEncoder(SMsgWriter* writer_) : writer(writer_) | |||
{ | |||
} |
@@ -24,11 +24,10 @@ namespace rfb { | |||
class HextileEncoder : public Encoder { | |||
public: | |||
static Encoder* create(SMsgWriter* writer); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
HextileEncoder(SMsgWriter* writer); | |||
virtual ~HextileEncoder(); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
private: | |||
HextileEncoder(SMsgWriter* writer); | |||
SMsgWriter* writer; | |||
}; | |||
} |
@@ -34,11 +34,6 @@ using namespace rfb; | |||
#include <rfb/rreDecode.h> | |||
#undef BPP | |||
Decoder* RREDecoder::create(CMsgReader* reader) | |||
{ | |||
return new RREDecoder(reader); | |||
} | |||
RREDecoder::RREDecoder(CMsgReader* reader_) : reader(reader_) | |||
{ | |||
} |
@@ -24,11 +24,10 @@ namespace rfb { | |||
class RREDecoder : public Decoder { | |||
public: | |||
static Decoder* create(CMsgReader* reader); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
RREDecoder(CMsgReader* reader); | |||
virtual ~RREDecoder(); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
private: | |||
RREDecoder(CMsgReader* reader); | |||
CMsgReader* reader; | |||
}; | |||
} |
@@ -33,11 +33,6 @@ using namespace rfb; | |||
#include <rfb/rreEncode.h> | |||
#undef BPP | |||
Encoder* RREEncoder::create(SMsgWriter* writer) | |||
{ | |||
return new RREEncoder(writer); | |||
} | |||
RREEncoder::RREEncoder(SMsgWriter* writer_) : writer(writer_) | |||
{ | |||
} |
@@ -25,11 +25,10 @@ namespace rfb { | |||
class RREEncoder : public Encoder { | |||
public: | |||
static Encoder* create(SMsgWriter* writer); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
RREEncoder(SMsgWriter* writer); | |||
virtual ~RREEncoder(); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
private: | |||
RREEncoder(SMsgWriter* writer); | |||
SMsgWriter* writer; | |||
rdr::MemOutStream mos; | |||
}; |
@@ -22,11 +22,6 @@ | |||
using namespace rfb; | |||
Decoder* RawDecoder::create(CMsgReader* reader) | |||
{ | |||
return new RawDecoder(reader); | |||
} | |||
RawDecoder::RawDecoder(CMsgReader* reader_) : reader(reader_) | |||
{ | |||
} |
@@ -24,11 +24,10 @@ namespace rfb { | |||
class RawDecoder : public Decoder { | |||
public: | |||
static Decoder* create(CMsgReader* reader); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
RawDecoder(CMsgReader* reader); | |||
virtual ~RawDecoder(); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
private: | |||
RawDecoder(CMsgReader* reader); | |||
CMsgReader* reader; | |||
}; | |||
} |
@@ -23,11 +23,6 @@ | |||
using namespace rfb; | |||
Encoder* RawEncoder::create(SMsgWriter* writer) | |||
{ | |||
return new RawEncoder(writer); | |||
} | |||
RawEncoder::RawEncoder(SMsgWriter* writer_) : writer(writer_) | |||
{ | |||
} |
@@ -24,11 +24,10 @@ namespace rfb { | |||
class RawEncoder : public Encoder { | |||
public: | |||
static Encoder* create(SMsgWriter* writer); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
RawEncoder(SMsgWriter* writer); | |||
virtual ~RawEncoder(); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
private: | |||
RawEncoder(SMsgWriter* writer); | |||
SMsgWriter* writer; | |||
}; | |||
} |
@@ -37,11 +37,6 @@ using namespace rfb; | |||
#include <rfb/tightDecode.h> | |||
#undef BPP | |||
Decoder* TightDecoder::create(CMsgReader* reader) | |||
{ | |||
return new TightDecoder(reader); | |||
} | |||
TightDecoder::TightDecoder(CMsgReader* reader_) : reader(reader_) | |||
{ | |||
} |
@@ -28,9 +28,9 @@ namespace rfb { | |||
class TightDecoder : public Decoder { | |||
public: | |||
static Decoder* create(CMsgReader* reader); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
TightDecoder(CMsgReader* reader); | |||
virtual ~TightDecoder(); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
private: | |||
void tightDecode8(const Rect& r); | |||
@@ -54,8 +54,6 @@ namespace rfb { | |||
void directFillRect16(const Rect& r, Pixel pix); | |||
void directFillRect32(const Rect& r, Pixel pix); | |||
TightDecoder(CMsgReader* reader); | |||
CMsgReader* reader; | |||
CMsgHandler* handler; | |||
rdr::InStream* is; |
@@ -92,11 +92,6 @@ const int TightEncoder::defaultCompressLevel = 2; | |||
#include <rfb/tightEncode.h> | |||
#undef BPP | |||
Encoder* TightEncoder::create(SMsgWriter* writer) | |||
{ | |||
return new TightEncoder(writer); | |||
} | |||
TightEncoder::TightEncoder(SMsgWriter* writer_) : writer(writer_) | |||
{ | |||
setCompressLevel(defaultCompressLevel); |
@@ -78,16 +78,16 @@ namespace rfb { | |||
class TightEncoder : public Encoder { | |||
public: | |||
static Encoder* create(SMsgWriter* writer); | |||
TightEncoder(SMsgWriter* writer); | |||
virtual ~TightEncoder(); | |||
virtual void setCompressLevel(int level); | |||
virtual void setQualityLevel(int level); | |||
virtual void setFineQualityLevel(int quality, JPEG_SUBSAMP subsampling); | |||
virtual int getNumRects(const Rect &r); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
virtual ~TightEncoder(); | |||
private: | |||
TightEncoder(SMsgWriter* writer); | |||
bool checkSolidTile(Rect& r, rdr::U32* colorPtr, bool needSameColor); | |||
void extendSolidArea(const Rect& r, rdr::U32 colorValue, Rect& er); | |||
void findBestSolidArea(Rect& r, rdr::U32 colorValue, Rect& bestr); |
@@ -40,11 +40,6 @@ using namespace rfb; | |||
#undef CPIXEL | |||
#undef BPP | |||
Decoder* ZRLEDecoder::create(CMsgReader* reader) | |||
{ | |||
return new ZRLEDecoder(reader); | |||
} | |||
ZRLEDecoder::ZRLEDecoder(CMsgReader* reader_) : reader(reader_) | |||
{ | |||
} |
@@ -25,11 +25,10 @@ namespace rfb { | |||
class ZRLEDecoder : public Decoder { | |||
public: | |||
static Decoder* create(CMsgReader* reader); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
ZRLEDecoder(CMsgReader* reader); | |||
virtual ~ZRLEDecoder(); | |||
virtual void readRect(const Rect& r, CMsgHandler* handler); | |||
private: | |||
ZRLEDecoder(CMsgReader* reader); | |||
CMsgReader* reader; | |||
rdr::ZlibInStream zis; | |||
}; |
@@ -46,11 +46,6 @@ IntParameter zlibLevel("ZlibLevel","Zlib compression level",-1); | |||
#undef CPIXEL | |||
#undef BPP | |||
Encoder* ZRLEEncoder::create(SMsgWriter* writer) | |||
{ | |||
return new ZRLEEncoder(writer); | |||
} | |||
ZRLEEncoder::ZRLEEncoder(SMsgWriter* writer_) | |||
: writer(writer_), zos(0,0,zlibLevel), mos(129*1024) | |||
{ |
@@ -26,12 +26,10 @@ namespace rfb { | |||
class ZRLEEncoder : public Encoder { | |||
public: | |||
static Encoder* create(SMsgWriter* writer); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
ZRLEEncoder(SMsgWriter* writer); | |||
virtual ~ZRLEEncoder(); | |||
virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual); | |||
private: | |||
ZRLEEncoder(SMsgWriter* writer); | |||
SMsgWriter* writer; | |||
rdr::ZlibOutStream zos; | |||
rdr::MemOutStream mos; |