// encode source data
static std::string encode_source_data(const lmdb_source_data_t& data) {
// allocate space for the encoding
size_t max_size =
10
+ data.repository_name.size()
+ 10
+ data.filename.size()
+ 10
+ 10
+ data.binary_hash.size();
uint8_t encoding[max_size];
uint8_t* p = encoding;
// encode each field
p = lmdb_helper::encode_sized_string(data.repository_name, p);
p = lmdb_helper::encode_sized_string(data.filename, p);
p = lmdb_helper::encode_uint64(data.filesize, p);
p = lmdb_helper::encode_sized_string(data.binary_hash, p);
#ifdef DEBUG
std::string encoding_string(reinterpret_cast<char*>(encoding), (p-encoding));
std::cout << "encoding lmdb_source_data " << data << "\n"
<< " to binary data "
<< lmdb_helper::binary_hash_to_hex(encoding_string)
<< " size " << encoding_string.size() << "\n";
#endif
// return encoding
return std::string(reinterpret_cast<char*>(encoding), (p-encoding));
}
bool nuiHTML::Load(nglIStream& rStream, nglTextEncoding OverrideContentsEncoding, const nglString& rSourceURL)
{
if (!rSourceURL.IsEmpty())
SetSourceURL(rSourceURL);
int res = -1;
nglTextEncoding encoding = eUTF8;
TidyDoc tdoc = NULL;
{
HTMLStream strm(rStream);
tdoc = tidyCreate();
tidyOptSetBool(tdoc, TidyShowMarkup, no);
tidyOptSetBool(tdoc, TidyShowWarnings, no);
tidyOptSetInt(tdoc, TidyShowErrors, 0);
tidyOptSetBool(tdoc, TidyQuiet, yes);
tidySetCharEncoding(tdoc, "utf8");
TidyInputSource source;
tidyInitSource( &source, &strm, &HTMLStream::TidyGetByte, &HTMLStream::TidyUngetByte, &HTMLStream::TidyEOF);
res = tidyParseSource(tdoc, &source);
if ( res >= 0 )
res = tidyCleanAndRepair(tdoc); // Tidy it up!
if ( res >= 0 )
res = tidyRunDiagnostics(tdoc); // Kvetch
if (OverrideContentsEncoding == eEncodingUnknown)
{
nglString encoding_string(GetEncodingString(tidyGetRoot(tdoc)));
//ascii, latin1, raw, utf8, iso2022, mac, win1252, utf16le, utf16be, utf16, big5 shiftjis
encoding = nuiGetTextEncodingFromString(encoding_string);
}
else
{
encoding = OverrideContentsEncoding;
}
}
char* pStr = NULL;
if (encoding != eUTF8)
{
// Release the doc to create a new one
tidyRelease(tdoc);
nglOMemory omem;
rStream.SetPos(0, eStreamFromStart);
rStream.PipeTo(omem);
nglString decoded;
decoded.Import(omem.GetBufferData(), omem.GetSize(), encoding);
pStr = decoded.Export(eUTF8);
nglIMemory imem(pStr, strlen(pStr));
HTMLStream strm(imem);
tdoc = tidyCreate();
tidySetCharEncoding(tdoc, "utf8");
TidyInputSource source;
tidyInitSource( &source, &strm, &HTMLStream::TidyGetByte, &HTMLStream::TidyUngetByte, &HTMLStream::TidyEOF);
res = tidyParseSource(tdoc, &source);
if ( res >= 0 )
res = tidyCleanAndRepair(tdoc); // Tidy it up!
if ( res >= 0 )
res = tidyRunDiagnostics(tdoc); // Kvetch
}
BuildTree(tdoc, tidyGetRoot(tdoc), eUTF8, mComputeStyle);
tidyRelease(tdoc);
if (pStr)
free(pStr);
return res < 2;
}
static void rf_client_encodings_data(void)
{
CL_SLOT *cl = (CL_SLOT *)cur_slot;
int i;
int preferred_enc_set = 0;
CARD32 enc;
/* Reset encoding list (always enable raw encoding) */
cl->enc_enable[RFB_ENCODING_RAW] = 1;
cl->enc_prefer = RFB_ENCODING_RAW;
cl->compress_level = -1;
cl->jpeg_quality = -1;
cl->enable_lastrect = 0;
cl->enable_newfbsize = 0;
cl->enable_cliprects_enc = 0;
cl->enable_frame_sync = 0;
for (i = 1; i < NUM_ENCODINGS; i++)
cl->enc_enable[i] = 0;
/* Read and store encoding list supplied by the client */
for (i = 0; i < (int)cl->temp_count; i++) {
enc = buf_get_CARD32(&cur_slot->readbuf[i * sizeof(CARD32)]);
if (!preferred_enc_set) {
if ( enc == RFB_ENCODING_RAW ||
enc == RFB_ENCODING_HEXTILE ||
enc == RFB_ENCODING_RAW24 ||
enc == RFB_ENCODING_TIGHT ) {
cl->enc_prefer = enc;
preferred_enc_set = 1;
}
}
if (enc >= 0 && enc < NUM_ENCODINGS) {
cl->enc_enable[enc] = 1;
} else if (enc >= RFB_ENCODING_COMPESSLEVEL0 &&
enc <= RFB_ENCODING_COMPESSLEVEL9 &&
cl->compress_level == -1) {
cl->compress_level = (int)(enc - RFB_ENCODING_COMPESSLEVEL0);
log_write(LL_DETAIL, "Compression level %d requested by client %s",
cl->compress_level, cur_slot->name);
} else if (enc >= RFB_ENCODING_QUALITYLEVEL0 &&
enc <= RFB_ENCODING_QUALITYLEVEL9 &&
cl->jpeg_quality == -1) {
cl->jpeg_quality = (int)(enc - RFB_ENCODING_QUALITYLEVEL0);
log_write(LL_DETAIL, "JPEG quality level %d requested by client %s",
cl->jpeg_quality, cur_slot->name);
} else if (enc == RFB_ENCODING_LASTRECT) {
log_write(LL_DETAIL, "Client %s supports LastRect markers",
cur_slot->name);
cl->enable_lastrect = 1;
} else if (enc == RFB_ENCODING_NEWFBSIZE) {
cl->enable_newfbsize = 1;
log_write(LL_DETAIL, "Client %s supports desktop geometry changes",
cur_slot->name);
} else if (enc == RFB_ENCODING_CLIPRECTS) {
cl->enable_cliprects_enc = 1;
log_write(LL_DETAIL, "Client %s supports cliprects",
cur_slot->name);
} else if (enc == RFB_ENCODING_HALF_REZ) {
vnc_spu.half_rez = 1;
log_write(LL_DETAIL, "Client %s supports half rez",
cur_slot->name);
} else if (enc == RFB_ENCODING_FRAME_SYNC) {
cl->enable_frame_sync = 1;
vnc_spu.frame_drop = 0; /* can't drop frames if trying to sync! */
crDebug("Frame sync requested by client, disabling frame_drop");
log_write(LL_DETAIL, "Client %s supports frame sync encoding",
cur_slot->name);
}
}
if (cl->compress_level < 0)
cl->compress_level = 6; /* default compression level */
/* CopyRect was pending but the client does not want it any more. */
if (!cl->enc_enable[RFB_ENCODING_COPYRECT] &&
REGION_NOTEMPTY(&cl->copy_region)) {
REGION_UNION(&cl->pending_region, &cl->pending_region, &cl->copy_region);
REGION_EMPTY(&cl->copy_region);
}
crDebug("In rf_client_encodings_data(), cl->enc_prefer=0x%x pixel_size=%d",
cl->enc_prefer, vnc_spu.pixel_size);
if (cl->enc_prefer == RFB_ENCODING_RAW24) {
if (vnc_spu.pixel_size == 0 || vnc_spu.pixel_size == 24) {
/* not set, or already 24bpp */
vnc_spu.pixel_size = 24;
log_write(LL_DETAIL, "Using Raw24 encoding for client %s",
cur_slot->name);
}
else if (vnc_spu.pixel_size == 32) {
/* revert to regular 32bpp raw */
cl->enc_prefer = RFB_ENCODING_RAW;
log_write(LL_DETAIL, "Using Raw (32) encoding for client %s",
cur_slot->name);
}
}
else {
vnc_spu.pixel_size = 32;
}
if (cl->enc_prefer == RFB_ENCODING_TIGHT)
if (cl->jpeg_quality < 0)
cl->jpeg_quality = 6; /* default quality */
log_write(LL_DETAIL, "Using encoding %s (0x%x)",
encoding_string(cl->enc_prefer), cl->enc_prefer);
crDebug("VNC SPU: Using %s encoding (0x%x) for new client",
encoding_string(cl->enc_prefer), cl->enc_prefer);
if (cl->enc_prefer == RFB_ENCODING_TIGHT) {
crDebug("VNC SPU: Tight jpeg quality level %d, compression level %d",
cl->jpeg_quality, cl->compress_level);
crDebug("VNC SPU: Force JPEG encoding: %d", opt_force_tight_jpeg);
}
crDebug("VNC SPU: pixel_size = %d", vnc_spu.pixel_size);
aio_setread(rf_client_msg, NULL, 1);
}
