From c01ea2e57c5c12d961cc916d24e814e67aa6ef20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc-Andr=C3=A9=20Moreau?= Date: Wed, 3 Aug 2011 23:33:44 -0400 Subject: [PATCH] cunit: added tests for bitmap caching orders --- cunit/test_orders.c | 219 +++++++++++++++++++++++++++++++++++++-- cunit/test_orders.h | 6 ++ include/freerdp/update.h | 37 +++++-- libfreerdp-core/orders.c | 179 +++++++++++++++++++++----------- libfreerdp-core/orders.h | 21 ++++ 5 files changed, 384 insertions(+), 78 deletions(-) diff --git a/cunit/test_orders.c b/cunit/test_orders.c index 325c01c48..2eb1187b2 100644 --- a/cunit/test_orders.c +++ b/cunit/test_orders.c @@ -49,6 +49,12 @@ int add_orders_suite(void) add_test_function(read_draw_nine_grid_order); add_test_function(read_line_to_order); add_test_function(read_glyph_index_order); + add_test_function(read_fast_index_order); + add_test_function(read_fast_glyph_order); + + add_test_function(read_cache_bitmap_order); + add_test_function(read_cache_bitmap_v2_order); + add_test_function(read_cache_bitmap_v3_order); return 0; } @@ -74,6 +80,8 @@ void test_read_dstblt_order(void) CU_ASSERT(dstblt.nWidth == 72); CU_ASSERT(dstblt.nHeight == 311); CU_ASSERT(dstblt.bRop == 0); + + CU_ASSERT(stream_get_length(s) == (sizeof(dstblt_order) - 1)); } uint8 patblt_order[] = "\x1a\x00\xc3\x01\x0d\x00\x0d\x00\xf0\xff\xff\x00\x5b\xef\x00\x81"; @@ -102,9 +110,11 @@ void test_read_patblt_order(void) CU_ASSERT(patblt.brushOrgX == 0); CU_ASSERT(patblt.brushOrgY == 0); CU_ASSERT(patblt.brushStyle == (BMF_1BPP | CACHED_BRUSH)); + + CU_ASSERT(stream_get_length(s) == (sizeof(patblt_order) - 1)); } -uint8 scrblt_order[] = "\x07\x00\xa1\x01\xf1\x00\xcc\x2f\x01\x8e"; +uint8 scrblt_order[] = "\x07\x00\xa1\x01\xf1\x00\xcc\x2f\x01\x8e\x00"; void test_read_scrblt_order(void) { @@ -127,6 +137,8 @@ void test_read_scrblt_order(void) CU_ASSERT(scrblt.bRop == 204); CU_ASSERT(scrblt.nXSrc == 303); CU_ASSERT(scrblt.nYSrc == 142); + + CU_ASSERT(stream_get_length(s) == (sizeof(scrblt_order) - 1)); } uint8 opaque_rect_order[] = "\x00\x04\x00\x03\x73\x02\x06"; @@ -140,7 +152,7 @@ void test_read_opaque_rect_order(void) s->p = s->data = opaque_rect_order; memset(orderInfo, 0, sizeof(ORDER_INFO)); - orderInfo->fieldFlags = 0x3C; + orderInfo->fieldFlags = 0x7C; memset(&opaque_rect, 0, sizeof(OPAQUE_RECT_ORDER)); update_read_opaque_rect_order(s, orderInfo, &opaque_rect); @@ -149,9 +161,12 @@ void test_read_opaque_rect_order(void) CU_ASSERT(opaque_rect.nTopRect == 0); CU_ASSERT(opaque_rect.nWidth == 1024); CU_ASSERT(opaque_rect.nHeight == 768); + CU_ASSERT(opaque_rect.color == 0x00060273); + + CU_ASSERT(stream_get_length(s) == (sizeof(opaque_rect_order) - 1)); } -uint8 draw_nine_grid_order[] = "\xfb\xf9\x0d"; +uint8 draw_nine_grid_order[] = "\xfb\xf9\x0d\x00"; void test_read_draw_nine_grid_order(void) { @@ -180,6 +195,8 @@ void test_read_draw_nine_grid_order(void) CU_ASSERT(draw_nine_grid.srcRight == 33); CU_ASSERT(draw_nine_grid.srcBottom == 33); CU_ASSERT(draw_nine_grid.bitmapId == 13); + + CU_ASSERT(stream_get_length(s) == (sizeof(draw_nine_grid_order) - 1)); } uint8 line_to_order[] = "\x03\xb1\x0e\xa6\x5b\xef\x00"; @@ -217,16 +234,18 @@ void test_read_line_to_order(void) CU_ASSERT(line_to.penStyle == 0); CU_ASSERT(line_to.penWidth == 0); CU_ASSERT(line_to.penColor == 0x00EF5B); + + CU_ASSERT(stream_get_length(s) == (sizeof(line_to_order) - 1)); } uint8 glyph_index_order_1[] = - "\x6a\x02\x27\x38\x00\x39\x07\x3a\x06\x3b\x07\x3c\x06\x3d\x06\x18" - "\x04\x1f\x06\x17\x02\x14\x04\x1b\x06\x19\x06\x45\x05\x18\x06\x1f" - "\x06\x1f\x02\x14\x02\x46\x06\xff\x15\x24"; + "\x6a\x02\x27\x38\x00\x39\x07\x3a\x06\x3b\x07\x3c\x06\x3d\x06\x18" + "\x04\x1f\x06\x17\x02\x14\x04\x1b\x06\x19\x06\x45\x05\x18\x06\x1f" + "\x06\x1f\x02\x14\x02\x46\x06\xff\x15\x24"; uint8 glyph_index_order_2[] = - "\x00\xff\xff\xff\x0c\x02\x6e\x01\x4d\x02\x7b\x01\x09\x02\x6e\x01" - "\xf6\x02\x7b\x01\x0c\x02\x79\x01\x03\xfe\x04\x00"; + "\x00\xff\xff\xff\x0c\x02\x6e\x01\x4d\x02\x7b\x01\x09\x02\x6e\x01" + "\xf6\x02\x7b\x01\x0c\x02\x79\x01\x03\xfe\x04\x00"; void test_read_glyph_index_order(void) { @@ -246,6 +265,8 @@ void test_read_glyph_index_order(void) CU_ASSERT(glyph_index.bkRight == 618); + CU_ASSERT(stream_get_length(s) == (sizeof(glyph_index_order_1) - 1)); + s->p = s->data = glyph_index_order_2; memset(orderInfo, 0, sizeof(ORDER_INFO)); @@ -268,4 +289,186 @@ void test_read_glyph_index_order(void) CU_ASSERT(glyph_index.opBottom == 379); CU_ASSERT(glyph_index.x == 524); CU_ASSERT(glyph_index.y == 377); + + CU_ASSERT(stream_get_length(s) == (sizeof(glyph_index_order_2) - 1)); } + +uint8 fast_index_order[] = + "\x07\x00\x03\xff\xff\x00\x74\x3b\x00\x0e\x00\x71\x00\x42\x00\x7e" + "\x00\x00\x80\x7c\x00\x15\x00\x00\x01\x06\x02\x04\x03\x08\x05\x09" + "\x06\x06\x06\x06\x07\x06\x08\x02\xff\x00\x12"; + +void test_read_fast_index_order(void) +{ + STREAM* s; + FAST_INDEX_ORDER fast_index; + + s = stream_new(0); + s->p = s->data = fast_index_order; + + memset(orderInfo, 0, sizeof(ORDER_INFO)); + orderInfo->fieldFlags = 0x70FF; + + update_read_fast_index_order(s, orderInfo, &fast_index); + + CU_ASSERT(fast_index.cacheId == 7); + CU_ASSERT(fast_index.flAccel == 3); + CU_ASSERT(fast_index.ulCharInc == 0); + CU_ASSERT(fast_index.backColor == 0x0000FFFF); + CU_ASSERT(fast_index.foreColor == 0x00003B74); + CU_ASSERT(fast_index.bkLeft == 14); + CU_ASSERT(fast_index.bkTop == 113); + CU_ASSERT(fast_index.bkRight == 66); + CU_ASSERT(fast_index.bkBottom == 126); + CU_ASSERT(fast_index.opLeft == 0); + CU_ASSERT(fast_index.opTop == 0); + CU_ASSERT(fast_index.opRight == 0); + CU_ASSERT(fast_index.opBottom == 0); + CU_ASSERT(fast_index.x == -32768); + CU_ASSERT(fast_index.y == 124); + + CU_ASSERT(stream_get_length(s) == (sizeof(fast_index_order) - 1)); +} + +uint8 fast_glyph_order[] = + "\x06\x00\x03\xff\xff\x00\x8b\x00\xb1\x00\x93\x00\xbe\x00\x0d\x00" + "\xfe\x7f\x00\x80\x00\x80\xbb\x00\x13\x00\x01\x4a\x06\x0a\x80\x80" + "\x80\xb8\xc4\x84\x84\x84\x84\x84\x00\x00\x68\x00"; + +void test_read_fast_glyph_order(void) +{ + STREAM* s; + FAST_GLYPH_ORDER fast_glyph; + + s = stream_new(0); + s->p = s->data = fast_glyph_order; + + memset(orderInfo, 0, sizeof(ORDER_INFO)); + orderInfo->fieldFlags = 0x7EFB; + orderInfo->boundLeft = 139; + orderInfo->boundTop = 177; + orderInfo->boundRight = 1068; + orderInfo->boundBottom = 189; + + memset(&fast_glyph, 0, sizeof(FAST_GLYPH_ORDER)); + + update_read_fast_glyph_order(s, orderInfo, &fast_glyph); + + CU_ASSERT(fast_glyph.backColor == 0); + CU_ASSERT(fast_glyph.foreColor == 0x0000FFFF); + CU_ASSERT(fast_glyph.bkLeft == 139); + CU_ASSERT(fast_glyph.bkTop == 177); + CU_ASSERT(fast_glyph.bkRight == 147); + CU_ASSERT(fast_glyph.bkBottom == 190); + CU_ASSERT(fast_glyph.opLeft == 0); + CU_ASSERT(fast_glyph.opTop == 13); + CU_ASSERT(fast_glyph.opRight == 32766); + CU_ASSERT(fast_glyph.opBottom == -32768); + CU_ASSERT(fast_glyph.x == -32768); + CU_ASSERT(fast_glyph.y == 187); + + CU_ASSERT(stream_get_length(s) == (sizeof(fast_glyph_order) - 1)); +} + +uint8 cache_bitmap_order[] = "\x00\x00\x10\x01\x08\x01\x00\x00\x00\x10"; + +void test_read_cache_bitmap_order(void) +{ + STREAM* s; + uint16 extraFlags; + CACHE_BITMAP_ORDER cache_bitmap; + + s = stream_new(0); + extraFlags = 0x0400; + s->p = s->data = cache_bitmap_order; + + memset(&cache_bitmap, 0, sizeof(CACHE_BITMAP_ORDER)); + + update_read_cache_bitmap_order(s, &cache_bitmap, True, extraFlags); + + CU_ASSERT(cache_bitmap.cacheId == 0); + CU_ASSERT(cache_bitmap.bitmapWidth == 16); + CU_ASSERT(cache_bitmap.bitmapHeight == 1); + CU_ASSERT(cache_bitmap.bitmapBpp == 8); + CU_ASSERT(cache_bitmap.bitmapLength == 1); + CU_ASSERT(cache_bitmap.cacheIndex == 0); + + CU_ASSERT(stream_get_length(s) == (sizeof(cache_bitmap_order) - 1)); +} + +uint8 cache_bitmap_v2_order[] = + "\x20\x40\xdc\xff\xff\x85\xff\xff\x99\xd6\x99\xd6\x99\xd6\x99\xd6" + "\x06\x8b\x99\xd6\x99\xd6\x99\xd6\x10\x84\x08\x42\x08\x42\x10\x84" + "\x99\xd6\x99\xd6\x99\xd6\x99\xd6\x06\x84\x99\xd6\x99\xd6\x99\xd6" + "\xff\xff\x16\x69\x99\xd6\x06\x69\x99\xd6\x04\xcc\x89\x52\x03\x6e" + "\xff\xff\x02\x6e\x08\x42\x01\x70\x08\x42\x71\xff\xff\xce\x18\xc6" + "\x01\x81\x08\x42\xce\x66\x29\x02\xcd\x89\x52\x03\x88\x10\x84\x99" + "\xd6\x99\xd6\x99\xd6\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x99\xd6" + "\x03\xf8\x01\x00\x00\x00\x00\xf0\x66\x99\xd6\x05\x6a\x99\xd6\x00" + "\xc4\xcc\x89\x52\x03\x6e\xff\xff\x02\x6e\x08\x42\x01\x70\x08\x42" + "\x71\xff\xff\xce\x18\xc6\x01\x81\x08\x42\xce\x66\x29\x02\xcd\x89" + "\x52\x03\x00\x04\xd6\x99\xd6\xc3\x80\x61\x00\xa5\x80\x40\xec\x52" + "\x00\x5a\x00\x2d\x00\x24\x00\x12\x00\x24\x00\x12\x00\x5a\x00\x2d" + "\x00\xa5\x80\x52\x00\xc3\x80\x61\x00\x00\x00\x00\x00\xcc\x89\x52" + "\x03\x6e\xff\xff\x02\xcb\x18\xc6\x84\x08\x42\x08\x42\x08\x42\xff" + "\xff"; + +void test_read_cache_bitmap_v2_order(void) +{ + STREAM* s; + uint16 extraFlags; + CACHE_BITMAP_V2_ORDER cache_bitmap_v2; + + s = stream_new(0); + extraFlags = 0x0CA1; + s->p = s->data = cache_bitmap_v2_order; + + memset(&cache_bitmap_v2, 0, sizeof(CACHE_BITMAP_V2_ORDER)); + + update_read_cache_bitmap_v2_order(s, &cache_bitmap_v2, True, extraFlags); + + CU_ASSERT(cache_bitmap_v2.cacheId == 1); + CU_ASSERT(cache_bitmap_v2.bitmapBpp == 16); + CU_ASSERT(cache_bitmap_v2.flags == 0x19); + CU_ASSERT(cache_bitmap_v2.bitmapWidth == 32); + CU_ASSERT(cache_bitmap_v2.bitmapHeight == 32); + CU_ASSERT(cache_bitmap_v2.bitmapLength == 220); + CU_ASSERT(cache_bitmap_v2.cacheIndex == 32767); + + CU_ASSERT(stream_get_length(s) == (sizeof(cache_bitmap_v2_order) - 1)); +} + +uint8 cache_bitmap_v3_order[] = + "\xff\x7f\x35\x50\xec\xbc\x74\x52\x65\xb7\x20\x00\x00\x00\x05\x00" + "\x02\x00\x28\x00\x00\x00\x5b\x4f\x45\xff\x5b\x4f\x45\xff\x5b\x4f" + "\x45\xff\x5b\x4f\x45\xff\x5b\x4f\x45\xff\x5b\x50\x45\xff\x5b\x50" + "\x45\xff\x5b\x50\x45\xff\x5b\x50\x45\xff\x5b\x50\x45\xff"; + +void test_read_cache_bitmap_v3_order(void) +{ + STREAM* s; + uint16 extraFlags; + CACHE_BITMAP_V3_ORDER cache_bitmap_v3; + + s = stream_new(0); + extraFlags = 0x0C30; + s->p = s->data = cache_bitmap_v3_order; + + memset(&cache_bitmap_v3, 0, sizeof(CACHE_BITMAP_V3_ORDER)); + + update_read_cache_bitmap_v3_order(s, &cache_bitmap_v3, True, extraFlags); + + CU_ASSERT(cache_bitmap_v3.cacheIndex == 32767); + CU_ASSERT(cache_bitmap_v3.key1 == 0xBCEC5035); + CU_ASSERT(cache_bitmap_v3.key2 == 0xB7655274); + CU_ASSERT(cache_bitmap_v3.bpp == 32); + + CU_ASSERT(cache_bitmap_v3.bitmapData.bpp == 32); + CU_ASSERT(cache_bitmap_v3.bitmapData.codecID == 0); + CU_ASSERT(cache_bitmap_v3.bitmapData.width == 5); + CU_ASSERT(cache_bitmap_v3.bitmapData.height == 2); + CU_ASSERT(cache_bitmap_v3.bitmapData.length == 40); + + CU_ASSERT(stream_get_length(s) == (sizeof(cache_bitmap_v3_order) - 1)); +} + diff --git a/cunit/test_orders.h b/cunit/test_orders.h index 02a8c7901..b90fcbbbc 100644 --- a/cunit/test_orders.h +++ b/cunit/test_orders.h @@ -30,3 +30,9 @@ void test_read_opaque_rect_order(void); void test_read_draw_nine_grid_order(void); void test_read_line_to_order(void); void test_read_glyph_index_order(void); +void test_read_fast_index_order(void); +void test_read_fast_glyph_order(void); + +void test_read_cache_bitmap_order(void); +void test_read_cache_bitmap_v2_order(void); +void test_read_cache_bitmap_v3_order(void); diff --git a/include/freerdp/update.h b/include/freerdp/update.h index e73654a60..17fe19abb 100644 --- a/include/freerdp/update.h +++ b/include/freerdp/update.h @@ -143,6 +143,7 @@ typedef struct sint16 nHeight; uint8 bRop; uint8 nDeltaEntries; + uint16 cbData; uint8* codeDeltaList; } MULTI_DSTBLT_ORDER; @@ -161,6 +162,7 @@ typedef struct uint8 brushHatch; uint8 brushExtra[7]; uint8 nDeltaEntries; + uint16 cbData; uint8* codeDeltaList; } MULTI_PATBLT_ORDER; @@ -174,6 +176,7 @@ typedef struct sint16 nXSrc; sint16 nYSrc; uint8 nDeltaEntries; + uint16 cbData; uint8* codeDeltaList; } MULTI_SCRBLT_ORDER; @@ -193,6 +196,7 @@ typedef struct sint16 nHeight; uint32 color; uint8 numRectangles; + uint16 cbData; DELTA_RECT rectangles[45]; } MULTI_OPAQUE_RECT_ORDER; @@ -204,6 +208,7 @@ typedef struct sint16 srcBottom; uint16 bitmapId; uint8 nDeltaEntries; + uint16 cbData; uint8* codeDeltaList; } MULTI_DRAW_NINE_GRID_ORDER; @@ -228,6 +233,7 @@ typedef struct uint8 bRop2; uint32 penColor; uint8 nDeltaEntries; + uint8 cbData; uint8* codeDeltaList; } POLYLINE_ORDER; @@ -297,6 +303,7 @@ typedef struct uint8 brushExtra[7]; sint16 x; sint16 y; + uint8 cbData; uint8* data; } GLYPH_INDEX_ORDER; @@ -315,8 +322,9 @@ typedef struct sint16 opTop; sint16 opRight; sint16 opBottom; - uint16 x; - uint16 y; + sint16 x; + sint16 y; + uint8 cbData; uint8* data; } FAST_INDEX_ORDER; @@ -335,8 +343,9 @@ typedef struct sint16 opTop; sint16 opRight; sint16 opBottom; - uint16 x; - uint16 y; + sint16 x; + sint16 y; + uint8 cbData; uint8* data; } FAST_GLYPH_ORDER; @@ -348,6 +357,7 @@ typedef struct uint8 fillMode; uint32 brushColor; uint8 nDeltaEntries; + uint8 cbData; uint8* codeDeltaList; } POLYGON_SC_ORDER; @@ -365,6 +375,7 @@ typedef struct uint8 brushHatch; uint8 brushExtra[7]; uint8 nDeltaEntries; + uint8 cbData; uint8* codeDeltaList; } POLYGON_CB_ORDER; @@ -417,14 +428,24 @@ typedef struct uint32 key1; uint32 key2; uint8 bitmapBpp; - uint8 bitmapWidth; - uint8 bitmapHeight; - uint16 bitmapLength; + uint16 bitmapWidth; + uint16 bitmapHeight; + uint32 bitmapLength; uint16 cacheIndex; uint8 bitmapComprHdr[8]; uint8* bitmapDataStream; } CACHE_BITMAP_V2_ORDER; +typedef struct +{ + uint8 bpp; + uint8 codecID; + uint16 width; + uint16 height; + uint32 length; + uint8* data; +} BITMAP_DATA_EX; + typedef struct { uint8 cacheId; @@ -433,7 +454,7 @@ typedef struct uint16 cacheIndex; uint32 key1; uint32 key2; - uint8* bitmapData; + BITMAP_DATA_EX bitmapData; } CACHE_BITMAP_V3_ORDER; typedef struct diff --git a/libfreerdp-core/orders.c b/libfreerdp-core/orders.c index e3df1d7a3..7a068d946 100644 --- a/libfreerdp-core/orders.c +++ b/libfreerdp-core/orders.c @@ -220,6 +220,50 @@ void update_read_2byte_signed(STREAM* s, sint16* value) *value *= -1; } +void update_read_4byte_unsigned(STREAM* s, uint32* value) +{ + uint8 byte; + uint8 count; + + stream_read_uint8(s, byte); + + count = (byte & 0xC0) >> 6; + + switch (count) + { + case 0: + *value = (byte & 0x3F); + break; + + case 1: + *value = (byte & 0x3F) << 8; + stream_read_uint8(s, byte); + *value |= byte; + break; + + case 2: + *value = (byte & 0x3F) << 16; + stream_read_uint8(s, byte); + *value |= (byte << 8); + stream_read_uint8(s, byte); + *value |= byte; + break; + + case 3: + *value = (byte & 0x3F) << 24; + stream_read_uint8(s, byte); + *value |= (byte << 16); + stream_read_uint8(s, byte); + *value |= (byte << 8); + stream_read_uint8(s, byte); + *value |= byte; + break; + + default: + break; + } +} + /* Primary Drawing Orders */ void update_read_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, DSTBLT_ORDER* dstblt) @@ -319,22 +363,24 @@ void update_read_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, OPAQUE_RECT if (orderInfo->fieldFlags & ORDER_FIELD_04) update_read_coord(s, &opaque_rect->nHeight, orderInfo->deltaCoordinates); + opaque_rect->color = 0; + if (orderInfo->fieldFlags & ORDER_FIELD_05) { stream_read_uint8(s, byte); - opaque_rect->color = (opaque_rect->color & 0xFFFFFF00) | byte; + opaque_rect->color = byte; } if (orderInfo->fieldFlags & ORDER_FIELD_06) { stream_read_uint8(s, byte); - opaque_rect->color = (opaque_rect->color & 0xFFFF00FF) | (byte << 8); + opaque_rect->color |= (byte << 8); } if (orderInfo->fieldFlags & ORDER_FIELD_07) { stream_read_uint8(s, byte); - opaque_rect->color = (opaque_rect->color & 0xFF00FFFF) | (byte << 16); + opaque_rect->color |= (byte << 16); } } @@ -358,8 +404,6 @@ void update_read_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, DRAW_NIN void update_read_multi_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DSTBLT_ORDER* multi_dstblt) { - uint16 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &multi_dstblt->nLeftRect, orderInfo->deltaCoordinates); @@ -380,15 +424,13 @@ void update_read_multi_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DSTB if (orderInfo->fieldFlags & ORDER_FIELD_07) { - stream_read_uint16(s, cbData); - stream_seek(s, cbData); + stream_read_uint16(s, multi_dstblt->cbData); + stream_seek(s, multi_dstblt->cbData); } } void update_read_multi_patblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_PATBLT_ORDER* multi_patblt) { - uint16 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &multi_patblt->nLeftRect, orderInfo->deltaCoordinates); @@ -430,15 +472,13 @@ void update_read_multi_patblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_PATB if (orderInfo->fieldFlags & ORDER_FIELD_14) { - stream_read_uint16(s, cbData); - stream_seek(s, cbData); + stream_read_uint16(s, multi_patblt->cbData); + stream_seek(s, multi_patblt->cbData); } } void update_read_multi_scrblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_SCRBLT_ORDER* multi_scrblt) { - uint16 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &multi_scrblt->nLeftRect, orderInfo->deltaCoordinates); @@ -465,15 +505,14 @@ void update_read_multi_scrblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_SCRB if (orderInfo->fieldFlags & ORDER_FIELD_09) { - stream_read_uint16(s, cbData); - stream_seek(s, cbData); + stream_read_uint16(s, multi_scrblt->cbData); + stream_seek(s, multi_scrblt->cbData); } } void update_read_multi_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect) { uint8 byte; - uint16 cbData; if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &multi_opaque_rect->nLeftRect, orderInfo->deltaCoordinates); @@ -519,7 +558,7 @@ void update_read_multi_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, MULTI rectangles = multi_opaque_rect->rectangles; zeroBitsSize = ((multi_opaque_rect->numRectangles + 1) / 2); - stream_read_uint16(s, cbData); + stream_read_uint16(s, multi_opaque_rect->cbData); stream_get_mark(s, zeroBits); stream_seek(s, zeroBitsSize); @@ -552,8 +591,6 @@ void update_read_multi_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, MULTI void update_read_multi_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid) { - uint16 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &multi_draw_nine_grid->srcLeft, orderInfo->deltaCoordinates); @@ -574,8 +611,8 @@ void update_read_multi_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, MU if (orderInfo->fieldFlags & ORDER_FIELD_07) { - stream_read_uint16(s, cbData); - stream_seek(s, cbData); + stream_read_uint16(s, multi_draw_nine_grid->cbData); + stream_seek(s, multi_draw_nine_grid->cbData); } } @@ -614,8 +651,6 @@ void update_read_line_to_order(STREAM* s, ORDER_INFO* orderInfo, LINE_TO_ORDER* void update_read_polyline_order(STREAM* s, ORDER_INFO* orderInfo, POLYLINE_ORDER* polyline) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &polyline->xStart, orderInfo->deltaCoordinates); @@ -633,8 +668,8 @@ void update_read_polyline_order(STREAM* s, ORDER_INFO* orderInfo, POLYLINE_ORDER if (orderInfo->fieldFlags & ORDER_FIELD_06) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, polyline->cbData); + stream_seek(s, polyline->cbData); } } @@ -742,8 +777,6 @@ void update_read_save_bitmap_order(STREAM* s, ORDER_INFO* orderInfo, SAVE_BITMAP void update_read_glyph_index_order(STREAM* s, ORDER_INFO* orderInfo, GLYPH_INDEX_ORDER* glyph_index) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) stream_read_uint8(s, glyph_index->cacheId); @@ -809,15 +842,13 @@ void update_read_glyph_index_order(STREAM* s, ORDER_INFO* orderInfo, GLYPH_INDEX if (orderInfo->fieldFlags & ORDER_FIELD_22) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, glyph_index->cbData); + stream_seek(s, glyph_index->cbData); } } void update_read_fast_index_order(STREAM* s, ORDER_INFO* orderInfo, FAST_INDEX_ORDER* fast_index) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) stream_read_uint8(s, fast_index->cacheId); @@ -865,15 +896,13 @@ void update_read_fast_index_order(STREAM* s, ORDER_INFO* orderInfo, FAST_INDEX_O if (orderInfo->fieldFlags & ORDER_FIELD_15) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, fast_index->cbData); + stream_seek(s, fast_index->cbData); } } void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_ORDER* fast_glyph) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) stream_read_uint8(s, fast_glyph->cacheId); @@ -921,15 +950,13 @@ void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_O if (orderInfo->fieldFlags & ORDER_FIELD_15) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, fast_glyph->cbData); + stream_seek(s, fast_glyph->cbData); } } void update_read_polygon_sc_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_SC_ORDER* polygon_sc) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &polygon_sc->xStart, orderInfo->deltaCoordinates); @@ -950,15 +977,13 @@ void update_read_polygon_sc_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_SC_O if (orderInfo->fieldFlags & ORDER_FIELD_07) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, polygon_sc->cbData); + stream_seek(s, polygon_sc->cbData); } } void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_ORDER* polygon_cb) { - uint8 cbData; - if (orderInfo->fieldFlags & ORDER_FIELD_01) update_read_coord(s, &polygon_cb->xStart, orderInfo->deltaCoordinates); @@ -997,8 +1022,8 @@ void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_O if (orderInfo->fieldFlags & ORDER_FIELD_13) { - stream_read_uint8(s, cbData); - stream_seek(s, cbData); + stream_read_uint8(s, polygon_cb->cbData); + stream_seek(s, polygon_cb->cbData); } } @@ -1077,8 +1102,8 @@ void update_read_cache_bitmap_order(STREAM* s, CACHE_BITMAP_ORDER* cache_bitmap_ stream_read_uint8(s, cache_bitmap_order->bitmapWidth); /* bitmapWidth (1 byte) */ stream_read_uint8(s, cache_bitmap_order->bitmapHeight); /* bitmapHeight (1 byte) */ stream_read_uint8(s, cache_bitmap_order->bitmapBpp); /* bitmapBpp (1 byte) */ - stream_read_uint8(s, cache_bitmap_order->bitmapLength); /* bitmapLength (2 bytes) */ - stream_read_uint8(s, cache_bitmap_order->cacheIndex); /* cacheIndex (2 bytes) */ + stream_read_uint16(s, cache_bitmap_order->bitmapLength); /* bitmapLength (2 bytes) */ + stream_read_uint16(s, cache_bitmap_order->cacheIndex); /* cacheIndex (2 bytes) */ if (compressed) { @@ -1103,17 +1128,30 @@ void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_b { uint8 bitsPerPixelId; - cache_bitmap_v2_order->cacheId = flags & 0x00000003; - cache_bitmap_v2_order->flags = (flags & 0x0000FF80) >> 7; + cache_bitmap_v2_order->cacheId = flags & 0x0003; + cache_bitmap_v2_order->flags = (flags & 0xFF80) >> 7; - bitsPerPixelId = (flags & 0x00000078) >> 3; + bitsPerPixelId = (flags & 0x0078) >> 3; cache_bitmap_v2_order->bitmapBpp = CBR2_BPP[bitsPerPixelId]; - stream_read_uint32(s, cache_bitmap_v2_order->key1); /* key1 (4 bytes) */ - stream_read_uint32(s, cache_bitmap_v2_order->key2); /* key2 (4 bytes) */ - stream_read_uint8(s, cache_bitmap_v2_order->bitmapWidth); /* bitmapWidth (1 byte) */ - stream_read_uint8(s, cache_bitmap_v2_order->bitmapHeight); /* bitmapHeight (1 byte) */ - stream_read_uint8(s, cache_bitmap_v2_order->bitmapLength); /* bitmapLength (2 bytes) */ + if (cache_bitmap_v2_order->flags & CBR2_PERSISTENT_KEY_PRESENT) + { + stream_read_uint32(s, cache_bitmap_v2_order->key1); /* key1 (4 bytes) */ + stream_read_uint32(s, cache_bitmap_v2_order->key2); /* key2 (4 bytes) */ + } + + if (cache_bitmap_v2_order->flags & CBR2_HEIGHT_SAME_AS_WIDTH) + { + update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapWidth); /* bitmapWidth */ + cache_bitmap_v2_order->bitmapHeight = cache_bitmap_v2_order->bitmapWidth; + } + else + { + update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapWidth); /* bitmapWidth */ + update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapHeight); /* bitmapHeight */ + } + + update_read_4byte_unsigned(s, &cache_bitmap_v2_order->bitmapLength); /* bitmapLength */ update_read_2byte_unsigned(s, &cache_bitmap_v2_order->cacheIndex); /* cacheIndex */ if (compressed) @@ -1137,7 +1175,9 @@ void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_b void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order, boolean compressed, uint16 flags) { + uint32 bitmapLength; uint8 bitsPerPixelId; + BITMAP_DATA_EX* bitmapData; cache_bitmap_v3_order->cacheId = flags & 0x00000003; cache_bitmap_v3_order->flags = (flags & 0x0000FF80) >> 7; @@ -1148,6 +1188,23 @@ void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_b stream_read_uint16(s, cache_bitmap_v3_order->cacheIndex); /* cacheIndex (2 bytes) */ stream_read_uint32(s, cache_bitmap_v3_order->key1); /* key1 (4 bytes) */ stream_read_uint32(s, cache_bitmap_v3_order->key2); /* key2 (4 bytes) */ + + bitmapData = &cache_bitmap_v3_order->bitmapData; + + stream_read_uint8(s, bitmapData->bpp); + stream_seek_uint8(s); /* reserved1 (1 byte) */ + stream_seek_uint8(s); /* reserved2 (1 byte) */ + stream_read_uint8(s, bitmapData->codecID); /* codecID (1 byte) */ + stream_read_uint16(s, bitmapData->width); /* width (2 bytes) */ + stream_read_uint16(s, bitmapData->height); /* height (2 bytes) */ + stream_read_uint32(s, bitmapData->length); /* length (4 bytes) */ + + if (bitmapData->data == NULL) + bitmapData->data = (uint8*) xmalloc(bitmapData->length); + else + bitmapData->data = (uint8*) xrealloc(bitmapData->data, bitmapData->length); + + stream_read(s, bitmapData->data, bitmapData->length); } void update_read_cache_color_table_order(STREAM* s, CACHE_COLOR_TABLE_ORDER* cache_color_table_order, uint16 flags) @@ -1477,16 +1534,14 @@ void update_recv_primary_order(rdpUpdate* update, STREAM* s, uint8 flags) if (flags & ORDER_BOUNDS) { if (!(flags & ORDER_ZERO_BOUNDS_DELTAS)) - { update_read_bounds(s, orderInfo); - bounds.left = orderInfo->boundLeft; - bounds.top = orderInfo->boundTop; - bounds.right = orderInfo->boundRight; - bounds.bottom = orderInfo->boundBottom; + bounds.left = orderInfo->boundLeft; + bounds.top = orderInfo->boundTop; + bounds.right = orderInfo->boundRight; + bounds.bottom = orderInfo->boundBottom; - IFCALL(update->SetBounds, update, &bounds); - } + IFCALL(update->SetBounds, update, &bounds); } orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) ? True : False; diff --git a/libfreerdp-core/orders.h b/libfreerdp-core/orders.h index 374ca3fee..69182be54 100644 --- a/libfreerdp-core/orders.h +++ b/libfreerdp-core/orders.h @@ -228,4 +228,25 @@ void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_O void update_read_ellipse_sc_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_SC_ORDER* ellipse_sc); void update_read_ellipse_cb_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_CB_ORDER* ellipse_cb); +void update_read_cache_bitmap_order(STREAM* s, CACHE_BITMAP_ORDER* cache_bitmap_order, boolean compressed, uint16 flags); +void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order, boolean compressed, uint16 flags); +void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order, boolean compressed, uint16 flags); +void update_read_cache_color_table_order(STREAM* s, CACHE_COLOR_TABLE_ORDER* cache_color_table_order, uint16 flags); +void update_read_cache_glyph_order(STREAM* s, CACHE_GLYPH_ORDER* cache_glyph_order, uint16 flags); +void update_read_cache_glyph_v2_order(STREAM* s, CACHE_GLYPH_V2_ORDER* cache_glyph_v2_order, uint16 flags); +void update_read_cache_brush_order(STREAM* s, CACHE_BRUSH_ORDER* cache_brush_order, uint16 flags); + +void update_read_create_offscreen_bitmap_order(STREAM* s, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap); +void update_read_switch_surface_order(STREAM* s, SWITCH_SURFACE_ORDER* switch_surface); +void update_read_create_nine_grid_bitmap_order(STREAM* s, CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap); +void update_read_frame_marker_order(STREAM* s, FRAME_MARKER_ORDER* frame_marker); +void update_read_stream_bitmap_first_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first); +void update_read_stream_bitmap_next_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_next); +void update_read_draw_gdiplus_first_order(STREAM* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first); +void update_read_draw_gdiplus_next_order(STREAM* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next); +void update_read_draw_gdiplus_end_order(STREAM* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end); +void update_read_draw_gdiplus_cache_first_order(STREAM* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first); +void update_read_draw_gdiplus_cache_next_order(STREAM* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next); +void update_read_draw_gdiplus_cache_end_order(STREAM* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end); + #endif /* __ORDERS_H */