void update_read_bitmap_data(STREAM* s, BITMAP_DATA* bitmap_data)
{
uint8* srcData;
uint16 dstSize;
boolean status;
uint16 bytesPerPixel;
stream_read_uint16(s, bitmap_data->left);
stream_read_uint16(s, bitmap_data->top);
stream_read_uint16(s, bitmap_data->right);
stream_read_uint16(s, bitmap_data->bottom);
stream_read_uint16(s, bitmap_data->width);
stream_read_uint16(s, bitmap_data->height);
stream_read_uint16(s, bitmap_data->bpp);
stream_read_uint16(s, bitmap_data->flags);
stream_read_uint16(s, bitmap_data->length);
bytesPerPixel = (bitmap_data->bpp + 7) / 8;
if (bitmap_data->flags & BITMAP_COMPRESSION)
{
uint16 cbCompMainBodySize;
uint16 cbUncompressedSize;
stream_seek_uint16(s); /* cbCompFirstRowSize (2 bytes) */
stream_read_uint16(s, cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
stream_seek_uint16(s); /* cbScanWidth (2 bytes) */
stream_read_uint16(s, cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
dstSize = cbUncompressedSize;
bitmap_data->length = cbCompMainBodySize;
bitmap_data->data = (uint8*) xzalloc(dstSize);
stream_get_mark(s, srcData);
stream_seek(s, bitmap_data->length);
status = bitmap_decompress(srcData, bitmap_data->data, bitmap_data->width, bitmap_data->height,
bitmap_data->length, bitmap_data->bpp, bitmap_data->bpp);
if (status != True)
printf("bitmap decompression failed, bpp:%d\n", bitmap_data->bpp);
}
else
{
int y;
int offset;
int scanline;
stream_get_mark(s, srcData);
dstSize = bitmap_data->length;
bitmap_data->data = (uint8*) xzalloc(dstSize);
scanline = bitmap_data->width * (bitmap_data->bpp / 8);
for (y = 0; y < bitmap_data->height; y++)
{
offset = (bitmap_data->height - y - 1) * scanline;
stream_read(s, &bitmap_data->data[offset], scanline);
}
}
}
void rdp_read_control_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint16(s); /* controlFlags (2 bytes) */
stream_seek_uint16(s); /* remoteDetachFlag (2 bytes) */
stream_seek_uint16(s); /* controlInterest (2 bytes) */
stream_seek_uint16(s); /* detachInterest (2 bytes) */
}
void rdp_read_window_activation_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint16(s); /* helpKeyFlag (2 bytes) */
stream_seek_uint16(s); /* helpKeyIndexFlag (2 bytes) */
stream_seek_uint16(s); /* helpExtendedKeyFlag (2 bytes) */
stream_seek_uint16(s); /* windowManagerKeyFlag (2 bytes) */
}
void rdp_read_order_capability_set(STREAM* s, rdpSettings* settings)
{
int i;
uint16 orderFlags;
uint8 orderSupport[32];
uint16 orderSupportExFlags;
stream_seek(s, 16); /* terminalDescriptor (16 bytes) */
stream_seek_uint32(s); /* pad4OctetsA (4 bytes) */
stream_seek_uint16(s); /* desktopSaveXGranularity (2 bytes) */
stream_seek_uint16(s); /* desktopSaveYGranularity (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */
stream_seek_uint16(s); /* maximumOrderLevel (2 bytes) */
stream_seek_uint16(s); /* numberFonts (2 bytes) */
stream_read_uint16(s, orderFlags); /* orderFlags (2 bytes) */
stream_read(s, orderSupport, 32); /* orderSupport (32 bytes) */
stream_seek_uint16(s); /* textFlags (2 bytes) */
stream_read_uint16(s, orderSupportExFlags); /* orderSupportExFlags (2 bytes) */
stream_seek_uint32(s); /* pad4OctetsB (4 bytes) */
stream_seek_uint32(s); /* desktopSaveSize (4 bytes) */
stream_seek_uint16(s); /* pad2OctetsC (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsD (2 bytes) */
stream_seek_uint16(s); /* textANSICodePage (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsE (2 bytes) */
for (i = 0; i < 32; i++)
{
if (orderSupport[i] == False)
settings->order_support[i] = False;
}
}
void rdp_read_glyph_cache_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek(s, 40); /* glyphCache (40 bytes) */
stream_seek_uint32(s); /* fragCache (4 bytes) */
stream_seek_uint16(s); /* glyphSupportLevel (2 bytes) */
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
}
boolean rdp_recv_client_font_map_pdu(rdpRdp* rdp, STREAM* s)
{
rdp->finalize_sc_pdus |= FINALIZE_SC_FONT_MAP_PDU;
stream_seek_uint16(s); /* numberEntries (2 bytes) */
stream_seek_uint16(s); /* totalNumEntries (2 bytes) */
stream_seek_uint16(s); /* mapFlags (2 bytes) */
stream_seek_uint16(s); /* entrySize (2 bytes) */
return true;
}
void update_read_bitmap_data(STREAM* s, BITMAP_DATA* bitmap_data)
{
uint8* srcData;
uint16 dstSize;
boolean status;
uint16 bytesPerPixel;
stream_read_uint16(s, bitmap_data->left);
stream_read_uint16(s, bitmap_data->top);
stream_read_uint16(s, bitmap_data->right);
stream_read_uint16(s, bitmap_data->bottom);
stream_read_uint16(s, bitmap_data->width);
stream_read_uint16(s, bitmap_data->height);
stream_read_uint16(s, bitmap_data->bpp);
stream_read_uint16(s, bitmap_data->flags);
stream_read_uint16(s, bitmap_data->length);
bytesPerPixel = (bitmap_data->bpp + 7) / 8;
if (bitmap_data->flags & BITMAP_COMPRESSION)
{
uint16 cbCompMainBodySize;
uint16 cbUncompressedSize;
stream_seek_uint16(s); /* cbCompFirstRowSize (2 bytes) */
stream_read_uint16(s, cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
stream_seek_uint16(s); /* cbScanWidth (2 bytes) */
stream_read_uint16(s, cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
dstSize = cbUncompressedSize;
bitmap_data->length = cbCompMainBodySize;
}
else
{
dstSize = bitmap_data->width * bitmap_data->height * bytesPerPixel;
}
stream_get_mark(s, srcData);
stream_seek(s, bitmap_data->length);
bitmap_data->data = (uint8*) xzalloc(dstSize);
//printf("bytesPerPixel:%d, width:%d, height:%d dstSize:%d flags:0x%04X\n",
// bytesPerPixel, bitmap_data->width, bitmap_data->height, dstSize, bitmap_data->flags);
status = bitmap_decompress(srcData, bitmap_data->data, bitmap_data->width, bitmap_data->height,
bitmap_data->length, bitmap_data->bpp, bitmap_data->bpp);
if (status != True)
printf("bitmap decompression failed\n");
}
void update_recv_orders(rdpUpdate* update, STREAM* s)
{
uint16 numberOrders;
stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */
stream_read_uint16(s, numberOrders); /* numberOrders (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsB (2 bytes) */
while (numberOrders > 0)
{
update_recv_order(update, s);
numberOrders--;
}
}
static void cliprdr_process_clip_caps(cliprdrPlugin* cliprdr, STREAM* s, uint16 length, uint16 flags)
{
int i;
uint16 lengthCapability;
uint16 cCapabilitiesSets;
uint16 capabilitySetType;
stream_read_uint16(s, cCapabilitiesSets); /* cCapabilitiesSets (2 bytes) */
stream_seek_uint16(s); /* pad1 (2 bytes) */
DEBUG_CLIPRDR("cCapabilitiesSets %d", cCapabilitiesSets);
for (i = 0; i < cCapabilitiesSets; i++)
{
stream_read_uint16(s, capabilitySetType); /* capabilitySetType (2 bytes) */
stream_read_uint16(s, lengthCapability); /* lengthCapability (2 bytes) */
switch (capabilitySetType)
{
case CB_CAPSTYPE_GENERAL:
cliprdr_process_general_capability(cliprdr, s);
break;
default:
DEBUG_WARN("unknown cliprdr capability set: %d", capabilitySetType);
break;
}
}
}
boolean rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s)
{
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
rdp_recv_server_redirection_pdu(rdp, s);
stream_seek_uint8(s); /* pad2Octets (1 byte) */
return true;
}
void rail_read_server_exec_result_order(STREAM* s, RAIL_EXEC_RESULT_ORDER* exec_result)
{
stream_read_uint16(s, exec_result->flags); /* flags (2 bytes) */
stream_read_uint16(s, exec_result->execResult); /* execResult (2 bytes) */
stream_read_uint32(s, exec_result->rawResult); /* rawResult (4 bytes) */
stream_seek_uint16(s); /* padding (2 bytes) */
rail_read_unicode_string(s, &exec_result->exeOrFile); /* exeOrFile */
}
void rdp_read_bitmap_capability_set(STREAM* s, rdpSettings* settings)
{
uint8 drawingFlags;
uint16 desktopWidth;
uint16 desktopHeight;
uint16 desktopResizeFlag;
uint16 preferredBitsPerPixel;
stream_read_uint16(s, preferredBitsPerPixel); /* preferredBitsPerPixel (2 bytes) */
stream_seek_uint16(s); /* receive1BitPerPixel (2 bytes) */
stream_seek_uint16(s); /* receive4BitsPerPixel (2 bytes) */
stream_seek_uint16(s); /* receive8BitsPerPixel (2 bytes) */
stream_read_uint16(s, desktopWidth); /* desktopWidth (2 bytes) */
stream_read_uint16(s, desktopHeight); /* desktopHeight (2 bytes) */
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
stream_read_uint16(s, desktopResizeFlag); /* desktopResizeFlag (2 bytes) */
stream_seek_uint16(s); /* bitmapCompressionFlag (2 bytes) */
stream_seek_uint8(s); /* highColorFlags (1 byte) */
stream_read_uint8(s, drawingFlags); /* drawingFlags (1 byte) */
stream_seek_uint16(s); /* multipleRectangleSupport (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsB (2 bytes) */
if (desktopResizeFlag == False)
settings->desktop_resize = False;
}
void rdp_read_sound_capability_set(STREAM* s, rdpSettings* settings)
{
uint16 soundFlags;
stream_read_uint16(s, soundFlags); /* soundFlags (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */
settings->sound_beeps = (soundFlags & SOUND_BEEPS_FLAG) ? True : False;
}
void update_read_synchronize(rdpUpdate* update, STREAM* s)
{
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
/**
* The Synchronize Update is an artifact from the
* T.128 protocol and should be ignored.
*/
}
static boolean rdpsnd_server_recv_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
int i;
if (stream_get_left(s) < 20)
return false;
stream_seek_uint32(s); /* dwFlags */
stream_seek_uint32(s); /* dwVolume */
stream_seek_uint32(s); /* dwPitch */
stream_seek_uint16(s); /* wDGramPort */
stream_read_uint16(s, rdpsnd->context.num_client_formats); /* wNumberOfFormats */
stream_seek_uint8(s); /* cLastBlockConfirmed */
stream_seek_uint16(s); /* wVersion */
stream_seek_uint8(s); /* bPad */
if (rdpsnd->context.num_client_formats > 0)
{
rdpsnd->context.client_formats = xzalloc(rdpsnd->context.num_client_formats * sizeof(rdpsndFormat));
for (i = 0; i < rdpsnd->context.num_client_formats; i++)
{
if (stream_get_left(s) < 18)
{
xfree(rdpsnd->context.client_formats);
rdpsnd->context.client_formats = NULL;
return false;
}
stream_read_uint16(s, rdpsnd->context.client_formats[i].wFormatTag);
stream_read_uint16(s, rdpsnd->context.client_formats[i].nChannels);
stream_read_uint32(s, rdpsnd->context.client_formats[i].nSamplesPerSec);
stream_seek_uint32(s); /* nAvgBytesPerSec */
stream_read_uint16(s, rdpsnd->context.client_formats[i].nBlockAlign);
stream_read_uint16(s, rdpsnd->context.client_formats[i].wBitsPerSample);
stream_read_uint16(s, rdpsnd->context.client_formats[i].cbSize);
if (rdpsnd->context.client_formats[i].cbSize > 0)
{
stream_seek(s, rdpsnd->context.client_formats[i].cbSize);
}
}
}
return true;
}
boolean rdp_recv_control_pdu(STREAM* s, uint16* action)
{
if (stream_get_left(s) < 8)
return false;
stream_read_uint16(s, *action); /* action (2 bytes) */
stream_seek_uint16(s); /* grantId (2 bytes) */
stream_seek_uint32(s); /* controlId (4 bytes) */
return true;
}
void rdp_read_share_data_header(STREAM* s, uint16* length, uint8* type, uint32* share_id)
{
/* Share Data Header */
stream_read_uint32(s, *share_id); /* shareId (4 bytes) */
stream_seek_uint8(s); /* pad1 (1 byte) */
stream_seek_uint8(s); /* streamId (1 byte) */
stream_read_uint16(s, *length); /* uncompressedLength (2 bytes) */
stream_read_uint8(s, *type); /* pduType2, Data PDU Type (1 byte) */
stream_seek_uint8(s); /* compressedType (1 byte) */
stream_seek_uint16(s); /* compressedLength (2 bytes) */
}
void rdp_read_bitmap_cache_host_support_capability_set(STREAM* s, rdpSettings* settings)
{
uint8 cacheVersion;
stream_read_uint8(s, cacheVersion); /* cacheVersion (1 byte) */
stream_seek_uint8(s); /* pad1 (1 byte) */
stream_seek_uint16(s); /* pad2 (2 bytes) */
if (cacheVersion & BITMAP_CACHE_V2)
settings->persistent_bitmap_cache = True;
}
void rdp_read_bitmap_cache_v2_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint16(s); /* cacheFlags (2 bytes) */
stream_seek_uint8(s); /* pad2 (1 byte) */
stream_seek_uint8(s); /* numCellCaches (1 byte) */
stream_seek(s, 4); /* bitmapCache0CellInfo (4 bytes) */
stream_seek(s, 4); /* bitmapCache1CellInfo (4 bytes) */
stream_seek(s, 4); /* bitmapCache2CellInfo (4 bytes) */
stream_seek(s, 4); /* bitmapCache3CellInfo (4 bytes) */
stream_seek(s, 4); /* bitmapCache4CellInfo (4 bytes) */
stream_seek(s, 12); /* pad3 (12 bytes) */
}
void rdp_recv_logon_info_v2(rdpRdp* rdp, STREAM* s)
{
uint32 cbDomain;
uint32 cbUserName;
stream_seek_uint16(s); /* version (2 bytes) */
stream_seek_uint32(s); /* size (4 bytes) */
stream_read_uint32(s, cbDomain); /* cbDomain (4 bytes) */
stream_read_uint32(s, cbUserName); /* cbUserName (4 bytes) */
stream_seek(s, 558); /* pad */
stream_seek(s, cbDomain); /* domain */
stream_seek(s, cbUserName); /* userName */
}
void rdp_read_input_capability_set(STREAM* s, rdpSettings* settings)
{
uint16 inputFlags;
stream_read_uint16(s, inputFlags); /* inputFlags (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */
stream_read_uint32(s, settings->kbd_layout); /* keyboardLayout (4 bytes) */
stream_read_uint32(s, settings->kbd_type); /* keyboardType (4 bytes) */
stream_read_uint32(s, settings->kbd_subtype); /* keyboardSubType (4 bytes) */
stream_read_uint32(s, settings->kbd_fn_keys); /* keyboardFunctionKeys (4 bytes) */
stream_seek(s, 64); /* imeFileName (64 bytes) */
if ((inputFlags & INPUT_FLAG_FASTPATH_INPUT) || (inputFlags & INPUT_FLAG_FASTPATH_INPUT2))
{
if (settings->fast_path_input != False)
settings->fast_path_input = True;
}
}
boolean rdp_recv_client_synchronize_pdu(rdpRdp* rdp, STREAM* s)
{
uint16 messageType;
rdp->finalize_sc_pdus |= FINALIZE_SC_SYNCHRONIZE_PDU;
if (stream_get_left(s) < 4)
return false;
stream_read_uint16(s, messageType); /* messageType (2 bytes) */
if (messageType != SYNCMSGTYPE_SYNC)
return false;
/* targetUser (2 bytes) */
stream_seek_uint16(s);
return true;
}
void rdp_read_bitmap_cache_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint32(s); /* pad1 (4 bytes) */
stream_seek_uint32(s); /* pad2 (4 bytes) */
stream_seek_uint32(s); /* pad3 (4 bytes) */
stream_seek_uint32(s); /* pad4 (4 bytes) */
stream_seek_uint32(s); /* pad5 (4 bytes) */
stream_seek_uint32(s); /* pad6 (4 bytes) */
stream_seek_uint16(s); /* Cache0Entries (2 bytes) */
stream_seek_uint16(s); /* Cache0MaximumCellSize (2 bytes) */
stream_seek_uint16(s); /* Cache1Entries (2 bytes) */
stream_seek_uint16(s); /* Cache1MaximumCellSize (2 bytes) */
stream_seek_uint16(s); /* Cache2Entries (2 bytes) */
stream_seek_uint16(s); /* Cache2MaximumCellSize (2 bytes) */
}
void rdp_read_general_capability_set(STREAM* s, rdpSettings* settings)
{
uint16 extraFlags;
uint8 refreshRectSupport;
uint8 suppressOutputSupport;
stream_seek_uint16(s); /* osMajorType (2 bytes) */
stream_seek_uint16(s); /* osMinorType (2 bytes) */
stream_seek_uint16(s); /* protocolVersion (2 bytes) */
stream_seek_uint16(s); /* pad2OctetsA (2 bytes) */
stream_seek_uint16(s); /* generalCompressionTypes (2 bytes) */
stream_read_uint16(s, extraFlags); /* extraFlags (2 bytes) */
stream_seek_uint16(s); /* updateCapabilityFlag (2 bytes) */
stream_seek_uint16(s); /* remoteUnshareFlag (2 bytes) */
stream_seek_uint16(s); /* generalCompressionLevel (2 bytes) */
stream_read_uint8(s, refreshRectSupport); /* refreshRectSupport (1 byte) */
stream_read_uint8(s, suppressOutputSupport); /* suppressOutputSupport (1 byte) */
if (refreshRectSupport == False)
settings->refresh_rect = False;
if (suppressOutputSupport == False)
settings->suppress_output = False;
}
void update_recv_pointer(rdpUpdate* update, STREAM* s)
{
uint16 messageType;
stream_read_uint16(s, messageType); /* messageType (2 bytes) */
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
switch (messageType)
{
case PTR_MSG_TYPE_POSITION:
update_read_pointer_position(s, &update->pointer_position);
IFCALL(update->PointerPosition, update, &update->pointer_position);
break;
case PTR_MSG_TYPE_SYSTEM:
update_read_pointer_system(s, &update->pointer_system);
IFCALL(update->PointerSystem, update, &update->pointer_system);
break;
case PTR_MSG_TYPE_COLOR:
update_read_pointer_color(s, &update->pointer_color);
IFCALL(update->PointerColor, update, &update->pointer_color);
break;
case PTR_MSG_TYPE_POINTER:
update_read_pointer_new(s, &update->pointer_new);
IFCALL(update->PointerNew, update, &update->pointer_new);
break;
case PTR_MSG_TYPE_CACHED:
update_read_pointer_cached(s, &update->pointer_cached);
IFCALL(update->PointerCached, update, &update->pointer_cached);
break;
default:
break;
}
}
void update_read_palette(rdpUpdate* update, STREAM* s, PALETTE_UPDATE* palette_update)
{
int i;
uint8 byte;
uint32 color;
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
stream_read_uint32(s, palette_update->number); /* numberColors (4 bytes), must be set to 256 */
if (palette_update->number > 256)
palette_update->number = 256;
/* paletteEntries */
for (i = 0; i < (int) palette_update->number; i++)
{
stream_read_uint8(s, byte);
color = byte;
stream_read_uint8(s, byte);
color |= (byte << 8);
stream_read_uint8(s, byte);
color |= (byte << 16);
palette_update->entries[i] = color;
}
}
/* receives a list of server supported formats and returns a list
of client supported formats */
static void rdpsnd_process_message_formats(rdpsndPlugin* rdpsnd, STREAM* data_in)
{
uint16 wNumberOfFormats;
uint16 nFormat;
uint16 wVersion;
STREAM* data_out;
rdpsndFormat* out_formats;
uint16 n_out_formats;
rdpsndFormat* format;
uint8* format_mark;
uint8* data_mark;
int pos;
rdpsnd_free_supported_formats(rdpsnd);
stream_seek_uint32(data_in); /* dwFlags */
stream_seek_uint32(data_in); /* dwVolume */
stream_seek_uint32(data_in); /* dwPitch */
stream_seek_uint16(data_in); /* wDGramPort */
stream_read_uint16(data_in, wNumberOfFormats);
stream_read_uint8(data_in, rdpsnd->cBlockNo); /* cLastBlockConfirmed */
stream_read_uint16(data_in, wVersion);
stream_seek_uint8(data_in); /* bPad */
DEBUG_SVC("wNumberOfFormats %d wVersion %d", wNumberOfFormats, wVersion);
if (wNumberOfFormats < 1)
{
DEBUG_WARN("wNumberOfFormats is 0");
return;
}
out_formats = (rdpsndFormat*)xzalloc(wNumberOfFormats * sizeof(rdpsndFormat));
n_out_formats = 0;
data_out = stream_new(24);
stream_write_uint8(data_out, SNDC_FORMATS); /* msgType */
stream_write_uint8(data_out, 0); /* bPad */
stream_seek_uint16(data_out); /* BodySize */
stream_write_uint32(data_out, TSSNDCAPS_ALIVE | TSSNDCAPS_VOLUME); /* dwFlags */
stream_write_uint32(data_out, 0xFFFFFFFF); /* dwVolume */
stream_write_uint32(data_out, 0); /* dwPitch */
stream_write_uint16_be(data_out, 0); /* wDGramPort */
stream_seek_uint16(data_out); /* wNumberOfFormats */
stream_write_uint8(data_out, 0); /* cLastBlockConfirmed */
stream_write_uint16(data_out, 6); /* wVersion */
stream_write_uint8(data_out, 0); /* bPad */
for (nFormat = 0; nFormat < wNumberOfFormats; nFormat++)
{
stream_get_mark(data_in, format_mark);
format = &out_formats[n_out_formats];
stream_read_uint16(data_in, format->wFormatTag);
stream_read_uint16(data_in, format->nChannels);
stream_read_uint32(data_in, format->nSamplesPerSec);
stream_seek_uint32(data_in); /* nAvgBytesPerSec */
stream_read_uint16(data_in, format->nBlockAlign);
stream_read_uint16(data_in, format->wBitsPerSample);
stream_read_uint16(data_in, format->cbSize);
stream_get_mark(data_in, data_mark);
stream_seek(data_in, format->cbSize);
format->data = NULL;
DEBUG_SVC("wFormatTag=%d nChannels=%d nSamplesPerSec=%d nBlockAlign=%d wBitsPerSample=%d",
format->wFormatTag, format->nChannels, format->nSamplesPerSec,
format->nBlockAlign, format->wBitsPerSample);
if (rdpsnd->fixed_format > 0 && rdpsnd->fixed_format != format->wFormatTag)
continue;
if (rdpsnd->fixed_channel > 0 && rdpsnd->fixed_channel != format->nChannels)
continue;
if (rdpsnd->fixed_rate > 0 && rdpsnd->fixed_rate != format->nSamplesPerSec)
continue;
if (rdpsnd->device && rdpsnd->device->FormatSupported(rdpsnd->device, format))
{
DEBUG_SVC("format supported.");
stream_check_size(data_out, 18 + format->cbSize);
stream_write(data_out, format_mark, 18 + format->cbSize);
if (format->cbSize > 0)
{
format->data = xmalloc(format->cbSize);
memcpy(format->data, data_mark, format->cbSize);
}
n_out_formats++;
}
}
rdpsnd->n_supported_formats = n_out_formats;
if (n_out_formats > 0)
{
rdpsnd->supported_formats = out_formats;
}
else
{
xfree(out_formats);
DEBUG_WARN("no formats supported");
}
pos = stream_get_pos(data_out);
stream_set_pos(data_out, 2);
stream_write_uint16(data_out, pos - 4);
stream_set_pos(data_out, 18);
stream_write_uint16(data_out, n_out_formats);
stream_set_pos(data_out, pos);
svc_plugin_send((rdpSvcPlugin*)rdpsnd, data_out);
if (wVersion >= 6)
{
data_out = stream_new(8);
stream_write_uint8(data_out, SNDC_QUALITYMODE); /* msgType */
stream_write_uint8(data_out, 0); /* bPad */
stream_write_uint16(data_out, 4); /* BodySize */
stream_write_uint16(data_out, HIGH_QUALITY); /* wQualityMode */
stream_write_uint16(data_out, 0); /* Reserved */
svc_plugin_send((rdpSvcPlugin*)rdpsnd, data_out);
}
}
void rdp_read_color_cache_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint16(s); /* colorTableCacheSize (2 bytes) */
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
}
boolean tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, STREAM* s)
{
int i;
uint32 cbFormat;
boolean ret = True;
memset(mediatype, 0, sizeof(TS_AM_MEDIA_TYPE));
/* MajorType */
DEBUG_DVC("MajorType:");
tsmf_print_guid(stream_get_tail(s));
for (i = 0; tsmf_major_type_map[i].type != TSMF_MAJOR_TYPE_UNKNOWN; i++)
{
if (memcmp(tsmf_major_type_map[i].guid, stream_get_tail(s), 16) == 0)
break;
}
mediatype->MajorType = tsmf_major_type_map[i].type;
if (mediatype->MajorType == TSMF_MAJOR_TYPE_UNKNOWN)
ret = False;
DEBUG_DVC("MajorType %s", tsmf_major_type_map[i].name);
stream_seek(s, 16);
/* SubType */
DEBUG_DVC("SubType:");
tsmf_print_guid(stream_get_tail(s));
for (i = 0; tsmf_sub_type_map[i].type != TSMF_SUB_TYPE_UNKNOWN; i++)
{
if (memcmp(tsmf_sub_type_map[i].guid, stream_get_tail(s), 16) == 0)
break;
}
mediatype->SubType = tsmf_sub_type_map[i].type;
if (mediatype->SubType == TSMF_SUB_TYPE_UNKNOWN)
ret = False;
DEBUG_DVC("SubType %s", tsmf_sub_type_map[i].name);
stream_seek(s, 16);
/* bFixedSizeSamples, bTemporalCompression, SampleSize */
stream_seek(s, 12);
/* FormatType */
DEBUG_DVC("FormatType:");
tsmf_print_guid(stream_get_tail(s));
for (i = 0; tsmf_format_type_map[i].type != TSMF_FORMAT_TYPE_UNKNOWN; i++)
{
if (memcmp(tsmf_format_type_map[i].guid, stream_get_tail(s), 16) == 0)
break;
}
mediatype->FormatType = tsmf_format_type_map[i].type;
if (mediatype->FormatType == TSMF_FORMAT_TYPE_UNKNOWN)
ret = False;
DEBUG_DVC("FormatType %s", tsmf_format_type_map[i].name);
stream_seek(s, 16);
/* cbFormat */
stream_read_uint32(s, cbFormat);
DEBUG_DVC("cbFormat %d", cbFormat);
#ifdef WITH_DEBUG_DVC
freerdp_hexdump(stream_get_tail(s), cbFormat);
#endif
switch (mediatype->FormatType)
{
case TSMF_FORMAT_TYPE_MFVIDEOFORMAT:
/* http://msdn.microsoft.com/en-us/library/aa473808.aspx */
stream_seek(s, 8); /* dwSize and ? */
stream_read_uint32(s, mediatype->Width); /* videoInfo.dwWidth */
stream_read_uint32(s, mediatype->Height); /* videoInfo.dwHeight */
stream_seek(s, 32);
/* videoInfo.FramesPerSecond */
stream_read_uint32(s, mediatype->SamplesPerSecond.Numerator);
stream_read_uint32(s, mediatype->SamplesPerSecond.Denominator);
stream_seek(s, 80);
stream_read_uint32(s, mediatype->BitRate); /* compressedInfo.AvgBitrate */
stream_seek(s, 36);
if (cbFormat > 176)
{
mediatype->ExtraDataSize = cbFormat - 176;
mediatype->ExtraData = stream_get_tail(s);
}
break;
case TSMF_FORMAT_TYPE_WAVEFORMATEX:
/* http://msdn.microsoft.com/en-us/library/dd757720.aspx */
stream_seek_uint16(s);
stream_read_uint16(s, mediatype->Channels);
stream_read_uint32(s, mediatype->SamplesPerSecond.Numerator);
mediatype->SamplesPerSecond.Denominator = 1;
stream_read_uint32(s, mediatype->BitRate);
mediatype->BitRate *= 8;
stream_read_uint16(s, mediatype->BlockAlign);
stream_read_uint16(s, mediatype->BitsPerSample);
stream_read_uint16(s, mediatype->ExtraDataSize);
if (mediatype->ExtraDataSize > 0)
mediatype->ExtraData = stream_get_tail(s);
break;
case TSMF_FORMAT_TYPE_MPEG2VIDEOINFO:
/* http://msdn.microsoft.com/en-us/library/dd390707.aspx */
i = tsmf_codec_parse_VIDEOINFOHEADER2(mediatype, s);
i += tsmf_codec_parse_BITMAPINFOHEADER(mediatype, s, True);
if (cbFormat > i)
{
mediatype->ExtraDataSize = cbFormat - i;
mediatype->ExtraData = stream_get_tail(s);
}
break;
case TSMF_FORMAT_TYPE_VIDEOINFO2:
i = tsmf_codec_parse_VIDEOINFOHEADER2(mediatype, s);
i += tsmf_codec_parse_BITMAPINFOHEADER(mediatype, s, False);
if (cbFormat > i)
{
mediatype->ExtraDataSize = cbFormat - i;
mediatype->ExtraData = stream_get_tail(s);
}
break;
default:
break;
}
if (mediatype->SamplesPerSecond.Numerator == 0)
mediatype->SamplesPerSecond.Numerator = 1;
if (mediatype->SamplesPerSecond.Denominator == 0)
mediatype->SamplesPerSecond.Denominator = 1;
return ret;
}
void rdp_read_font_capability_set(STREAM* s, rdpSettings* settings)
{
stream_seek_uint16(s); /* fontSupportFlags (2 bytes) */
stream_seek_uint16(s); /* pad2Octets (2 bytes) */
}