mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cunit: added tests for bitmap caching orders

Browse Source
This commit is contained in:
Marc-André Moreau 2011-08-03 23:33:44 -04:00
parent 33bc8553c2
commit c01ea2e57c
5 changed files with 384 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
cunit/test_orders.c
View File

@ -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));
}

6
cunit/test_orders.h
View File

@ -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);

37
include/freerdp/update.h
View File

@ -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

179
libfreerdp-core/orders.c
View File

@ -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;

21
libfreerdp-core/orders.h
View File

@ -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 */