Move image encoding logic into a central EncodeManager class

This allows us to apply a lot more server logic
independently of which encoder is in use.

Most of this class are things moved over from the
Tight encoder.

1 files changed, 39 insertions, 99 deletions

diff --git a/common/rfb/TightEncoder.h b/common/rfb/TightEncoder.h
index 89d096b2..7bce2642 100644
--- a/common/rfb/TightEncoder.h
+++ b/common/rfb/TightEncoder.h
@@ -1,5 +1,6 @@
 /* Copyright (C) 2000-2003 Constantin Kaplinsky.  All Rights Reserved.
  * Copyright (C) 2011 D. R. Commander
+ * 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
@@ -22,120 +23,59 @@
 #include <rdr/MemOutStream.h>
 #include <rdr/ZlibOutStream.h>
 #include <rfb/Encoder.h>
-#include <rfb/JpegCompressor.h>
-#include <rfb/Palette.h>
-
-// FIXME: Check if specifying extern "C" is really necessary.
-#include <stdio.h>
-extern "C" {
-#include <jpeglib.h>
-}
 
 namespace rfb {
 
-  class PixelBuffer;
-
-  struct TIGHT_CONF {
-    unsigned int maxRectSize, maxRectWidth;
-    unsigned int monoMinRectSize;
-    int idxZlibLevel, monoZlibLevel, rawZlibLevel;
-    int idxMaxColorsDivisor;
-    int palMaxColorsWithJPEG;
-    int jpegQuality;
-    int jpegSubsampling;
-  };
-
-  //
-  // Compression level stuff. The following array contains various
-  // encoder parameters for each of 10 compression levels (0..9).
-  // Last three parameters correspond to JPEG quality levels (0..9).
-  //
-  // NOTE: s_conf[9].maxRectSize should be >= s_conf[i].maxRectSize,
-  // where i in [0..8]. RequiredBuffSize() method depends on this.
-  // FIXME: Is this comment obsolete?
-  //
-
-  
   class TightEncoder : public Encoder {
   public:
     TightEncoder(SConnection* conn);
     virtual ~TightEncoder();
 
-    virtual void setCompressLevel(int level);
-    virtual void setQualityLevel(int level);
-    virtual void setFineQualityLevel(int quality, int subsampling);
-    virtual int getNumRects(const Rect &r);
-    virtual void writeRect(const Rect& r, PixelBuffer* pb);
-
-  private:
-    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);
-    void sendRectSimple(const Rect& r);
-    void writeSubrect(const Rect& r, bool forceSolid = false);
-
-    void writeCompact(rdr::OutStream* os, rdr::U32 value);
-
-    void compressData(const void *buf, unsigned int length,
-                      rdr::ZlibOutStream *zos, int zlibLevel,
-                      rdr::OutStream *os);
+    virtual bool isSupported();
 
-    void fastFillPalette8(const rdr::U8 *data, int stride, const Rect &r);
-    void fastFillPalette16(const rdr::U16 *data, int stride, const Rect &r);
-    void fastFillPalette32(const rdr::U32 *data, int stride, const Rect &r);
-
-    void fillPalette8(rdr::U8 *data, int count);
-    void fillPalette16(rdr::U16 *data, int count);
-    void fillPalette32(rdr::U32 *data, int count);
-
-    unsigned int packPixels8(rdr::U8 *buf, unsigned int count);
-    unsigned int packPixels16(rdr::U16 *buf, unsigned int count);
-    unsigned int packPixels32(rdr::U32 *buf, unsigned int count);
-
-    void tightEncode8(const Rect& r, rdr::OutStream *os, bool forceSolid);
-    void tightEncode16(const Rect& r, rdr::OutStream *os, bool forceSolid);
-    void tightEncode32(const Rect& r, rdr::OutStream *os, bool forceSolid);
-
-    bool checkSolidTile8(Rect& r, rdr::U32 *colorPtr, bool needSameColor);
-    bool checkSolidTile16(Rect& r, rdr::U32 *colorPtr, bool needSameColor);
-    bool checkSolidTile32(Rect& r, rdr::U32 *colorPtr, bool needSameColor);
-
-    void encodeSolidRect8(rdr::U8 *buf, rdr::OutStream *os);
-    void encodeSolidRect16(rdr::U16 *buf, rdr::OutStream *os);
-    void encodeSolidRect32(rdr::U32 *buf, rdr::OutStream *os);
-
-    void encodeFullColorRect8(rdr::U8 *buf, const Rect& r, rdr::OutStream *os);
-    void encodeFullColorRect16(rdr::U16 *buf, const Rect& r, rdr::OutStream *os);
-    void encodeFullColorRect32(rdr::U32 *buf, const Rect& r, rdr::OutStream *os);
-
-    void encodeMonoRect8(rdr::U8 *buf, const Rect& r, rdr::OutStream *os);
-    void encodeMonoRect16(rdr::U16 *buf, const Rect& r, rdr::OutStream *os);
-    void encodeMonoRect32(rdr::U32 *buf, const Rect& r, rdr::OutStream *os);
+    virtual void setCompressLevel(int level);
 
-    void encodeIndexedRect16(rdr::U16 *buf, const Rect& r, rdr::OutStream *os);
-    void encodeIndexedRect32(rdr::U32 *buf, const Rect& r, rdr::OutStream *os);
+    virtual void writeRect(const PixelBuffer* pb, const Palette& palette);
+    virtual void writeSolidRect(int width, int height,
+                                const PixelFormat& pf,
+                                const rdr::U8* colour);
 
-    void encodeJpegRect16(rdr::U16 *buf, int stride, const Rect& r,
-                          rdr::OutStream *os);
-    void encodeJpegRect32(rdr::U32 *buf, int stride, const Rect& r,
-                          rdr::OutStream *os);
+  protected:
+    void writeMonoRect(const PixelBuffer* pb, const Palette& palette);
+    void writeIndexedRect(const PixelBuffer* pb, const Palette& palette);
+    void writeFullColourRect(const PixelBuffer* pb, const Palette& palette);
 
-    rdr::MemOutStream mos;
-    rdr::ZlibOutStream zos[4];
-    JpegCompressor jc;
-    PixelBuffer *pb;
-    PixelFormat serverpf, clientpf;
+    void writePixels(const rdr::U8* buffer, const PixelFormat& pf,
+                     unsigned int count, rdr::OutStream* os);
 
-    bool pack24;
-    int palMaxColors;
-    Palette palette;
+    void writeCompact(rdr::OutStream* os, rdr::U32 value);
 
-    static const int defaultCompressLevel;
-    static const TIGHT_CONF conf[];
+    rdr::OutStream* getZlibOutStream(int streamId, int level, size_t length);
+    void flushZlibOutStream(rdr::OutStream* os);
+
+  protected:
+    // Preprocessor generated, optimised methods
+    void writeMonoRect(int width, int height,
+                       const rdr::U8* buffer, int stride,
+                       const PixelFormat& pf, const Palette& palette);
+    void writeMonoRect(int width, int height,
+                       const rdr::U16* buffer, int stride,
+                       const PixelFormat& pf, const Palette& palette);
+    void writeMonoRect(int width, int height,
+                       const rdr::U32* buffer, int stride,
+                       const PixelFormat& pf, const Palette& palette);
+
+    void writeIndexedRect(int width, int height,
+                          const rdr::U16* buffer, int stride,
+                          const PixelFormat& pf, const Palette& palette);
+    void writeIndexedRect(int width, int height,
+                          const rdr::U32* buffer, int stride,
+                          const PixelFormat& pf, const Palette& palette);
+
+    rdr::ZlibOutStream zlibStreams[4];
+    rdr::MemOutStream memStream;
 
-    const TIGHT_CONF* pconf;
-    int jpegQuality;
-    int jpegSubsampling;
+    int idxZlibLevel, monoZlibLevel, rawZlibLevel;
   };
 
 }