Get rid of the register mechanism for encoders and decoders

We have no use for it, so let's keep things simple.

common/rfb/CMsgWriter.cxx

 #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>

common/rfb/Decoder.cxx

 /* 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
  * USA.
  */
 #include <stdio.h>
-#include <rfb/Exception.h>
+#include <rfb/encodings.h>
 #include <rfb/Decoder.h>
 #include <rfb/RawDecoder.h>
 #include <rfb/RREDecoder.h>
 {
 }
 
-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;
+  }
 }

common/rfb/Decoder.h

 /* 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
 #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:
 
     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

common/rfb/Encoder.cxx

 /* 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
  * USA.
  */
 #include <stdio.h>
+#include <rfb/encodings.h>
 #include <rfb/Exception.h>
 #include <rfb/Encoder.h>
 #include <rfb/RawEncoder.h>
 {
 }
 
-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;
+  }
 }

common/rfb/Encoder.h

 /* 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
 #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:
 
     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

common/rfb/HextileDecoder.cxx

 #include <rfb/hextileDecode.h>
 #undef BPP
 
-Decoder* HextileDecoder::create(CMsgReader* reader)
-{
-  return new HextileDecoder(reader);
-}
-
 HextileDecoder::HextileDecoder(CMsgReader* reader_) : reader(reader_)
 {
 }

common/rfb/HextileDecoder.h

 
   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;
   };
 }

common/rfb/HextileEncoder.cxx

 #include <rfb/hextileEncodeBetter.h>
 #undef BPP
 
-Encoder* HextileEncoder::create(SMsgWriter* writer)
-{
-  return new HextileEncoder(writer);
-}
-
 HextileEncoder::HextileEncoder(SMsgWriter* writer_) : writer(writer_)
 {
 }

common/rfb/HextileEncoder.h

 
   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;
   };
 }

common/rfb/RREDecoder.cxx

 #include <rfb/rreDecode.h>
 #undef BPP
 
-Decoder* RREDecoder::create(CMsgReader* reader)
-{
-  return new RREDecoder(reader);
-}
-
 RREDecoder::RREDecoder(CMsgReader* reader_) : reader(reader_)
 {
 }

common/rfb/RREDecoder.h

 
   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;
   };
 }

common/rfb/RREEncoder.cxx

 #include <rfb/rreEncode.h>
 #undef BPP
 
-Encoder* RREEncoder::create(SMsgWriter* writer)
-{
-  return new RREEncoder(writer);
-}
-
 RREEncoder::RREEncoder(SMsgWriter* writer_) : writer(writer_)
 {
 }

common/rfb/RREEncoder.h

 
   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;
   };

common/rfb/RawDecoder.cxx

 
 using namespace rfb;
 
-Decoder* RawDecoder::create(CMsgReader* reader)
-{
-  return new RawDecoder(reader);
-}
-
 RawDecoder::RawDecoder(CMsgReader* reader_) : reader(reader_)
 {
 }

common/rfb/RawDecoder.h

 
   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;
   };
 }

common/rfb/RawEncoder.cxx

 
 using namespace rfb;
 
-Encoder* RawEncoder::create(SMsgWriter* writer)
-{
-  return new RawEncoder(writer);
-}
-
 RawEncoder::RawEncoder(SMsgWriter* writer_) : writer(writer_)
 {
 }

common/rfb/RawEncoder.h

 
   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;
   };
 }

common/rfb/TightDecoder.cxx

 #include <rfb/tightDecode.h>
 #undef BPP
 
-Decoder* TightDecoder::create(CMsgReader* reader)
-{
-  return new TightDecoder(reader);
-}
-
 TightDecoder::TightDecoder(CMsgReader* reader_) : reader(reader_)
 {
 }

common/rfb/TightDecoder.h

   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);
     void directFillRect16(const Rect& r, Pixel pix);
     void directFillRect32(const Rect& r, Pixel pix);
 
-    TightDecoder(CMsgReader* reader);
-
     CMsgReader* reader;
     CMsgHandler* handler;
     rdr::InStream* is;

common/rfb/TightEncoder.cxx

 #include <rfb/tightEncode.h>
 #undef BPP
 
-Encoder* TightEncoder::create(SMsgWriter* writer)
-{
-  return new TightEncoder(writer);
-} 
-
 TightEncoder::TightEncoder(SMsgWriter* writer_) : writer(writer_)
 {
   setCompressLevel(defaultCompressLevel);

common/rfb/TightEncoder.h

   
   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);

common/rfb/ZRLEDecoder.cxx

 #undef CPIXEL
 #undef BPP
 
-Decoder* ZRLEDecoder::create(CMsgReader* reader)
-{
-  return new ZRLEDecoder(reader);
-}
-
 ZRLEDecoder::ZRLEDecoder(CMsgReader* reader_) : reader(reader_)
 {
 }

common/rfb/ZRLEDecoder.h

 
   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;
   };

common/rfb/ZRLEEncoder.cxx

 #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)
 {

common/rfb/ZRLEEncoder.h

 
   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;