Attachment #558340 for bug #840433

View | Details | Raw Unified | Return to bug 840433
Collapse All | Expand All





using namespace rfb;

rdr::MemOutStream* ZRLEEncoder::sharedMos = 0;
int ZRLEEncoder::maxLen = 4097 * 1024; // enough for width 16384 32-bit pixels

IntParameter zlibLevel("ZlibLevel","Zlib compression level",-1);

}

ZRLEEncoder::ZRLEEncoder(SMsgWriter* writer_)
  : writer(writer_), zos(0,0,zlibLevel), mos(129*1024)
{
  if (sharedMos)
    mos = sharedMos;
  else
    mos = new rdr::MemOutStream(129*1024);
}

ZRLEEncoder::~ZRLEEncoder()
{
  if (!sharedMos)
    delete mos;
}

bool ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
{
  rdr::U8* imageBuf = writer->getImageBuf(64 * 64 * 4 + 4);
  mos.clear();
  bool wroteAll = true;
  *actual = r;

  switch (writer->bpp()) {
  case 8:
    wroteAll = zrleEncode8(r, &mos, &zos, imageBuf, maxLen, actual, ig);
    break;
  case 16:
    wroteAll = zrleEncode16(r, &mos, &zos, imageBuf, maxLen, actual, ig);
    break;
  case 32:
    {

      if ((fitsInLS3Bytes && pf.isLittleEndian()) ||
          (fitsInMS3Bytes && pf.isBigEndian()))
      {
        wroteAll = zrleEncode24A(r, &mos, &zos, imageBuf, maxLen, actual, ig);
      }
      else if ((fitsInLS3Bytes && pf.isBigEndian()) ||
               (fitsInMS3Bytes && pf.isLittleEndian()))
      {
        wroteAll = zrleEncode24B(r, &mos, &zos, imageBuf, maxLen, actual, ig);
      }
      else
      {
        wroteAll = zrleEncode32(r, &mos, &zos, imageBuf, maxLen, actual, ig);
      }
      break;
    }


  writer->startRect(*actual, encodingZRLE);
  rdr::OutStream* os = writer->getOutStream();
  os->writeU32(mos.length());
  os->writeBytes(mos.data(), mos.length());
  writer->endRect();
  return wroteAll;
}




    // width, in this example about 128 bytes).
    static void setMaxLen(int m) { maxLen = m; }

    // setSharedMos() sets a MemOutStream to be shared amongst all
    // ZRLEEncoders.  Should be called before any ZRLEEncoders are created.
    static void setSharedMos(rdr::MemOutStream* mos_) { sharedMos = mos_; }

  private:
    ZRLEEncoder(SMsgWriter* writer);
    SMsgWriter* writer;
    rdr::MemOutStream mos;
    rdr::ZlibOutStream zos;
    rdr::MemOutStream* mos;
    static rdr::MemOutStream* sharedMos;
    static int maxLen;
  };
}

Return to bug 840433

Lines 26-32 Link Here

(-)tigervnc-1.3.0-orig/common/rfb/ZRLEEncoder.cxx (-16 / +9 lines)
26		26
27	using namespace rfb;	27	using namespace rfb;
28		28
29	rdr::MemOutStream* ZRLEEncoder::sharedMos = 0;
30	int ZRLEEncoder::maxLen = 4097 * 1024; // enough for width 16384 32-bit pixels	29	int ZRLEEncoder::maxLen = 4097 * 1024; // enough for width 16384 32-bit pixels
31		30
32	IntParameter zlibLevel("ZlibLevel","Zlib compression level",-1);	31	IntParameter zlibLevel("ZlibLevel","Zlib compression level",-1);
Lines 55-87 Link Here
55	}	54	}
56		55
57	ZRLEEncoder::ZRLEEncoder(SMsgWriter* writer_)	56	ZRLEEncoder::ZRLEEncoder(SMsgWriter* writer_)
58	: writer(writer_), zos(0,0,zlibLevel)	57	: writer(writer_), zos(0,0,zlibLevel), mos(129*1024)
59	{	58	{
60	if (sharedMos)
61	mos = sharedMos;
62	else
63	mos = new rdr::MemOutStream(129*1024);
64	}	59	}
65		60
66	ZRLEEncoder::~ZRLEEncoder()	61	ZRLEEncoder::~ZRLEEncoder()
67	{	62	{
68	if (!sharedMos)
69	delete mos;
70	}	63	}
71		64
72	bool ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)	65	bool ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
73	{	66	{
74	rdr::U8* imageBuf = writer->getImageBuf(64 * 64 * 4 + 4);	67	rdr::U8* imageBuf = writer->getImageBuf(64 * 64 * 4 + 4);
75	mos->clear();	68	mos.clear();
76	bool wroteAll = true;	69	bool wroteAll = true;
77	*actual = r;	70	*actual = r;
78		71
79	switch (writer->bpp()) {	72	switch (writer->bpp()) {
80	case 8:	73	case 8:
81	wroteAll = zrleEncode8(r, mos, &zos, imageBuf, maxLen, actual, ig);	74	wroteAll = zrleEncode8(r, &mos, &zos, imageBuf, maxLen, actual, ig);
82	break;	75	break;
83	case 16:	76	case 16:
84	wroteAll = zrleEncode16(r, mos, &zos, imageBuf, maxLen, actual, ig);	77	wroteAll = zrleEncode16(r, &mos, &zos, imageBuf, maxLen, actual, ig);
85	break;	78	break;
86	case 32:	79	case 32:
87	{	80	{
Lines 94-109 Link Here
94	if ((fitsInLS3Bytes && pf.isLittleEndian()) \|\|	87	if ((fitsInLS3Bytes && pf.isLittleEndian()) \|\|
95	(fitsInMS3Bytes && pf.isBigEndian()))	88	(fitsInMS3Bytes && pf.isBigEndian()))
96	{	89	{
97	wroteAll = zrleEncode24A(r, mos, &zos, imageBuf, maxLen, actual, ig);	90	wroteAll = zrleEncode24A(r, &mos, &zos, imageBuf, maxLen, actual, ig);
98	}	91	}
99	else if ((fitsInLS3Bytes && pf.isBigEndian()) \|\|	92	else if ((fitsInLS3Bytes && pf.isBigEndian()) \|\|
100	(fitsInMS3Bytes && pf.isLittleEndian()))	93	(fitsInMS3Bytes && pf.isLittleEndian()))
101	{	94	{
102	wroteAll = zrleEncode24B(r, mos, &zos, imageBuf, maxLen, actual, ig);	95	wroteAll = zrleEncode24B(r, &mos, &zos, imageBuf, maxLen, actual, ig);
103	}	96	}
104	else	97	else
105	{	98	{
106	wroteAll = zrleEncode32(r, mos, &zos, imageBuf, maxLen, actual, ig);	99	wroteAll = zrleEncode32(r, &mos, &zos, imageBuf, maxLen, actual, ig);
107	}	100	}
108	break;	101	break;
109	}	102	}
Lines 111-118 Link Here
111		104
112	writer->startRect(*actual, encodingZRLE);	105	writer->startRect(*actual, encodingZRLE);
113	rdr::OutStream* os = writer->getOutStream();	106	rdr::OutStream* os = writer->getOutStream();
114	os->writeU32(mos->length());	107	os->writeU32(mos.length());
115	os->writeBytes(mos->data(), mos->length());	108	os->writeBytes(mos.data(), mos.length());
116	writer->endRect();	109	writer->endRect();
117	return wroteAll;	110	return wroteAll;
118	}	111	}

Lines 38-53 Link Here

(-)tigervnc-1.3.0-orig/common/rfb/ZRLEEncoder.h (-6 / +1 lines)
38	// width, in this example about 128 bytes).	38	// width, in this example about 128 bytes).
39	static void setMaxLen(int m) { maxLen = m; }	39	static void setMaxLen(int m) { maxLen = m; }
40		40
41	// setSharedMos() sets a MemOutStream to be shared amongst all
42	// ZRLEEncoders. Should be called before any ZRLEEncoders are created.
43	static void setSharedMos(rdr::MemOutStream* mos_) { sharedMos = mos_; }
44
45	private:	41	private:
46	ZRLEEncoder(SMsgWriter* writer);	42	ZRLEEncoder(SMsgWriter* writer);
47	SMsgWriter* writer;	43	SMsgWriter* writer;
		44	rdr::MemOutStream mos;
48	rdr::ZlibOutStream zos;	45	rdr::ZlibOutStream zos;
49	rdr::MemOutStream* mos;
50	static rdr::MemOutStream* sharedMos;
51	static int maxLen;	46	static int maxLen;
52	};	47	};
53	}	48	}